Java中多态

1.1 多态的概述及其代码体现

* A：多态（polymorphic)概述

* 事物存在的多种形态

* B:多态的前提

* a:要有继承关系

* b:要有方法重写。

* c:要有父类引用指向子类对象。

代码：

public class Demo01_Polymorphic {
    public static void main(String[] args) {
        Cat cat = new Cat();   // new Cat()是一个对象，小猫是一只猫
        cat.eat();

        Animal animal = new Cat(); // 父类引用指向子类对象，子类即父类
        animal.eat();
    }
}

//基本类
class Animal{
    public void eat(){
        System.out.println("动物吃饭");
    }
}

// 猫类继承了动物类
class Cat extends Animal{
    // 重写了父类方法
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

1.2多态中成员方法的特点

1.2.1 成员变量

A：多态中成员访问的特点

    * a:成员变量

        * 编译看左边（父类），运行看左边（父类）。

代码：

public class Demo02_Polymorphic {
    public static void main(String[] args) {
        Father f = new Son();     // 父类引用指向子类对象                                 
        System.out.println(f.num);       //10 f是Father类型的，只能看到father那一块输出的结果是10
        Son son = new Son();
        System.out.println(son.num);
    }
}
// 父类
class Father{
    int num = 10;
}

// 继承父类
class Son extends Father{
    int num = 20;
}

内存图：

1.2.2 成员方法

A：多态中成员访问的特点

    * a:成员方法

        * 编译看左边（父类），运行看右边（子类）。(只有这一种情况是真正的多态）

1.2.3 静态方法

A：多态中成员访问的特点

    * a:静态方法

        * 编译看左边（父类），运行看左边（子类）。

代码：

public class Demo02_Polymorphic {
    public static void main(String[] args) {
        Father f = new Son();     // 父类引用指向子类对象  f是Father类型 int a
        f.show();           // 成员方法的动态绑定
    }
}
// 父类
class Father{
    int num = 10;
    public static void show(){
        System.out.println("Father static 父类");
    }
}

// 继承父类
class Son extends Father{
    int num = 20;
    // 子类重写了父类的方法
    public static void show(){
        System.out.println("Son staitc 子类");
    }
}

1.3 多态中向上转型和向下转型

A：案例演示
    * 详细讲解多态中向上转型和向下转型
    * Person p = new SuperMan(); 向上转型
    * SuperMan sm = (SuperMan)p; 向下转型

代码：

/**
 * A：案例演示
 *     * 详细讲解多态中向上转型和向下转型
 *     * Person p = new SuperMan(); 向上转型
 *     * SuperMan sm = (SuperMan)p;向下转型
 */
public class Demo03_Polymorphic {
    public static void main(String[] args) {
        Person p = new SuperMan();   // 父类引用指向子类对象
        p.business();
        // p.fly();    // 超人所具有特性  父类的对象无法使用子类的特有方法

        SuperMan s1 = (SuperMan)p;     // int i = (int)5.0;
        s1.fly();  //  这时候可以调用子类的特有方法
    }
}

class Person{
    String name = "John";
    public void business() {
        System.out.println("谈生意");
    }
}

class SuperMan extends Person{
    String name = "SuperMan";

    // 重写了谈生意的方法
    public void business() {
        System.out.println("谈几个亿的大单");
    }
    // 特有的方法
    public void fly() {
        System.out.println("飞出去救人");
    }
}

1.4 多态的好处和弊端

* A：多态的好处

* a:提高了代码的维护性（继承保证）

* b:提高了代码的扩展性（由多态保证）

* B:案例演示

* 多态的好处

* 可以当作形式参数，可以接收任意子类对象

* C：多态的弊端

* 不能使用子类的特有属性和行为。

代码：

public class Demo01_Polymorphic {
    public static void main(String[] args) {
        Cat cat = new Cat();
        method(cat);         // 第一次调用时Animal a = cat{new Cat()};
        Dog dog = new Dog();
        method(dog);        // 第二次调用时Animal a = dog{new dog()};
        Pig pig = new Pig();// 第一次调用时Animal a = pig{new Pig()};
        method(pig);
    }

    public static void method(Animal a){   // 父类的引用指向子类对象
        a.eat();
    }
}

//基本类
class Animal{
    public void eat(){
        System.out.println("动物吃饭");
    }
}

// 猫类继承了动物类
class Cat extends Animal{
    // 重写了父类方法
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

class Dog extends Animal{
    // 重写了父类方法
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

class Pig extends Animal{
    // 重写了父类方法
    public void eat(){
        System.out.println("吃玉米");
    }
}