多态学习笔记

多态

什么是多态？

多态概述

​ 多态：同一对象在不同情况下，表现出不同的状态或行为。多态是面向对象的三大特性之一（封装、继承、多态），多态体现为父类引用变量可以指向子类对象。

实现多态的步骤

​ 1.要有继承（或实现）的关系

​ 2.要有方法重写

​ 3.父类引用指向子类对象

语法格式

​ 父类类型 变量名 = new 子类类型()，代码举例如下

Parent p = new Child();

多态的使用场景

父类型变量作为参数时，可以接受任意子类对象。

class Animal {
	...
}
class Cat extends Animal{
	...
}
class Dog extends Animal{
	...
}

public class Test{
	public static void show(Cat c){
		...
	}
	public static void main(String[] args) {
	    	Cat cat = new Cat();
			Dog dog = new Dog();
		    show(cat);//没问题，因为show（）方法参数是Cat类型
		    show(dog);//报错
	}
}

把参数改为父类型

public static void show(Animal animal){
	...
}
public static void main(String[] args) {
    	Cat cat = new Cat();
		Dog dog = new Dog();
	    show(cat);//没问题，接受子类对象
	    show(dog);//没问题，接受子类对象
}

多态中成员变量的使用

​ 多态中使用成员变量，编译时看左边类型中有没有改成员变量，没有则报错。运行也是使用左边类型中的成员变量。

public class Test{
	public static void main(String[] args) {
	Animal animal = new Cat();
	System.out.println(animal.name);
	}

}
class Animal {	
	String name = "动物";
}
class Cat extends Animal {
	String name = "猫";
}
/*程序运行结果
动物
*/

结论：多态中成员变量不涉及到重写

多态中方法的调用

多态中调用成员方法，编译时看左边类有没有这个成员，运行时用的是右边类中的方法（重写覆盖）

public class Test1 {
    public static void main(String[] args) {           
      Animal a = new Cat();  
      a.eat();  		//用变量a调用eat方法	
      show(new Cat());  // 以 Cat 对象调用 show 方法
  }  
            
    public static void show(Animal a)  {
      a.eat();   
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
} 
  

输出结果

吃鱼
吃鱼

多态中的转型

​ 在多态中，不能直接使用子类特有的成员，当需要使用子类特有功能时，需要进行类型转换，类型转换分为向上转型和向下转型。

对象向上转型

​ 多态中的向上转型也就是多态的定义

Animal animal = new Dog();

​ 为什么要发生向上转型？

• 减少重复代码，使代码变得简洁。
• 提高系统扩展性。
• 用于参数统一化,假设父类有n个子类，方法要接受子类的实例，如果没有向上转型，就需要定义n个方法接收不同的对象。

对象向下转型

​ 多态中的向下转型是将父类对象还原成子类

Dog dog = (Dog)animal;

​ 为什么要发生向下转型？当父类需要调用子类的扩充方法时，才需要向下转型。

​ 注意：向下转型之前一定要进行向上转型

​ 向下转型举例：

class Animal {
	...
}
class Cat extends Animal{
	public void catc() {
		System.out.println("猫会抓老鼠");
	}
}

public class Test{
	public static void main(String[] args) {
	    Animal animal = new Cat();
	    animal.catc();//并不能使用子类中特有的方法，该语句会报错
	}
}

当需要用到子类中特有的方法时，可以向下转型

public class Test{
	public static void main(String[] args) {
	    Animal animal = new Cat();
	    Cat cat = (Cat)animal;//还原成子类
	    cat.catc();
	}
}

​ 通过对象的向上转型可以实现接受参数的统一，向下转型可以实现子类扩充的调用（一般不操作向下转型，有安全隐患）

注意事项

​ 向下转型只能在继承层次内转换，否则在强行运行程序时，会报ClassCastException异常

class Animal {
	...
}
class Cat extends Animal{
	...
}
class Dog extends Animal{
	...
}
public class Demo{
	public static void main(String[] args) {
	    Animal animal = new Cat();
        Cat cat = (Cat)animal;//没问题
	    Dog dog = (Dog)animal;//不能这样，程序执行时会报ClassCastException异常
	}
}

​ 因此将父类对象转换成子类之前，最好使用instanceof关键字进行检查

instanceof关键字

​ instanceof运算符的前一个操作符是一个引用变量，后一个操作数通常是一个类（可以是接口），用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是返回true，否则返回false。也就是说：使用instanceof关键字做判断时， instanceof 操作符的左右操作数必须有继承或实现关系。

​ instanceof关键字用法：

对象名 instanceof 数据类型
意思是判断前边的对象是否是后边的数据类型

​ 向下转型时，使用instanceof关键字进行检查：

//判断当前对象是否是Dog类对象
if(animal instanceof Dog){ 
    //是则可以进行转换，防止了ClassCastException异常
    Dog dog = (Dog)animal;    
}