Java-接口和多态

接口

接口Interface，接口和类的关系是实现，implements
Interface 接口名{
}

package com.it01;
/*
 * 	java用于处理继承的单一局限性---接口Interface，接口和类的关系是实现，implements
 * 
 *  	创建接口的格式
 *  		Interface 接口名{
 *  			}
 */
public class InterfaceDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BillGates bg =new BillGates();
		bg.code();
	}

}

class Boss{
	public void manage() {
		System.out.println("管理公司");
	}
}

class Programmer{
	public void code() {
		System.out.println("敲代码");
	}
}

class BillGates extends Programmer{
	
}

接口的成员特点：

• 只能有常量
• 常量使用public static final修饰
• 只能有抽象方法
• 成员方法默认使用public&abstract修饰

建议手动添加修饰符
注意：

-类和接口是实现关系
类和接口是实现关系—一个类实现一个接口必须实现它所有的方法
接口不能创建对象（实例化）

package com.it01;

public class InterfaceDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
//接口
interface Animal{
	public static  final int num=30;
	public abstract void eat();
}


//类和接口是实现关系
class Cat implements Animal{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("我要吃鱼");
	}
	
}

package com.it01;
/*
 * 	类与类的关系--继承关系，单一继承，多层继承
 * 	类与接口---实现关系,多实现
 * 	接口与接口的关系----可继承关系，多继承
 */
public class InterfaceDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

//接口
interface InterA{
	public abstract void method();
}

interface InterB{
	public abstract void method();
}

interface InterC extends InterA{
	public abstract void method();
}

class Demo implements InterA,InterB{

	@Override
	public void method() {
		// TODO Auto-generated method stub
		
	}
	
}

接口的优点：
1.类与接口的关系：实现关系，而且是多实现，一个类可以实现多个接口，类与类之间是继承关系，打破了继承的局限性。
2.对外提供规则，提供规范
3.降低了程序的耦合性，可以实现模块化开发，提高了开发效率

接口和抽象类的区别：

• [ 1] 共性：不断的抽取，抽取出抽象的概念
• [2]区别：
  1.与类的关系
  类与接口的关系：实现关系，而且是多实现，一个类可以实现多个接口，并把抽象方法全部实现
  类与类之间是继承关系，只能是单一继承和多层继承。
  2.成员
  成员变量：
  抽象类有成员变量和成员常量
  接口只能有常量
  成员方法：
  抽象类可以有抽象方法和非抽象方法
  接口只能有抽象类，而且方法修饰符有默认修饰符
  构造方法：
  抽象类有构造方法
  接口没有构造方法

接口案例
案例分析

案例代码

package com.it02;
/*
 * 	运动员案例
 * 	分析
 * 		由下至上    不断向上抽取
 * 	实现
 * 		由上至下    先实现共性
 */
public class InterfaceTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建篮球运动员和教练
		BasketballPlayer bp0 = new BasketballPlayer("王治郅",18,"男");
		BasketballPlayer bp = new BasketballPlayer();
		bp.name="郭艾伦";
		bp.age=29;
		bp.gender="男";
		bp.sleep();
		bp.study();
		bp.speak();
		
		BasketballCoach bc = new BasketballCoach();
		bc.name="姚明";
		bc.age=32;
		bc.gender="男";
		bc.sleep();
		bc.teach();;
		bc.speak();
		
		//创建乒乓球运动员和教练
		

	}

}

//人的类
class Person{
	String name;
	int age;
	String gender;
	
	//无参构造方法
	public Person() {
		// TODO Auto-generated constructor stub
		super();
	}

	
	
	//有参构造
	public Person(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//成员方法
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

//运动员
abstract class Player extends Person{
	
	public Player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Player(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	public abstract void study();
}

//教练员
abstract class Coach extends Person{
	
	public Coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Coach(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	public abstract void teach();
}
//英语
interface SpeakEnglish{
	public abstract void speak();
}

//实现类
//篮球运动员
class BasketballPlayer extends Player implements SpeakEnglish{
	
	


	public BasketballPlayer() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BasketballPlayer(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void study() {
		// TODO Auto-generated method stub
		System.out.println("学习扣篮");
	}

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("学英语");
		
	}
	
}
//乒乓球运动员
class PingpangPlayer extends Player{
	
	

	public PingpangPlayer() {
		super();
		// TODO Auto-generated constructor stub
	}

	public PingpangPlayer(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void study() {
		// TODO Auto-generated method stub
		System.out.println("学习抽球");
	}
	
}

//篮球教练
class BasketballCoach extends Coach implements SpeakEnglish{
	
	


	public BasketballCoach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BasketballCoach(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教扣篮");
	}

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("学英语");
	}
	
}

//乒乓球教练

class PingpangCoach extends Coach{

	
	public PingpangCoach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public PingpangCoach(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教抽球");
	}
	
}

匿名对象

package com.it03;
/*
 * 	匿名对象：没有名字的对象
 * 	匿名对象的应用场景：
 * 		当方法之带调用一次的时候可以使用匿名对象
 * 		可以当作参数进行传递，但是无法在传参之前做其他的事请
 * 		
 * 	注意：匿名对象可以创建成员变量并赋值，但没有意义
 */
public class AnonymousObjectDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Student s = new Student();
		//s.study();
		
		//new Student();//匿名对象，没有变量引用的对象
		new Student().study();
		new Student().study();
		new Student().study();
		
		//调用method方法
		method(new Student());
	}
	
	public static void method(Student s) {
		System.out.println("调用method方法");
	}

}

class Student{
	String name;
	int age;
	public void study() {
		System.out.println("学习是主要任务");
	}
}

final关键字

package com.it03;
/*
 * 	final：修饰符，可以用于修饰类、成员方法和成员变量
 * 	final所修饰的类，不能被继承，不能有子类
 * 	final所修饰的方法在子类中不能被重写
 * 	final所修饰的变量：不可以修改的，是常量
 * 
 * 	常量：
 * 		字面值常量
 * 		自定义常量：被final修饰的变量，一旦赋值不可修改（必须被初始化）
 */
public class FinalDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal a= new Animal();
		a.eat();
	}

}

final class Animal {
	public void eat() {
		System.out.println("吃东西");
	}
}

多态

多态的三个要素：

• 子父类继承关系
• 方法的重写
• 父类引用指向子类对象

动态绑定

• 运行期间-调用的方法是根据其具体的类型

package com.it04;

public class PoymorphicDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Cat c = new Cat();
		c.eat();
		
		//父类引用Animal a
		//指向=
		//子类对象new Cat()
		Animal a = new Cat();
		a.eat();
	}

}


class Animal{
	public void eat() {
		System.out.println("吃东西");
	}
}

class Cat extends Animal{
	//方法的重写
	public void eat() {
		System.out.println("猫吃?");
	}
}

多态的成员特点

1. 成员变量-编译时看到是左边，运行时也看得左边
2. 成员方法-编译时看到是左边，运行时也看得右边
3. 静态方法-编译时看到是左边，运行时也看得左边

编译时看的都是左边，运行时成员方法看的右边，其他看的左边

package com.it04;

public class PoymorphicDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dad d = new Kid();
		System.out.println(d.num);//20
		
		d.method();//我是父类方法
		
		d.function();//我是父类静态方法(使用变量去调用静态方法，其实相当于使用变量类型的类名去调用)
	}

}

class Dad {
	int num=20;
	public void method() {
		System.out.println("我是父类方法");
	}
	public static void function() {
		System.out.println("我是父类静态方法");
	}
}

class Kid extends Dad{
	int num=10;
	public void method() {
		System.out.println("我是子类方法");
	}
	public static void function() {
		System.out.println("我是子类静态方法");
	}
}

多态中的向上转型和向下转型

package com.it04;
/*
 * 	多态中的向上转型和向下转型
 * 	引用类型之间的转换
 * 		向上转型-由小到大
 * 		向下转型-由大到小
 * 
 * 	基本数据类型的转换
 * 		自动转换-由小到大
 * 		强制类型转换-由大到小
 */
public class PoymorphicDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animals a = new Dog();//向上转型
		
		a.eat();
		
		Dog d = (Dog)a;//向下转型
		d.eat();
		d.swim();
	}

}

class Animals{
	public void eat() {
		System.out.println("吃东西");
	}
}

class Dog extends Animals{
	public void eat() {
		System.out.println("啃骨头");
	}
	
	public void swim() {
		System.out.println("狗刨");
	}
}

多态的优缺点

• 缺点：
  无法直接访问子类特有的成员

• 优点：
  可以提高可维护性
  提高代码的可扩展性

package com.it04;
/*
 * 	多态可以提高代码的可扩展性
 */
public class PoymorphicDemo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建工厂类对象
		Factory f = new Factory();
		f.CreatPhone(new HuaWei());
		f.CreatPhone(new XiaoMi());
	}

}

//定义接口
interface Phone{
	public void call();
}

class HuaWei implements Phone{

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("华为手机，中华有为");
	}
	
}

class XiaoMi implements Phone{

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("小米手机，性价比之王");
	}
	
}

//定义生产手机的工厂类
class Factory {
	public void CreatPhone(Phone p) {
		p.call();
	}
}