Java面向对象——多态

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

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

· 多态存在的条件：

  1. 有继承关系；

  2. 子类重写父类的方法；

  3. 父类引用指向子类对象。

多态注意事项：
  1. 多条是方法的多态，属性没有多态；

  2. 父类和子类，有联系    类型转换异常：ClassCastException！

  注意，以下方法没有多态：
  1. static方法，属于类，不属于实例，所以该方法不能被重写；

  2. final  常量；无法重写；

  3. private方法  私有；无法重写。

---

代码演示：

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

public class Student extends Person{
 
    @Override
    public void run() {
        System.out.println("son");
    }
 
    public void eat(){
        System.out.println("eat");
    }
}

import oop.demo06.Person;
import oop.demo06.Student;
//一个项目应该只存在一个main方法
public 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();
 
    }
}

---

instanceof（类型转换）

 instanceof关键字：判断一个对象是什么类型

创建一个父类Person，子类Student、Teacher

代码演示：

    public static void main(String[] args) {
 
        //Object > Person > Student
        Object object = new Student();
 
        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
        System.out.println("============================");
        Person person = new Student();
        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);  编译报错
        System.out.println("============================");
        Student student = new Student();
        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(student instanceof String);  编译报错
 
    }

---

类型转换：

  1. 父类引用指向子类的对象；

  2. 把子类转换为父类，向上转型；可能丢失一些方法；

  3. 把父类转换为子类，向下转型；强制转换；

  4. 方便方法的调用，减少重复的代码。简洁

代码演示：（父类、子类同上）

        //类型之间的转换：父  子
 
        //高                  低
        Person obj = new Student();
        //将上面的对象转换为Student类型，就可以使用Student的方法了
        Student student = (Student) obj;
        student.go();
        //或
        ((Student) obj).go();
 
        //低                   高
        //子类转换为父类，可能会丢失自己的一些方法
        Student student1 = new Student();
        student1.go();
        Person person = student1;