Java碎碎念之浅谈多态

大家都知道,面向对象的三大特征为:继承,封装,多态
其中多态较为抽象,以下是我第二次学习javase时的笔记(望采纳):
1,理解多态性:可以理解为一个事物的多种形态.
2,何为多态性:对象的多态性:父类引用指向子类对象(或者子类的对象赋给父类引用)
3,多态的使用,虚拟方法的调用
有了对象的多态性以后,我们在编译期间,只能调用父类中声明的方法,但是在运行期间,我们实际执行的则是子类中重写父类的方法.
总结:编译看左边,运行看右边
4,多态性的使用前提:
>类的继承关系
>方法的重写
5,对象的多态性,只适用于方法,不适用于属性(编译和运行都看左边)
6,虚拟方法
>正常的方法调用:对象.方法名
>虚拟方法(多态):
子类中定义了与父类同名同参数的方法,在多态情况下,将此时父类的方法称为虚拟方法,父类根据赋给他的不同的子类对象,动态调用属于子类的该方法,这样的方法调用在编译期间是无法确定的.
>编译时类型和运行时类型
废话少说,上代码
如以下的多态性代码:

Animal1 animal=new Dog();
animal1.eat();

编译时animal1为Animal类型,而方法的调用是在运行时确定的,所以调用的是Dog类的eat方法.–动态绑定.

package Demo2;

/**
 * @author TR
 * @date 2020/7/14 - 下午 4:59
 * @describe: 测试多态的重要性
 */
public class Demo16 {
    public static void main(String[] args) {
        Demo16 d = new Demo16();
        d.func(new Cat());
        d.func(new Dog());
    }

    public void func(Dog dog) {
        dog.shout();
        dog.eat();
    }

    public void func(Cat cat) {
        cat.shout();
        cat.eat();
    }
}

class Animal1 {
    public void eat() {
        System.out.println("我要吃东西...");
    }

    public void shout() {
        System.out.println("我要叫");
    }
}

class Dog extends Animal1 {
    @Override
    public void eat() {
        System.out.println("我要吃狗粮");
    }

    @Override
    public void shout() {
        System.out.println("汪!汪!汪!");
    }
}

class Cat extends Animal1 {
    @Override
    public void eat() {
        System.out.println("我要吃鱼");
    }

    @Override
    public void shout() {
        System.out.println("喵!喵!喵!");

    }
}

但是如果用了多态:

    Demo16 d = new Demo16();
    d.func(new Cat());
    d.func(new Dog());
}

public void func(Animal1 animal1) {
    animal1.shout();
    animal1.eat();
}

输出结果一样:

喵!喵!喵!
我要吃鱼
汪!汪!汪!
我要吃狗粮

代码量是不是少了很多.这只是其中一点.如果没有多态,用一个类要给他一个单独的构造器,然后在主类中创建对象来调用方法.随着类越来越多,代码量也是剧增的.
通过构造器将父类引用指向子类对象

Animal1 animal=new Dog();
Animal1 animal1=new Cat();

这样当animal调用eat或者shout方法时,编译时在父类,运行时在子类,就可以实现子类中重写的方法了.
关于方法的重载和重写
从编译和运行的角度来看:
重载,是指允许存在多个同名方法,而这些方法的参数不同,编译器根据方法不同的参数,对同方法的参数作修饰.对于编译器而言,这些同名的方法就成了不同的方法.他们的调用地址在编译期间就绑定了.Java的重载是可以包括父类和子类的,即子类可以重载父类的同名不同参数的方法方法.
所以,对于重载而言,在方法调用之前,编译器就已经确定了所要调用的方法,这称为"早绑定"或者"静态绑定".
而对于多态,只有等到方法调用的那一刻,编译器才会确定所要调用的具体方法,这称为"晚绑定"或者"动态绑定".
Bruce Eckel说过:如果不是晚绑定,就不是多态.
关于多态就说这么多.

本文地址：https://blog.csdn.net/weixin_46255799/article/details/107341100