面向对象：8、多态

1、什么是多态

多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。

这对于大型系统来说能提高系统的灵活性和扩展性。

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

相同类域的不同对象,调用相同的方法,执行结果是不同的

一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型

子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法,如果重写了,那么调用的就是重写之后的方法。

原理：编译看左边，运行看右边。

2、重写、重载和多态的关系

重载是编译时多态

调用重载的方法,在编译期间就要确1 定调用的方法是谁,如果不能确定则编译报错

重写是运行时多态

调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用,是运行时动态和对象绑定的)

3、多态的注意事项

1. 多态是方法的多态，属性没有多态性。
2. 编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常。
3. 多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

4、多态存在的条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：

1. static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2. final方法，因为被final修饰的方法无法被子类重写
3. private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，就不是多态

5、方法绑定

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。

静态绑定：

在编译期完成，可以提高代码执行速度。

动态绑定：

通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了final类、final方、static方法，所有方法都是JVM在运行期才进行动态绑定的。

多态：如果编译时类型和运行时类型不一致，就会造成多态。

6、代码实现

Person

package com.hsy.extend.polymorphic;

public class Person {
   String name;
   int age;
   
   int id = 1001;
   
   public void eat(){
      System.out.println("人：吃饭");
   }
   
   public void walk(){
      System.out.println("人：走路");
   }
   
}

Man

package com.hsy.extend.polymorphic;

public class Man extends Person{
   
   boolean isSmoking;
   
   int id = 1002;
   
   public void earnMoney(){
      System.out.println("男人负责挣钱养家");
   }
   
   public void eat(){
      System.out.println("男人多吃肉，长肌肉");
   }
   
   public void walk(){
      System.out.println("男人霸气的走路");
   }

}

Woman

package com.hsy.extend.polymorphic;

public class Woman extends Person{
   
   boolean isBeauty;
   
   public void goShopping(){
      System.out.println("女人喜欢购物");
   }
   
   public void eat(){
      System.out.println("女人少吃，为了减肥");
   }
   
   public void walk(){
      System.out.println("女人窈窕的走路");
   }
}

PersonTest

package com.hsy.extend.polymorphic;



/*
 * 面向对象特征之三：多态性
 * 
 * 1.理解多态性：可以理解为一个事物的多种形态。
 * 2.何为多态性：
 *   对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
 *   
 * 3. 多态的使用：虚拟方法调用
 *   有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
 *   总结：编译，看左边；运行，看右边。
 *   
 * 4.多态性的使用前提：  ① 类的继承关系  ② 方法的重写
 * 
 * 5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
 */
public class PersonTest {
   
   
   public static void main(String[] args) {
      
      Person p1 = new Person();
      p1.eat();
      
      Man man = new Man();
      man.eat();
      man.age = 25;
      man.earnMoney();
      
      //*************************************************
      System.out.println("*******************");
      //对象的多态性：父类的引用指向子类的对象
      Person p2 = new Man();
//    Person p3 = new Woman();
      //多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
      p2.eat();
      p2.walk();
      
//    p2.earnMoney();
      
      System.out.println(p2.id);//1001
      
   }
}

7、多态的使用举例

package com.hsy.extend.polymorphic;

import java.sql.Connection;


//多态性的使用举例一：
public class AnimalTest {
   
   public static void main(String[] args) {
      
      AnimalTest test = new AnimalTest();
      test.func(new Dog());
      
      
      test.func(new Cat());
   }
   
   public void func(Animal animal){//Animal animal = new Dog();
      animal.eat();
      animal.shout();
      
      if(animal instanceof Dog){
         Dog d = (Dog)animal;
         d.watchDoor();
      }
   }
   
// public void func(Dog dog){
//    dog.eat();
//    dog.shout();
// }
// public void func(Cat cat){
//    cat.eat();
//    cat.shout();
// }
}


class Animal{
   
   
   public void eat(){
      System.out.println("动物：进食");
   }
   
   public void shout(){
      System.out.println("动物：叫");
   }
   
   
}

class Dog extends Animal{
   public void eat(){
      System.out.println("狗吃骨头");
   }
   
   public void shout(){
      System.out.println("汪！汪！汪！");
   }
   
   public void watchDoor(){
      System.out.println("看门");
   }
}
class Cat extends Animal{
   public void eat(){
      System.out.println("猫吃鱼");
   }
   
   public void shout(){
      System.out.println("喵！喵！喵！");
   }
}

//举例二：

class Order{
   
   public void method(Object obj){
      
   }
}

//举例三：
class Driver{
   
   public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
      //规范的步骤去操作数据
//    conn.method1();
//    conn.method2();
//    conn.method3();
      
   }
   
}

8、多态是运行时行为！！！！！

package com.hsy.extend.polymorphic2;


import java.util.Random;

//面试题：多态是编译时行为还是运行时行为？
//证明如下：
class Animal {

    protected void eat() {
        System.out.println("animal eat food");
    }
}

class Cat extends Animal {

    protected void eat() {
        System.out.println("cat eat fish");
    }
}

class Dog extends Animal {

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

    }

}

class Sheep extends Animal {


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

    }


}

public class InterviewTest {

    public static Animal getInstance(int key) {
        switch (key) {
            case 0:
                return new Cat();
            case 1:
                return new Dog();
            default:
                return new Sheep();
        }

    }

    public static void main(String[] args) {
        int key = new Random().nextInt(3);

        System.out.println(key);

        Animal animal = getInstance(key);

        animal.eat();

    }

}