Java基础语法（十）| 多态

呆呆不呆~

已于 2024-04-12 12:05:18 修改

阅读量463

点赞数 24

分类专栏： java专栏文章标签： java 开发语言后端

于 2024-04-03 08:31:25 首次发布

本文链接：https://blog.csdn.net/m0_46331650/article/details/137239790

版权

java专栏专栏收录该内容

18 篇文章 0 订阅

订阅专栏

前言

Hello，大家好！很开心与你们在这里相遇，我是一个喜欢文字、喜欢有趣的灵魂、喜欢探索一切有趣事物的女孩，想与你们共同学习、探索关于IT的相关知识，希望我们可以一路陪伴~

1. 多态

1.1 什么是多态

多态是继封装、继承之后，面向对象的第三大特性。生活中，比如跑的动作，小猫、小狗和大象,都是动物，跑起来是不一样的。

再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。

可见，同一行为，通过不同的事物，可以体现出来的不同的形态。

多态，指的是同类事物、或实现同一接口的对象，同样的行为，呈现的不同形态。

1.2 多态的前提

- 1.要有继承或实现关系
- 2.要有方法的重写
- 3.要有父类引用指向子类对象 fu f = new zi();

1.3 多态格式

普通类多态的格式

父类对象 = new 子类();

抽象类多态的格式

抽象类对象名 = new 抽象类子类();

接口多态的格式

接口对象名 = new 接口实现类();

1.4 多态中的成员访问特点

成员变量

编译看左边(父类)，运行看左边(父类)

成员方法

编译看左边(父类)，运行看右边(子类)

代码示例

动物类：

public abstract class Animal {
    int age = 40;
    public abstract void eat();
}

猫类：

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;

    //子类要重写父类中的方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
     

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

测试类：

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

      	//成员变量
        //编译看左边(父类)，运行看左边(父类)
        System.out.println(a.age);
        // System.out.println(a.weight);  //弊端：不能使用子类的特有成员变量

        //成员方法
        //编译看左边(父类)，运行看右边(子类)
        a.eat();
        // a.playGame(); //弊端：不能使用子类的特有成员方法
    }
}

1.5 多态的好处和弊端

多态的弊端

不能使用子类的特有成员

多态的好处

提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。

多态的好处代码演示

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

定义父类：

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); 
        
        //showAnimalEat(new Cat());
        //showAnimalEat(new Dog());
    }

    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方法了，直接使用showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

1.6 多态中的转型

为什么要用转型

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

向上转型

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

使用格式：

向上转型
父类类型变量名 = 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) {
        // 向上转型     fu f = new zi()
        Animal a = new Cat();  
        a.eat();                // 调用的是 Cat 的 eat

        // 向下转型    zi z = (zi)fu;  向下转型，获取子类特有的方法
        Cat c = (Cat)a;       
        c.catchMouse();         // 调用的是 Cat 的 catchMouse     
    }
}

1.7 转型的异常

问题描述

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

 public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();        // 调用的是 Cat 的 eat
        
        // 向下转型 
        Cat c = (Cat)a;
        c.catchMouse();//调用自己的方法
        System.out.println("================");
 
        // 向下转型  
        Dog d = (Dog)a;       //引用的父类，是多态cat类，并不是dog 
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】    
    }  
}

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
        }
    }  
}
分析：

这段代码可以通过编译，但是运行时，却报出了ClassCastException类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量做类型的校验。

instanceof使用格式

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

instanceof代码示例

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
        }
    }  
}

无论发生什么，都不要放弃自己~ 喜欢我就关注我叭~