面向对象之多态

多态

1.概念

多态是面向对象程序设计(oop)的一个重要特征，指同一个实体同时具有多种形式，即可一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

2.特点

1.多态的前提：要有继承、要有方法的重写
2.父类引用指向子类对象，如 Animal a=new Cat();
3. 多态中，编译看左边，运行看右边

3.练习：多态入门案例

package cn.tedu.oop2;


import jdk.nashorn.internal.ir.CatchNode;

public class TestDemo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        cat cat = new cat();
        Dog dog = new Dog();
        animal.eat();
        cat.eat();
        dog.eat();
        //父类引用指向子类对象
        //解释创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存
      Animal a2=new cat();
        Animal a3 =new Dog();
        /**编译看左边，运行看右边
         * 解释:必须要在父类定义这个方法，才能通过编译，把多态对象看作是父类类型
         *  必须要在子类重写这个方法，才能满足多态，时机干活的是子类*/
        a2.eat();
    }

}
//多态的前提：继承+重写
//1.创建父类
class Animal{
    public void eat(){
        System.out.println("小动物Animal吃啥都行");
    }

}
class cat extends Animal{
    //对父类的功能不满意重写eat
    public void eat(){
        System.out.println("小猫爱吃小鱼干");
    }
    //添加子类的特有功能
    public void jump(){
        System.out.println("小猫Cat跳的老高了");
    }
}
//创建第二个Animal子类
class Dog extends Animal{
    @Override
    //注解@Override如果加上不报错 就代表重写成功
    public void eat(){
        System.out.println("小狗爱吃肉骨头");
    }
    //添加子类的特有功能
    public void run(){
        System.out.println("小狗Dog跑的老快了");
    }
}

多态的好处

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

多态的使用

前提：多态对象把自己看作是父类类型
1.成员变量：使用的是父类的
2.成员方法：由于存在重写现象，所以使用的是子类的
3.静态成员：随着类的加载而加载，谁调用就返回谁的

多态问题，无论向上向下转型，都记住一句话：
编译看左边，运行看右边
意思：编译时候，看左边的对象有没有该方法，运行时候结果看new的对象时谁，就调用谁的方法
.

package cn.tedu.oop2;

import javax.annotation.processing.SupportedOptions;

/*本类用于测试多态成员的使用情况*/
public class TestDemo2 {
    public static void main(String[] args) {
        Dog2 dog2 = new Dog2();
        System.out.println(dog2.sum);
        dog2.eat();

        Animal2 a=new Dog2();
        //多态中成员变量使用的是父类的成员变量
        System.out.println(a.sum);
        //多态中方法的声明使用的是父类的，方法体使用的是子类的
        a.eat();
        //多态中，调用的静态方法是父类的，因为多态对象把自己看作是父类类型
//        直接使用父类中的静态资源
        a.play();
        Animal2.play();

    }

}
class Animal2{
    int sum=10;
    public void eat(){
        System.out.println("吃啥都行");
         
    }
    public static void play(){
        System.out.println("玩啥都行");
    }

}
class Dog2 extends Animal2{
    int sum=20;
    public void eat(){
        System.out.println("小狗爱吃肉包子");
    }
//    @Override
    /**这不是一个重写的方法，只是恰巧在两个类中出现了一摸一样的两个静态方法
     * 静态方法属于类资源，只有一份，不存在重写的现象，
     * 在哪个类里定义，就作为哪个类的资源使用*/
    public static void play(){
        System.out.println("小狗爱玩皮球66");
    }
}                                                                                                                                                                                                                                                                                                                                                                                                             

运行结果