多态

多态（动态编译：类型：可扩展性）

1.即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

2.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

3.多态存在的条件

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

4.注意事项：

• 多态是方法的多态，属性没有多态
• 父类和子类，有联系类型转换异常! ClassCastException!
• 存在条件: 继承关系，方法需要重写，父类引用指向了类对象! Father f1 = new Son();
• 不能重写的情况
  • static方法，属于类，它不属于实例
  • final 常量
  • private方法

示例：

父类

package oop.Demo06;

public class Person {

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

}

子类

package oop.Demo06;

public class Student extends Person{

    @Override
    public void run() {
        System.out.println("son");
    }

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

}

在main方法中调用

package oop;

import oop.Demo06.Person;
import oop.Demo06.Student;
import oop.demo05.A;
import oop.demo05.B;

public abstract class Application {

    public static void main(String[] args) {

        // 一个对象的实际类型是确定的
        // new Student();
        // new Person();

        // 可以指向的引用类型就不确定了

        // Student 能调用的方法都是自己的或者父类的！
        Student s1 = new Student();
        // Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run(); // 子类重写了父类的方法，执行子类的方法
        s1.run();

        // 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        ((Student) s2).eat(); // 把s2的Person类型转换成Student类型
        s1.eat();
    }

}

输出结果为：

son
son
eat
eat

6.instanceof （类型转换） 引用类型，判断一个对象是什么类型~

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型，强制转换
3.把父类转换为了类，向下转型
4.方便方法的调用。减少重复的代码，简洁！

示例1：用 instanceof 判断

package oop;

import oop.Demo06.Person;
import oop.Demo06.Student;
import oop.Demo06.Teacher;
import oop.demo05.A;
import oop.demo05.B;

public abstract class Application {

    public static void main(String[] args) {

        // Object > String
        // Object > Person > Teacher
        // Object > Person > Student
        Object object = new Student();

        System.out.println(X instanceof Y); // 能不能编译通过！

        System.out.println(object instanceof Student);  // True
        System.out.println(object instanceof Person);   // True
        System.out.println(object instanceof Object);   // True
        System.out.println(object instanceof Teacher);  // False
        System.out.println(object instanceof String);   // False

        Person person = new Student();
        System.out.println("============================");
        System.out.println(person instanceof Student);  // True
        System.out.println(person instanceof Person);   // True
        System.out.println(person instanceof Object);   // True
        System.out.println(person instanceof Teacher);  // False
        // System.out.println(person instanceof String);   // 编译报错

        Student student = new Student();
        System.out.println("============================");
        System.out.println(student instanceof Student);  // True
        System.out.println(student instanceof Person);   // True
        System.out.println(student instanceof Object);   // True
        //System.out.println(student instanceof Teacher);  // 编译报错
        // System.out.println(person instanceof String);   // 编译报错

    }

}

示例2：强制转换

子类：

package oop.Demo06;

public class Student extends Person{

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

在main方法中调用

package oop;

import oop.Demo06.Person;
import oop.Demo06.Student;

public abstract class Application {

    public static void main(String[] args) {
        // 类型之间的转化：父 子

        // 高                 低
       Person obj = new Student();

       // student将这个对象转为Student类型，我们就可以使用Student类型的方法了！

        Student student = (Student) obj;    
        student.go();
        // 上面两句的简写方式：((Student) obj).go();

    }

}

输出结果为：

go

示例3：自然转换

子类

package oop.Demo06;

public class Student extends Person{

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

在main方法中调用

    public static void main(String[] args) {
        // 类型之间的转化：父 子

        // 子类转换为父类，可能丢失自己的本来的一些方法！
        Student student = new Student();
        student.go();
        Person person = student;
        
    }

输出结果为：

go