Java--面向对象之多态

妖狐艹你老母 2021-09-27 15:48 428阅读 0赞

### 文章目录 ###

*  前言
 *  内容
 *   *  1. 多态的定义
     *  2. 多态的体现
     *  3. 多态的好处
     *  4. 引用类型转换
     *   *  向上转型
         *  向下转型
         *  为什么要转型
         *  转型的异常
 *  总结
 *  end

# 前言 #

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

# 内容 #

## 1. 多态的定义 ##

**多态**： 是指同一行为，具有多个不同表现形式。

> 前提  
> 1. 继承或者实现【二选一】  
> 2. 方法的重写【意义体现：不重写，无意义】  
> 3. 父类引用指向子类对象【格式体现】

## 2. 多态的体现 ##

多态体现的格式：

父类类型 变量名 = new 子类对象;
    		变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。  
代码如下：

Fu f = new Zi();
    		f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。  
代码如下：

## 3. 多态的好处 ##

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码如下：

定义父类：
    			public abstract class Animal {  
    			    public abstract void eat(); 
    			}
    			
    定义子类：
    			class Cat extends Animal {  
    			    public void eat() {  
    			        System.out.println("吃鱼"); 
    			    } 
    			} 
    			class Dog extends Animal {  
    			    public void eat() {  
    			        System.out.println("吃骨头"); 
    			    } 
    			}
    			
    定义测试类：
    			public class Test { 
    			    public static void main(String[] args) { 
    			        // 多态形式，创建对象
    			        Cat c = new Cat(); 
    			        Dog d = new Dog();
    			        // 调用showCatEat
    			        showCatEat(c);
    			        // 调用showDogEat
    			        showDogEat(d);
    			        /* 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */
    			        showAnimalEat(c);
    			        showAnimalEat(d);
    			    }
    			    public static void showCatEat (Cat c){ 
    			        c.eat();
    			    }
    			    public static void showDogEat (Dog d){ 
    			        d.eat();
    			    }
    			    public static void showAnimalEat (Animal a){ 
    			        a.eat();
    			    }
    			}

由于多态特性的支持，`showAnimalEat`方法的`Animal`类型，是`Cat`和`Dog`的父类类型，父类类型接收子类对象，当然可以把`Cat`对象和`Dog`对象，传递给方法。  
当`eat`方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与`showCatEat`、`showDogEat`方法一致，所以`showAnimalEat`完全可以替代以上两方法。  
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写`showXxxEat`方法了，直接使用`howAnimalEat`都可以完成。  
所以，多态的好处，体现在，**可以使程序编写的更简单，并有良好的扩展**。

## 4. 引用类型转换 ##

回顾基本数据类型转换

1.  自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
2.  强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14  
    多态的转型分为向上转型与向下转型两种：

### 向上转型 ###

**向上转型**：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

> 当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型  变量名 = new 子类类型();
    			如：Animal a = new Cat();

### 向下转型 ###

**向下转型**：父类类型向子类类型向下转换的过程，这个过程是强制的。

> 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
    			如:Cat c =(Cat) a;

### 为什么要转型 ###

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。  
转型演示，代码如下：

定义类：
    			abstract class Animal {  
    			    abstract void eat(); 
    			} 
    			class Cat extends Animal {  
    			    public void eat() {  
    			        System.out.println("吃鱼"); 
    			    } 
    			    public void catchMouse() {  
    			        System.out.println("抓老鼠"); 
    			    } 
    			} 
    			class Dog extends Animal {  
    			    public void eat() {  
    			        System.out.println("吃骨头"); 
    			    } 
    			    public void watchHouse() {  
    			        System.out.println("看家"); 
    			    } 
    			}
    			
    定义测试类：
    			public class Test { 
    			    public static void main(String[] args) { 
    			        // 向上转型 
    			        Animal a = new Cat(); 
    			        a.eat();  // 调用的是 Cat 的 eat 
    			        // 向下转型 
    			        Cat c = (Cat)a;      
    			        c.catchMouse();  // 调用的是 Cat 的 catchMouse 
    			    } 
    			}

### 转型的异常 ###

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test { 
    			    public static void main(String[] args) { 
    			        // 向上转型 
    			        Animal a = new Cat(); 
    			        a.eat();               // 调用的是 Cat 的 eat
    			        // 向下转型 
    			        Dog d = (Dog)a;      
    			        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    			    } 
    			}

这段代码可以通过编译，但是运行时，却报出了 `ClassCastException` ，类型转换异常！这是因为，明明创建了`Cat`类型对象，运行时，当然不能转换成`Dog`对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。  
为了避免`ClassCastException`的发生，Java提供了 `instanceof`关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型

如果变量属于该数据类型，返回true。
    		如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test { 
    			    public static void main(String[] args) { 
    			        // 向上转型 
    			        Animal a = new Cat(); 
    			        a.eat();               // 调用的是 Cat 的 eat
    			        // 向下转型 
    			        if (a instanceof Cat){ 
    			            Cat c = (Cat)a;      
    			            c.catchMouse();        // 调用的是 Cat 的 catchMouse
    			        } else if (a instanceof Dog){ 
    			            Dog d = (Dog)a; 
    			            d.watchHouse();       // 调用的是 Dog 的 watchHouse
    			        }
    			    } 
    			}

# 总结 #

多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。  
多态是继封装、继承之后，面向对象的第三大特性。

# end #

[Java–面向对象之继承][Java]  
[Java–面向对象之封装][Java 1]  
谢谢您的阅读!

[Java]: https://blog.csdn.net/Luojun13Class/article/details/83421843
[Java 1]: https://blog.csdn.net/Luojun13Class/article/details/83043100