java多态-1

学习多态前，请认真学习封装与继承

---

一、多态

多态的含义：方法或对象具有多种形态。

多态是面向对象的第三大特征，多态建立在封装和继承的基础上。

二、多态的具体体现

1. 方法中体现多态

重载（overload）体现了多态

重写（override）体现了多态

2. 对象体现多态

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

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

3. 运行类型是可以变化的

4. 编译类型看定义时 = 号 的左边，运行类型看 = 号 的右边

案例：

//父类
public class Person {
    private String name;
    private int 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 class Student extends Person{
   
}

public class exercise {
    public static void main(String[] args) {
         Person people = new Student();
    
    }

}

Person people = new Student(); //people的编译类型是Person，运行类型是Dog

父类的引用 可以指向 子类的对象

三、 多态注意事项

多态的前提：两个对象（类）存在继承关系

多态的向上转型：

1. 本质：父类的引用指向子类的对象

2. 语法：父类类型 引用名 = new 子类类型()；

3. 特点：编译类型看左边，运行类型看右边

   可以调用父类中所有成员(遵循访问权限)

   不能调用子类中特有成员，因为在编译阶段，能调用哪些成员，是由编译类型来决定的

   最终运行效果看子类的具体实现，如果子类有父类方法的重写，运行子类的方法内容（比如父类有eat，子类有eat，eatmouse， 则调用eat是子类的eat且不能调用eatmouse）

多态的向下转型：

1. 语法： 子类类型 引用名 = （子类类型） 父类引用

2. 只能强转父类的引用，不能强转父类的对象

3. 要求父类的引用必须指向的是当前目标类型的对象(必须先向上转型，才能再向下转型)

4. 当向下转型后，可以调用子类类型中所有的成员

Animal animal =  new Cat();

Cat cat = (Cat)animal;

cay.catchMouse();

四、 java动态绑定机制 

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型的绑定

2. 当调用对象属性时，没有绑定机制，哪里声明，哪里使用

class A{
    public int i = 10;
    public int sum(){
        return getI()+10;
    }
    
    public int sum1(){
        return i+10;
    }
    
    public int getI(){
        return i;
    }

}


class B extends A{
    public int i = 20;
    public int sum(){
        return i+20;
    }
    
    public int sum1(){
        return i+10;
    }
    
    public int getI(){
        return i;
    }

}

//main方法中
    
A a = new B();  //向上转型，编译类型是A，运行类型是B
a.sum();    //40     sum是方法，看运行类型B中有没有sum方法，有则执行  20+20
a.sum1();   //30      sum1是方法，看运行类型B中有没有sum1方法，有则执行     20+10

java绑定机制体现 案例

class A{
    public int i = 10;
    public int sum(){
        return getI()+10;
    }
    

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

}


class B extends A{
    public int i = 20;
   
    
    public int getI(){
        return i;
    }

}

main方法中
    
A a = new B();  //向上转型，编译类型是A，运行类型是B
a.sum();    // ,30   sum是方法，看运行类型B中有没有sum方法，有则执行，没有则找父类方法A，A中的sum为getI()+10,因为getI()是方法，绑定机制规定方法和运行内存绑定，则找运行内存B中的GetI()方法i = 20，最终结果 20+10
a.sum1();   //20      sum1是方法，看运行类型B中有没有sum1方法，有则执行，没有则找父类方法A，A中sum1为i+10，绑定机制规定属性哪里声明，哪里用，则使用A中的i=10     10+10