301讲！！！java动态绑定机制、(override)方法重写、重写细节、课堂练习、多态！！ 、向上转型、向下转型、（instanceOf 双目运算符）、多态数组

方法重写

比较重要的图。。一般重要

• 课堂练习

package main.daythree;

public class Override {
    public static void main(String[] args) {
        Person p1 = new Person("小白", 18);
        System.out.println(p1.say());
        System.out.println("===========");
        Student p2 = new Student("小绿", 20, 26, 99.8);
        System.out.println(p2.say());
    }

}
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        setName(name);
        setAge(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 String say(){
        return "name = " + name + "  age = " + getAge();
    }
}
class Student extends Person{
    private int id;
    private double score;
    public Student(String name, int age,int id,double score) {
        super(name, age);
        setId(id);
        setScore(score);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public String say(){   //下面老韩可以这么玩。。。。挺巧妙的
        return "name=" + getName() + " age=" + getAge() +
                " score=" + getScore() + " id=" + getId();
    }
}

• 老韩还可以这么玩....离谱了

多态(polymorphic)！

• 多态是核心、重难点。

方法重载体现出多态

要求背下来

1. 一个对象的编译类型和运行类型可以不一致
2. 编译类型再定义对象时，就确定了，不能改变
3. 运行类型额可以变化的。
4. 编译类型看定义时 = 号左边，运行类型看 = 号的右边。

• 示例

向上转型

• 向上转型：父类的引用指向了子类的对象。

​ 语法： 父类类型 引用名 = new 子类类型();

​ 例如：Cat继承Animal继承Object

​ Animal animal = new Cat();

​ Object obj = new Cat();

​ 可以调用父类所有的成员（需要遵守访问权限）

​ 不能调用子类中特有成员（属性、方法）； 【重要！！】

​ 最终运行效果看子类的具体实现。

调用方法时，按照从子类（运行类型）开始查找方法（规则和前面方法调用规则一致）

多态向下转型

• 语法： 子类类型 引用名 = (子类类型) 父类引用;
• 只能强转父类的引用，不能强转父类的对象！！
• 要求父类的引用必须指向的时当前目标类型的对象
• 当向下转型后，可以调用子类类型中所有的成员。

属性重写问题

• 向下转型注意看属性，属性属于编译类型所在的类。

• instanceOf 比较操作符，用于 判断对象的运行类型 是否为XX类型或者XX类型的子类型。

• 练习

• 练习答案

重要！！！！多态java的动态绑定机制 （非常非常重要）

• java的动态绑定机制

  1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。
  2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

package main.Dynamic_;

public class DynamicBinding {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());//30这里的动态绑定机制 getI()是调用的B类的。
        System.out.println(a.sum1());//20调用对象属性没有动态绑定机制。
    }
}

class A {
    int i = 10;

    public int sum() {
        return getI() + 10;
    }

    public int sum1() {
        return i + 10;
    }

    public int getI() {
        return i;
    }
}

class B extends A {
    int i = 20;

//    public int sum() {
//        return i + 20;
//    }

//    public int sum1() {
//        return i + 10;
//    }

    public int getI() {
        return i;
    }
}

多态数组

多态参数

• 多态的应用