面向对象12：什么是多态

多态

• 动态编译：类型—>可扩展性
• 即同一方法可以根据发送对象的不同而采取不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多 （父类，有关系的类）

多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类

注意：多态是方法的多态，属性没有多态性。

instanceof （）类型转换）y引用类型

多态注意事项

1、多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastException!
3.存在的条件：继承关系，方法需要重写，父类引用指向了子类对象！Father f1 = New Son();

方法不能被重写的情况

1.static 方法，属于类，他不属于实例
2.final 常量
3.private 方法

代码示例：

application2.java

package com.oop.Demo06;

public class Application2 {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        // new Person();
        // new Student();

        //可以指向的引用类型就不确定了,父类的引用指向子类的类型
        //Student 能调用的方法都是自己的或者继承父类的

        Student s1 = new Student();  //可以指向的引用类型就不确定了,父类的引用指向子类的类型  //Student 能调用的方法都是自己的或者继承父类的
        Person s2 = new Student();   //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Object s3 = new Student();
                                     //对象能执行哪些方法。主要看左边的类型，和右边关系不大
        s1.run();                    //son
        s2.run();                    //子类重写了父类的方法，执行子类的方法  ---son
        System.out.println("==============");
        s1.crash();
        s2.crash();
        System.out.println("==============");
        s1.foot();
        s2.foot();
        System.out.println("==============");
        s1.eat();
        ((Student) s2).eat();

    }
}

输出:

run1
run1
==============
crash1
crash1
==============
foot1
foot1
==============
eat1
eat1

进程已结束，退出代码 0

student.java

package com.oop.Demo06;

public class Student extends Person {

    public void run() {
        System.out.println("run1");
    }

    public void crash() {
        System.out.println("crash1");
    }
    //子类无foot方法

    public void eat() {
        System.out.println("eat1");
    }

}

person.java

package com.oop.Demo06;

public class Person {
    public void run() {
        System.out.println("run2");
    }

    public void crash() {
        System.out.println("crash2");
    }
    public void foot() {
        System.out.println("foot1");
    }

    //父类无eat方法
}