面向对象三大特征之多态

  ​    同一个对象，在不同时刻表现出来的不同形态

  - 要有继承或实现关系
  - 要有方法的重写
  - 要有父类引用指向子类对象

1.定义不同---重载是定义相同的方法名，参数不同；重写是子类重写父类的方法。

2.范围不同---重载是在一个类中，重写是子类与父类之间的。

3.多态不同---重载是编译时的多态性，重写是运行时的多态性。

4.返回不同---重载对返回类型没有要求，而重写要求返回类型，有兼容的返回类型。

5.参数不同---重载的参数个数、参数类型、参数顺序可以不同，而重写父子方法参数必须相同。

6.修饰不同---重载对访问修饰没有特殊要求，重写访问修饰符的限制一定要大于被重写方法的访问修饰符。

  - 成员变量

    ​    编译看父类，运行看父类

  - 成员方法

    ​    编译看父类，运行看子类

为什么成员变量和成员方法的访问不一样呢?·

• 因为成员方法有重写，而成员变量没有

package com.object_02;

public class AnimalDemo9 {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal9 a = new Cat9();

        System.out.println(a.age);
//        System.out.println(a.weight);
// 因为成员变量​编译看和运行看父类，父类中没有，所以weight报错
// 运行出的age也是父类的40

        a.eat();
//        a.playGame();
//因为成员方法编译看父类，父类Animal中只有eat方法，所以playGame方法报错
//因为运行看子类，所以eat方法运行的结果是子类重写后的"猫吃鱼"
    }
}

实例：

package com.object_02;

public class Animal9 {
        public int age = 40;

        public void eat() {
            System.out.println("动物吃东西");
        }
    }


package com.object_02;

public class Cat9 extends Animal9 {
    public int age = 20;
    public int weight = 10;


    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}


package com.object_02;

public class AnimalDemo9 {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal9 a = new Cat9();

        System.out.println(a.age);
//        System.out.println(a.weight);
// 因为成员变量​编译看和运行看父类，父类中没有，所以weight报错
// 运行出的age也是父类的40

        a.eat();
//        a.playGame();
//因为成员方法编译看父类，父类Animal中只有eat方法，所以playGame方法报错
//因为运行看子类，所以eat方法运行的结果是子类重写后的"猫吃鱼"
    }
}

  ​    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

  ​    不能使用子类的特有成员

  ​    父类引用指向子类对象就是向上转型

格式：父类型 对象名 =new 子类型;

//向上转型
        Animal a = new Cat();
        a.eat();
//      a.playGame();   //成员方法编译看父类，父类没有playGame方法，报错

解决了多态的弊端，从而可以使用子类的特有成员  

  ​    格式：子类型 对象名 = (子类型)父类引用;

 //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();   //解决了多态的弊端，从而可以使用子类的特有成员  

拓展：

instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

以下实例创建了 displayObjectClass() 方法来演示 Java instanceof 关键字用法：

import java.util.ArrayList;
import java.util.Vector;
 
public class Main {
 
public static void main(String[] args) {
   Object testObject = new ArrayList();
      displayObjectClass(testObject);
   }
   public static void displayObjectClass(Object o) {
      if (o instanceof Vector)
      System.out.println("对象是 java.util.Vector 类的实例");
      else if (o instanceof ArrayList)
      System.out.println("对象是 java.util.ArrayList 类的实例");
      else
      System.out.println("对象是 " + o.getClass() + " 类的实例");
   }
}

以上代码运行输出结果为：

对象是 java.util.ArrayList 类的实例