面向对象之继承与多态-优快云博客

本文链接：https://blog.youkuaiyun.com/aquanyt/article/details/117030032

面向对象2 继承性

方法的重写

定义
在子类中可以根据需要对从父类中继承的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
要求
1.子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2.子类冲洗的方法的返回类型不能大于父类被重写的方法的返回值类型
3.子类重写的方法使用的访问权限不能小于父类别重写的方法的访问权限
子类不能重写父类中声明为private权限的方法
4.子类方法抛出的异常不能大于父类被重写方法的异常
注意
子类与父类同名参数的方法必须同时声明为非static的（即为重写），或者同时声明为static的（不是重写）。因为static方法是属于类的，子类复发覆盖父类的方法。

super

可以理解为父类的；
super可以用来调用属性、方法、构造器

super的使用：属性和方法
3.1 我们可以在子类的方法或者构造器中，通过使用“super.属性”或者“super.方法”，显式的调用父类中声明的属性或者方法，但是通常情况下，我们习惯忽略super。
3.2 特殊情况下，当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中的声明的属性时，就必须显示的使用“super.属性”的方式，表明调用的是父类声明的属性。
3.3 特殊情况下，当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式使用“super.方法”的方式，表明调用的是父类中被重写的方法。
super 调用构造器
4.1 我们可以在子类的构造器中显式的使用"super（形参列表）”的方式，调用父类中声明的指定的构造器
4.2 super（形参列表）的使用必须声明在子类构造器的首行
4.3 我们在类中的构造器中，针对于“this（形参列表）” 或者 super（形参列表）只能二选一，不能同时出现。
4.4 在构造器的首行，没有显示的声明“this（形参列表）”或者“super（形参列表）”，则默认调用父类中空参的构造器，也就是super（）
4.5 在类的多个构造器中，至少有一个类的构造器中使用了“super（形参列表）”，调用父类的狗砸器。

子类对象的实例化过程

1.从结果上看，（集成性）
子类集成父类以后，就获取了父类中声明的属性或方法；
创建子类的对象，在对空间中，就会加载所有父类中的声明的属性

从过程上看
当我们通过子类的构造器创建子类对象时，我们一定会直接或者间接的调用器父类的构造器，进而调用父类的父类的构造器，直到所有直系父类都被调用。

P279

多态性

1.理解多态性，可以理解为一个事物的多种形态。
2.何为多态性：对象的多态性，父类的引用指向子类的对象。（或者子类的对象赋给父类的引用）

// 多态性
Persion p1 = new Man();

多态的使用：当调用子父类同名参数的方法时，实际执行的是子类重写的父类的方法—虚拟方法的使用；
多肽的使用：虚拟方法调用
有了对象的多态性之后，我们在编译时，只能调用父类中声明的方法，但是在运行时期，我们实际执行的是子类重写父类的方法。
总结就是：编译看父类，运行看子类。

多态性的使用，虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但是在运行期执行的是子类重写父类的方法。

多态性的使用前提：
①类的继承关系②重写③父类引用

package com.atguigu.java1;

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest animalTest = new AnimalTest();
        Dog dog = new Dog();
        animalTest.func(dog);
    }
    
    public void func(Animal animal) {
        animal.shout();
        animal.eat();
    }
}

class Animal{
    public void eat() {
        System.out.println("动物：进食");
    }

    public void shout() {
        System.out.println("动物：叫");
    }
}

class Dog extends Animal{

    public void eat() {
        System.out.println("狗：吃骨头");
    }

    public void shout() {
        System.out.println("狗：汪汪");
    }
}

class Cat extends Animal{
    
    public void eat() {
        System.out.println("猫 ：吃鱼");
    }

    public void shout() {
        System.out.println("猫：喵喵");
    }
}

对象的多态性：只适用于方法，不适用于属性（编译和运行都看左边）

总结

正常的方法的调用
虚拟方法调用（多态情况下）
子类中定义了与父类同名的同参数的方法，在多态情况下，将此时的父类的方法称为虚拟方法，父类根据付给他的不同的子类对象，动态调用属于子类的该方法，这样的方法调用在编译期是无法确定的。
编译时类型和运行时类型

Persion = new Student（）；
e.getInfo(); // 调用Student类的getInfo()方法。

编译时e为Persion类型，而方法的调用则是在运行时确定的，所以调用的是Student类的getInfo()方法。动态绑定。

多态是运行时行为；

方法的重载和重写

从编译和运行的角度看
重载：是允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。他们的调用地址在编译时就已经确定了，即子类可以重载父类的同名不同参数的方法；
所以，对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为早绑定，或者静态绑定；
而对于多态而言，只有等到方法调用的那一刻，编译器才会确定所要调用的具体方法，称为晚绑定或者是动态绑定；
引用一句Bruce Ecke的话：不要犯傻，如果他不是晚绑定，它就不是多态；