Java中多态的基本使用

古城微笑少年丶 2023-02-23 08:23 42阅读 0赞

**Java中多态的基本使用:**

学习多态基础语法之前，我们需要普及两个概念：

第一个：向上转型  
子类（多） --> 父类（少） （自动型）

第二个：向下转型  
父类（少） --> 子类（多） （强制型，需要加强制类型转换符）

注意：Java中允许向上转型，也允许向下转型。  
无论是向上转型，还是向下转型，两种类型之间必须有**继承关系**。

--------------------

下面设计几个类：

//父类，动物类
    class Animal { 
    	protected void run() {  
    		System.out.println("动物在移动!!!");
    	}
    }
    
    
    //子类，猫类
    class Cat extends Animal { 
    //重写run()方法
    	public void run() { 
    		System.out.println("猫在走猫步!!!");
    	}
    //子类应该会有自己特有的方法，比如猫会抓老鼠
    	public void catchMouse() { 
    		System.out.println("猫正在抓老鼠!!!");
    }
    }
    //子类，鸟儿类
    class Bird extends Animal { 
    	//重写移动方法
    	public void run() { 
    		System.out.println("鸟儿在飞翔!!!");
    	}
    }

我们来看一下“向上转型”，也就是“父类型的引用指向子类型的对象”（自动型，直接转）

Animal a2 = new Cat();
    a2.run();  //输出：猫在走猫步!!!

**分析一下执行过程：a2.run()**

java程序分为编译阶段和运行阶段。

编译阶段：在编译时，编译器只知道a2的类型是Animal，编译阶段并没有进行实例化对象，也就没有进行new对象，所以在编译检查a2.run()的语法时，会去a2对象的Animal.class字节码中找run()方法，成功找到，绑定上run()方法，编译通过，静态绑定成功（编译阶段属于静态绑定）。

运行阶段：运行代码时，实际上在堆内存中创建的对象是一个Cat对象，也就是在栈内存当中的a2变量引用指向堆内存中的那只Cat对象，执行a2.run()时动态执行的是a2指向的Cat对象内部的run()方法，故输出“猫在走猫步！！！”。这一阶段属于运行绑定（运行绑定属于动态绑定）。

--------------------

再来理解一下多态的定义：  
多态指的是，父类型的引用指向子类型的对象。  
在编译中一种形态，运行时另一种形态。

包括编译阶段和运行阶段。  
编译阶段：静态绑定父类的方法。  
运行阶段：动态绑定子类型对象的方法。

多种形态，编译时一种形态，运行时另一种形态，故称为多态。

我们来分析一下下面一行的代码能否执行？

//Animal a2 = new Cat();
    //a2.catchMouse();

显然不行，因为在编译时会静态的去a2类字节码中找catchMouse()方法，没找到，静态绑定失败，编译不通过。

--------------------

什么时候使用“向下转型”？

**注意：不要随便做强制类型转换。当你需要访问子类对象中“特有”的方法，此时必须进行向下强制转型。**

Animal a2 = new Cat();
    //a2是一个Animal型引用变量，把它强制向下转成猫类型
    Cat xCat = (Cat)a2;
    //catchMouse()是子类中特有的方法，需向下转型
    xCat.catchMouse(); //输出：猫正在抓老鼠!!!

//我们思考一个问题：向下转型有风险吗？分析以下代码

Animal a3 = new Bird();
    Cat yCat = (Cat)a3;
    yCat.catchMouse();

//编译阶段：Animal a3，a3型与Cat存在继承关系，故Animal a3能强制转为Cat型，yCat对象字节码内存在catchMouse()方法，静态绑定成功，编译通过。

//运行阶段：实例化的对象实际是一只“鸟儿”，拿着Bird强转为Cat，最后运行动态绑定的是鸟儿对象的catchMouse()方法，动态绑定失败，运行报错java.lang.ClassCastException（类型转换异常）。

--------------------

如何避免类型转换异常的发生？

用运算符：instanceof  
语法：(x instanceof ClassA)  
作用：在运行阶段动态判断“引用变量指向的堆内存对象是否属于ClassA”。

返回值：  
真：表示“引用变量x指向的堆内存对象属于ClassA”；  
假：表示“引用变量x指向的堆内存对象不属于ClassA”。

程序员以后在向下转型的时候，应该养成好习惯，**对所有的向下转型的变量先进行instanceof类型判断**，再进行是否强制转换。

例如解决上面转型失败的问题：

Animal a3 = new Bird();
    if (a3 instanceof Cat) { // 如果a3是一只Cat,显然a3指向的是Bird，条件不成立
    	Cat yCat = (Cat)a3;
    	yCat.catchMouse(); //无输出
    }

--------------------

多态语法测试代码如下：

public class MyTest { 
    
    	public static void main(String[] args) { 
    		//方法的覆盖
    		Animal a1 = new Animal();
    		a1.run();  //输出：动物在移动!!!
    		Cat c1 = new Cat();
    		c1.run();  //输出：猫在走猫步!!!
    		Bird b1 = new Bird(); 
    		b1.run();  //输出：鸟儿在飞翔!!!
    				
    		//父类型的引用指向子类型的对象，也就是向上转型（自动型）
    		Animal a2 = new Cat();
    		a2.run();  //输出：猫在走猫步!!!
    		
    		//Dog类没有继承Animal，转型失败，编译报错
    		//Animal a3 = new Dog();
    		//Dog d1 = new Animal();
    		
    		//分析一下下面一行的代码能否执行？
    		//a2.catchMouse();
    		//显然不行，因为在编译时会静态的去a2类字节码中找catchMouse()方法，没找到，静态绑定失败，编译不通过。
    		
    		//如果我写到这里，暴脾气上来了，就要用a2.catchMouse()去抓老鼠，那该怎么办？ 行，那就引出向下转型
    		//a2是一个Animal型引用变量，把它强制向下转成猫类型
    		Cat xCat = (Cat)a2;
    		xCat.catchMouse(); //输出：猫正在抓老鼠!!!
    		
    		//我们思考一个问题：向下转型有风险吗？分析以下代码
    		/*Animal a3 = new Bird(); Cat yCat = (Cat)a3; yCat.catchMouse();*/
    		//编译阶段：Animal a3，a3型与Cat存在继承关系，故Animal a3能强制转为Cat型，yCat对象字节码内存在catchMouse()方法，静态绑定成功，编译通过。
    		//运行阶段：实例化的对象实际是一只“鸟儿”，拿着Bird强转为Cat，最后运行动态绑定的是鸟儿对象的catchMouse()方法，动态绑定失败，运行报错。
    		//为避免向下转型出现ClassCastException（类型转换异常），我们使用instanceof判断。
    		Animal a3 = new Bird();
    		if (a3 instanceof Cat) { // 如果a3是一只Cat,显然a3指向的是Bird，条件不成立
    			Cat yCat = (Cat)a3;
    			yCat.catchMouse(); //无输出
    		}
    		
    	}
    }
    
    //父类，动物类
    class Animal { 
    	// 移动方法，访问权限为protected，比public低
    	public void run() {  
    		System.out.println("动物在移动!!!");
    	}
    }
    
    //子类，猫类
    class Cat extends Animal { 
    	//改方法的访问权限不能比原继承方法的访问权限低，可以更高
    	public void run() { 
    		System.out.println("猫在走猫步!!!");
    		// 这里不能抛出异常，因为抛出异常数=1 > 继承方法的抛出异常数=0
    	}
    	
    	//子类应该会有自己特有的方法，比如猫会抓老鼠
    	public void catchMouse() { 
    		System.out.println("猫正在抓老鼠!!!");
    	}
    }
    
    //子类，鸟儿类
    class Bird extends Animal { 
    	//重写移动方法
    	public void run() { 
    		System.out.println("鸟儿在飞翔!!!");
    	}
    }
    
    //狗类，这个类没有继承Animal类
    class Dog { 
    	
    }

--------------------

下面给道例题理解一下多态在开发中的作用:

/* * 编写程序模拟主人喂养宠物的场景： * 提示一： * 主人类：Master * 宠物类：Pet * 宠物子类：Dog，Cat，Bird * 提示二： * 主人应该有喂养方法：feed() * 宠物应该有吃的方法：eat() * 只要主人喂养，宠物就吃。 * * 要求：主人类中只提供一个喂养方法feed()，要求达到可以喂养各种类型的宠物。 * 编写测试程序：创建主人对象 * 创建各种宠物对象 * 调用主人的喂养方法feed()，喂养不同的宠物，观察执行结果。 * 通过改案例，理解多态在开发中的作用。 * 重要提示：feed()方法是否需要一个参数，参数选什么类型？？？ */
    
    public class MyTest{ 
    	public static void main(String[] args) { 
    		//实例化主人类
    		Master pipi = new Master();
    		//实例化三种宠物类
    		Dog d1 = new Dog();
    		Cat c1 = new Cat();
    		Bird b1 = new Bird();
    		//主人调用自己的喂养方法feed()来实现不同宠物的吃方法eat()
    		pipi.feed(d1);
    		pipi.feed(c1);
    		pipi.feed(b1);
    	}
    }
    
    //主人类
    class Master { 
    	//feed()方法
    	public void feed(Pet pet) { 
    		pet.eat();
    	}
    }
    
    //宠物类
    class Pet { 
    	//eat()方法
    	public void eat() { 
    		System.out.println("宠物" + "在吃东西！！！");
    	}
    }
    
    //宠物子类，Dog类
    class Dog extends Pet { 
    	//重写eat()方法
    	public void eat() { 
    		System.out.println("狗狗" + "喜欢啃骨头！！！");
    	}
    }
    
    //宠物子类，Cat类
    class Cat extends Pet { 
    	//重写eat()方法
    	public void eat() { 
    		System.out.println("猫儿" + "喜欢吃鱼！！！");
    	}
    }
    
    //宠物子类，Bird类
    class Bird extends Pet { 
    	//重写eat()方法
    	public void eat() { 
    		System.out.println("鸟儿" + "喜欢吃虫子！！！");
    	}
    }

--------------------