1.多态的概念

什么是多态? 通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

不懂? 没关系! 老规矩,上图。

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        method(dog);
        method(cat);
    }
    public static void method(Animal animal){
        // 子类的对象由父类接受,称之为向上转型,反之,则为向下转型
        animal.eat();
    }
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }
}
class Animal{
    String name;
    int age;
    public void eat(){
        System.out.println("动物吃饭");
    }
}

在这里我们定义了狗类和猫类,并未它们创建了一个父类Animal,我们定义了Test测试类,用来测试方法method执行的结果。

代码看不懂?

没关系,你只要看结果足矣,安排!

输出的结果为,狗吃饭,猫吃饭

你可能会说了,哎,这不对呀,我method的参数明明是Animal类,不应该是输出两行动物吃饭吗?

我只能说,先别急,我会把你安排的明明白白!

再来理解一下多态

一个函数中,传入不同的对象,输出结果却不同,猫和狗在吃饭上有不同的表现形式,但却都是继承了Animal类,两者都是动物,但在吃饭这一动作上却有差异,这便是多态!

2.多态的实现条件

1.必须在继承条件下(多态多态,无继承,何谈多态?)

2.子类必须对父类中要实现多态的方法进行重写(后面会说什么是重写)

3.通过父类的引用调用重写的方法(实现多态的方法中的参数是父类)

3.重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

规则:

1.子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 (参数列表) 要完全一致

2.被重写的方法返回值类型可以不同，但是必须是具有父子关系的

3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected

4.父类被static、private修饰的方法、构造方法都不能被重写。

5.重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

重写和重载的区别:

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        System.out.println(animal.name);
        //调用成员变量：编译看左边，运行也看左边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
        //运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
    }
}

class Dog extends Animal{
    String name = "狗";
    int age = 2;

    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
}

class Cat extends Animal{
    String name = "猫";
    int age = 2;
    
    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }
}
class Animal{
    String name = "动物";
    int age = 2;

    public void eat(){
        System.out.println("动物吃饭");
    }
}

成员变量便是属于静态绑定

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
        //调用成员方法：编译看左边，运行看右边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
        //运行看右边：java运行代码的时候，实际上运行的是子类中的方法
    }
}

class Dog extends Animal{
    String name = "狗";
    int age = 2;

    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
}

class Cat extends Animal{
    String name = "猫";
    int age = 2;

    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }
}
class Animal{
    String name = "动物";
    int age = 2;

    public void eat(){
        System.out.println("动物吃饭");
    }
}

成员方法属于动态绑定