java入门(二十二) | OOP(九)之多态

多态

1.1 概念

多态指同一个实体同时具有多种形式。
它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，
写出通用的代码，做出通用的编程，统一调用标准。

Demo

狗有两种形态：狗和小动物

    class Animal{}
    class Dog extends Animal{}
    class Test1{
       main(){
           Dog d = new Dog();//小狗就是小狗
          
       //父类引用 指向 子类对象--向上造型：把子类转成父类类型
           Animal a = new Dog();//多态，小狗是一种小动物
       }
    }

1.2 特点

1. 多态的前提1：是继承
2. 多态的前提2：要有方法的重写
3. 父类引用指向子类对象,如：Animal a = new Dog(); — 小到大，向上转型
4. 多态中，编译看左边，运行看右边
        编译：相当于要能够保存，保存时看左边
        运行：看结果时，运行时，看执行效果看右边

1.3 入门案例

package cn.qile.oop;

//多态的入门案例
public class Test3_DuoTai {
    public static void main(String[] args) {
        //TODO 创建父类对象测
        Fu f = new Fu();
        f.eat();//爸爸在吃肉
        //TODO 创建子类对象测
        Zi z = new Zi();
        z.show();//儿子在喝汤
        //TODO 创建多态对象测
        //1、多态：统一调用标准，统一只能调用父类提供的功能
        Fu f2 = new Zi();//父类引用， 指向 子类对象
        //2、编译看左边--想要保存，需要调用左边的功能
        //3、运行看右边  -- 运行的结果，怎么干活的，看右边看子类的实现方式
        f2.eat();//调用的是父类的eat()，但是结果是子类重写后的效果 -- 儿子在打游戏
        f2.show();//调用的是父类的show(), -- 儿子在喝汤
    }
}
//创建父类
class Fu{
    public void eat() {
        System.out.println("爸爸在吃肉");
    }
    public void show() {
        System.out.println("儿子在喝汤");
    }
}
//创建子类
//4、多态的前提1：发生继承关系
class Zi extends Fu{
    //5、多态的前提2：发生方法重写
    public void eat() {
        System.out.println("儿子在打游戏");
    }

}

2. 多态的优势

1. 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2. 提高了程序的扩展性和可维护性

class Animal{
//不关心具体的子类类型，把所有子类当做父类来看
public void eat(Object c){//Object作为方法参数，体现了程序的通用性
       c.eat();
    }
}
class Cat extends Animal {
}
class Dog extends Animal {
}

3. 多态的成员使用

3.1 特点

1. 成员变量：使用的是父类的
2. 成员方法：由于存在重写现象所以使用的是子类的
3. 静态成员：随着对象而存在，谁调用的就返回谁的

3.2 测试

package cn.qile.oop;

//多态的使用

public class Test4_DuoTai {
    public static void main(String[] args) {
        //TODO 创建父类对象测试
        Fu2 f = new Fu2();
        System.out.println(f.sum);//10
        f.eat();//Fu...eat()

        //TODO 创建子类对象测试
        Zi2 z = new Zi2();
        System.out.println(z.sum);//20
        z.eat();//Zi...eat()

        //TODO 创建多态对象测试
        Fu2 f2 = new Zi2();//父类引用 指向 子类对象  -- 向上造型
        //1、编译看左边，用了父类的eat()。运行看右边，运行结果以子类为准
        f2.eat();//Zi...eat()

        //2、多态中使用的成员变量是父类的
        System.out.println(f2.sum);//10

        //3、静态资源跟多态没有关系，是谁调用就执行谁的功能
        System.out.println(f2.age);//20，f2是Fu2父类类型

    }
}
//创建父类
class Fu2{
    int sum = 10;
    static int age = 20;

    public void eat() {
        System.out.println("Fu...eat()");
    }
}
//创建子类
class Zi2 extends Fu2{
    int sum = 20;
    static int age = 50;

    //TODO 重写eat()
    @Override//重写的标记   --  注解
    public void eat() {
        System.out.println("Zi...eat()");
    }
}