一、多态
多态：可以理解为事物存在的多种体现形态

例如：
人：男人，女人

动物：猫，狗

猫 x = new 猫();

动物 x = new 猫();

1.多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接受自己的对象。

2.多态的前提
(1)必须是类与类之间有关系，要么继承，要么实现
(2)通常存在覆盖
3.多态的好处
多态的出现大大的提高了程序的扩展性。

4.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5.多态的应用

6.多态的出现代码中的特点(多态使用的注意事项)

class Animal{
        abstract void eat();
}

class Cat extends Animal{
        public void eat(){
                system.out.prinln("吃鱼");
        }
       
        public void catchMouse(){
                system.out.prinln("抓老鼠");
        }
}

class Dog extends Animal{
        public void eat(){
                system.out.prinln("吃骨头");
        }
       
        public void kanJia(){
                system.out.prinln("看门");
        }
}

class Pig extends Animal{
        public void eat(){
                system.out.prinln("饲料");
        }
        public void gongDi(){
                system.out.prinln("gongDi");
        }
}

class DuoTaiDemo{
        public static void main(String[] args){
                //Cat c = new Cat();
                //c.eat();
               
        //        Dog d = new Dog();
                //d.eat();       
                /*Cat c = new Cat();
                Cat c1 = new Cat();
                function(c1);*/
               
                ///Animal c = new Cat();
                //c.eat();
               
                function(new Cat());
                function(new Dog());
                function(new Pig());
        }
       
        public static void function(Animal a){
                a.eat();
        }
}

二、多态的转型

class Animal{
        abstract void eat();
}

class Cat extends Animal{
        public void eat(){
                system.out.prinln("吃鱼");
        }
       
        public void catchMouse(){
                system.out.prinln("抓老鼠");
        }
}

class Dog extends Animal{
        public void eat(){
                system.out.prinln("吃骨头");
        }
       
        public void kanJia(){
                system.out.prinln("看门");
        }
}

class Pig extends Animal{
        public void eat(){
                system.out.prinln("饲料");
        }
        public void gongDi(){
                system.out.prinln("gongDi");
        }
}

class DuoTaiDemo{
        public static void main(String[] args){
                Animal a = new Cat();//类型提升，向上转型。
                a.eat();
                //如果想要调用猫的特有方法时，如何操作？
                //强制将父类的引用，转成子类类型,向下转型。
                Cat c = (Cat)a;
                c.catchMouse();
                //千万不要出现这样的操作，就是将父类对象转成子类类型。
                //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以
                //被强制转换
                //Animal a = new Animal(); //这种写法就不对了,不能强制把动物转成猫
                //Cat c=(Cat)a;
               
               
        }
       
        public static void function(Animal a){
                a.eat();
        }
}

三、多态示例

基础班学生：
        学习，睡觉。
高级班学生：
        学习，睡觉。
可以将这两类事物进行抽取

abstract class Student{
        public abstract void study();
        public void sleep(){
                System.out.println("躺着睡");
        }
}

class BaseStudent extends Student{
        public void study(){
                System.out.println("study");
        }
        public void sleep(){
                System.out.println("裸睡");
        }
}

class AdvStudent extends Student{
        public void study(){
                System.out.println("adv study");
        }
}

class DoStudent{
        public void doSomething(Student stu){
                stu.study();
                stu.sleep();
        }
}

class DuoTaiDemo3{
        public static void main(String[] args){
       
                DoStudent ds = new DoStudent();
                ds.doSomething(new BaseStudent());
                ds.doSomething(new AdvStudent());
               
               
                //BaseStudent ba = new BaseStudent();
                //ba.study();
                //ba.sleep();
               
                //AvdStudent as = new AvdStudent();
                //as.study();
                //as.sleep();
        }
       
       
}

四:多态中成员(函数与变量)的特点
1.
class Fu{
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
}

class Zi extends Fu{
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
}

class Test{
        public static void main(String[] args) {
                Zi z = new Zi();
                z.method1();
                z.method2();
                z.method3();
        }
       
}

//打印结果：
zi method_1
fu method_2
zi method_3

分析：Zi复写了Fu的method1，把Fu的method2继承过来，method3是特有的

2.在多态中成员函数的特点

class Fu{
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
}

class Zi extends Fu{
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
}

class Test{
        public static void main(String[] args) {
                Fu f = new Zi();
                f.method1();
                f.method2();
                //f.method3(); //这样编译会出错
        }
       
}

//打印结果：
zi method_1
fu method_2

在多态中成员函数的特点：
在编译时期：参与引用型变量所属的类中是否有调用的方法，如果有，编译通过，
如果没有编译失败。例如：f这个引用型变量中有method1和method2，但没有method3，编译失败

在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。
编译看左边：因为f这个引用型变量中有method1和method2，但没有method3，编译失败
运行看右边：Zi类中有method1，method2从Fu中继承了过来，所以运行结果为：
zi method_1
fu method_2


3.多态中成员变量的特点：
(1)
class Fu{
        int num = 5;
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
        static void method4(){
                System.out.println("fu method_4");
        }
}

class Zi extends Fu{
        int num = 8;
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
        static void method4(){
                System.out.println("zi method_4");
        }
}

class Test{
        public static void main(String[] args) {
                Fu f = new Zi();
                f.method4();
        }
       
}

//打印结果：
fu method_4

在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。



(2)class Fu{
        int num = 5;
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
        static void method4(){
                System.out.println("fu method_4");
        }
}

class Zi extends Fu{
        int num = 8;
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
        static void method4(){
                System.out.println("zi method_4");
        }
}

class Test{
        public static void main(String[] args) {
                Fu f = new Zi();
                System.out.println(f.num);
        }
       
}
//打印结果:5
在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)

!~~~~~~~~~!

坚持总结！