Java：多态

1、要想实现多态，需要满足几个条件

（1）继承关系上，向上转型
（2）子类和父类有同名的覆盖/重写方法
（3）通过父类对象的引用去调用这个重写方法
完成以上3部分，就会发生动态绑定，而动态绑定是多态的基础
父类只能调用自己特有的成员变量或方法，不能调用子类的

2、向上转型

向上转型：子类对象给父类对象的引用
（1）直接赋值

Animal animal = new Dog("李三",18);

（2）方法的参数，传参时向上转型

public static void func1(Animal animal){
}

public static void main(String[] args){
	Dog dog = new Dog("李三",18);
	func1(dog);
}

（3）方法返回值，向上转型

public static Animal func2(){
	Dog dog = new Dog("李三",18);
	return dog;
}

3、方法的重写

（1）继承关系上，方法名、方法返回值、方法参数链表一样
（2）子类中被重写的方法访问修饰限定符的权限大于等于父类的；因此被private修饰的方法是不能被重写的
（3）被static修饰的方法不能被重写
（4）被final修饰的方法不能被重写
（5）构造方法也不可被重写

class Animal{  
    String name;  
    int age;  
  
	public void eat(){
		System.out.println(this.name + "在吃东西");
	}
}  
  
class Dog extends Animal{  
	//这个标识用以检测重写方法有没有写错
	@Override
    public void eat(){
		System.out.println(this.name + "在吃狗粮");
	}
}

（6）协变：重写时，返回类型可以不同，但必须是父子关系

class Animal{  
    String name;  
    int age;  
  
	public Animal eat(){
		System.out.println(this.name + "在吃东西");
	}
}  
  
class Dog extends Animal{  
    public Dog eat(){
		System.out.println(this.name + "在吃狗粮");
	}
}

4、动态绑定

（1）在没有重写父类方法时，向上转型后调用的是父类的方法
如果子类重写了父类方法，向上转型后调用的是子类重写的方法
· 向上转型后的父类对象不能调用子类特有的方法
· 属性没有多态性，向上转型的父类只能调用自己的属性
· 构造方法没有多态性
（2）object类是所有类的父类
（3）动态绑定的实质：编译的时候调用的是父类的方法，运行时调用的是子类重写的方法
（4）而静态绑定在编译的时候就已经确定调用谁；重载方法使用的就是动态绑定

5、多态

当父类引用引用的子类对象不一样的时候，调用不同的重写方法，所表现出的行为是不一样的，这种思想就叫做多态

class Animal{  
    String name;  
    int age;  
  
	public Animal eat(){
		System.out.println(this.name + "在吃东西");
	}
}  
  
class Dog extends Animal{  
    public Dog eat(){
		System.out.println(this.name + "在吃狗粮");
	}
}

class Cat extends Animal{  
    public Cat eat(){
		System.out.println(this.name + "在吃猫粮");
	}
}

public class Test{

public static void eatFunc(Animal animal){
	animal.eat();
}

public static void main(String[] args){
	Dog dog = new Dog("李三",18);
	eatFunc(dog);

	Dog cat = new Cat("张四",24);
	eatFunc(cat);
}

}

6、向下转型

Animal animal = new Dog("李三",18);
Dog dog = (Dog)animal;
dog.bark();

向下转型不一定成功

Animal animal = new Dog("李三",18);
Cat cat = (Cat)animal;
cat.miaomiao();
//会报错，发生类型转换异常

向下转型非常不安全，因此我们用instanceof来进行判断

Animal animal = new Dog("李三",18);

if (animal instanceof Cat){
	Cat cat = (Cat)animal;
	cat.miaomiao();
}else {
	System.out.println("向下转型失败");
}
//这里会打印向下打印失败

7、构造方法实现动态绑定

在父类的构造方法当中，可以调用重写的方法，此时调用的是子类重写的方法，说明发生了动态绑定

class B{
	public B(){
		func();
	}
	public void func(){
		System.out.println("B");
	}
}

class D extends B{
	int num = 1;
	public void func(){
		System.out.println("D");
	}
}

public static void main(String[] args){
	D d = D();
}
//这里打印的是D，说明调用的是子类重写的方法
//这里实例化子类时，先构造父类，父类构造方法调用func，父类、子类都没构造完，因此子类中的num是0