面向对象 — 多态_面向对象多态-CSDN博客

本文链接：https://blog.csdn.net/m0_61410724/article/details/125246079

多态基本介绍

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

多态的前提是：1.继承。2.重写。

多态的具体体现为：1.方法的多态（重写和重载就体现多态）。2.对象的多态。

（1）本质：父类的引用指向了子类的对象。

（2）语法：父类类型引用名 = new 子类类型();

（3）特点：编译类型看左边，运行类型看右边，可以调用父类类型中的所有成员（需要遵守访问权限），不能调用子类中的特有成员，最终运行效果看子类的具体实现。

多态的优点

1.能够降低代码的“圈复杂度”，避免使用大量的if-else。

2.可扩展能力更强。

多态实现的条件

必须在继承体系下
子类必须要对父类中的方法进行重写
通过父类的引用调用重写的方法

方法的多态：

（1）重写和重载。

对象的多态：

(1)一个对象的编译类型和运行类型可以不一致。

(2)编译类型在定义对象时，就确定了，不能改变。

(3)运行类型是可以变化的。

(4)编译类型看定义时 “=”的左边，运行类型看“=”的右边。

Animal animal = new Dog();
animal = new Cat();

以上代码中animal的编译类型是Animal，运行类型是Dog。

后将运行类型变为Cat，编译类型仍是Animal。

重写和重载的区别

区别点	重载(overloading)	重写（override）
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
访问限定符	可以修改	不能做出更严格的限制（子类权限大于父类）

方法重载式一个类的多态性的表现，而方法重写式子类与父类的一种多态性表现。

重写的规则

（1）子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符返回值类型方法名（参数列表）要完全一致
（2）被重写的方法返回值类型可以不同，但是必须是具有父子关系的
（3）访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为protected
（4）父类被static、private修饰的方法都不能被重写
（5）子类和父类在同一个包中，那么子类可以重写父类中的所有方法，除了声明为private和final的方法
（6）子类和父类不在同一个包中，那么子类只能够重写父类的声明为public 和protected的非final方法
（7）重写的方法，可以使用 @Override 注解来显式指定。有了这个注解能够帮我们检查这个方法有没有被正确重写。例如不小心讲方法名拼写错了，此时编译器就会发现父类中并没有这个方法，就会编译报错，构不成重写。

多态的简单案例

用多态机制实现主人喂食问题：

package poly;

public class poly01 {
    public static void main(String[] args) {
        Master tom = new Master("汤姆");
        Dog dog = new Dog("大黄");
        Bone bone = new Bone("大棒骨");
        tom.feed(dog,bone);

        Cat cat = new Cat("大白");
        Fish fish = new Fish("小黄鱼");
        tom.feed(cat,fish);

    }


}

package poly;

public class Master {
    private String name;

    public Master(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void feed(Animal animal,Food food){
        System.out.println("主人" + name + "给" + animal.getName() + "吃" + food.getName());
    }
//    public void feed(Dog dog,Bone bone){
//        System.out.println("主人" + name + "给" + dog.getName() + "吃" + bone.getName());
//    }
//    public void feed(Cat cat,Fish fish){
//        System.out.println("主人" + name + "给" + cat.getName() + "吃" + fish.getName());
//    }
}

package poly;

public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package poly;

public class Dog extends Animal{
    public Dog(String name) {
        super(name);
    }
}

package poly;

public class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }
}

package poly;

public class Food {
    private String name;
    public Food(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package poly;

public class Bone extends Food{
    public Bone(String name) {
        super(name);
    }
}

package poly;

public class Fish extends Food{
    public Fish(String name) {
        super(name);
    }


}

向上转型和向下转型

在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
那么在这个过程中就存在着多态的应用。存在着两种转型方式，分别是：向上转型和向下转型。

向上转型：可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类中声明过的方法，方法体执行的就是子类重过后的功能。但是此时对象是把自己看做是父类类型的，所以其他资源使用的还是父类型的。

向下转型：子类的引用的指向子类对象，过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能，所以需要重新恢复成子类对象。

Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child