多态那些事

Y³

已于 2023-04-01 17:11:27 修改

阅读量48

点赞数

文章标签： java jvm 开发语言

于 2023-04-01 17:07:40 首次发布

本文链接：https://blog.csdn.net/2303_76713112/article/details/129899772

版权

多态

Java三大特性之一

一、定义

同类型的对象，表现出的不同形态

多态的表现形式

父类类型 对象名称 = 子类对象;

多态的前提

有继承关系
有父类引用指向子类对象

Fu f = new Zi();

有方法重写

例如：

先创建一个父类Javabean类

public class Person {
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name + "," + age);
    }
}

分别创建学生，老师，管理员Javabean类

public class Student extends Person{
    
    @Override
    public void show(){
        System.out.println("学生的信息为： " + getName() + "," + getAge());
    }
}

public class Teacher extends Person{

    @Override
    public void show(){
        System.out.println("老师的信息为： " + getName() + "," + getAge());
    }
}

public class Administrater extends Person{

    @Override
    public void show(){
        System.out.println("管理员的信息为： " + getName() + "," + getAge());
    }
}

用测试类来运行

public class test {
    public static void main(String[] args) {

        Student s = new Student();
        s.setName("月");
        s.setAge(18);

        Teacher t = new Teacher();
        t.setName("JJ哥");
        t.setAge(30);

        Administrater a = new Administrater();
        a.setName("殇");
        a.setAge(18);

        register(s);
        register(t);
        register(a);
    }

    //这个方法既能接收老师，又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父类
    public static void register(Person p){
        p.show();
    }
}

运行结果为：

学生的信息为： 月,18
老师的信息为： JJ哥,30
管理员的信息为： 殇,18

多态的好处

使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。

二、多态调用成员的特点

变量调用：编译看左边，运行也看左边
方法调用：编译看左边，运行看右边

例：

public class test{
    public static void main(String[] args)
    {
        Animal a = new Dog();
        //调用成员变量：编译看左边，运行也看左边
        //编译看左边：javac编译代码的时候，会看左边的父类有没有这个变量，如果有，编译成功，否则失败
        //运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
        System.out.println(a.name);//动物
        
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，否则失败
        //运行看右边：java运行代码的时候，实际上运行的是子类中的方法。
        a.show();//Dog --- show方法
        
        //成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。
    }
}

class Animal{
    String name = "动物";
    
    public void show(){
		System.out.println("Animal --- show方法");
    }
}

class Dog extends Animal{
    String name = "狗";
    
    @Override
    public void show(){
        System.out.println("Dog --- show方法");
    }
}

class Cat extends Animal{
    String name = "猫";
    
    @Override
    public void show(){
        System.out.println("Cat --- show方法");
    }
}

三、多态的优势与劣势

优势

在多态形式下，右边对象可以实现解耦合，便于扩展和维护。

Person p = new Student();
p.work;//业务逻辑发生改变时，后续代码无需修改

定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利。

例：

public class test {
    public static void main(String[] args) {
        Furniture F = new Desk;
        F.use();

        //多态的弊端
        //不能调用子类的特有功能
        //报错的原因？
        //当调用成员方法的时候，编译看左边，运行看右边
        //那么在编译的时候会先检查左边的父类中有没有这个方法，如果没有直接报错
        //F.putOn();
        
        //解决方案：强制转换类型（转成子类）
        //用if语句判断是否转换错误
        /*if(F instanceof Desk)
        {
            Desk D = (Desk) F;
            D.putOn();
        }
        else if(F instanceof Chair)
        {
            Chair C = (chair) F;
            C.sitDown();
        }
        else
        {
            System.out.println("没有这个类型，无法转换");
        }*/
        
        //优化：
        //先判断F是否为Desk类型，如果是，则强转成Desk类，转换之后变量名为D
        //如果不是，则不强转，结果直接是false
        if(F instanceof Desk D)
        {
            D.putOn();
        }
        else if(F instanceof Chair C)
        {
            C.sitDown();
        }
        else
        {
            System.out.println("没有这个类型，无法转换");
        }
    }
}

class Furniture{
    public void use()
    {
        System.out.println("装饰");
    }
}
class Desk extends Furniture{
    @Override
    public void use(){
        System.out.println("放东西");
    }

    public void putOn(){
        System.out.println("放很多东西");
    }
}
class Chair extends Furniture{
    @Override
    public void use()
    {
        System.out.println("给人坐");
    }
    public void sitDown(){
        System.out.println("给很多人坐");
    }
}