多态：
        概述：事物存在多种形态。（大白话：同一事物在不同时刻，表现出来的不同状态）
        前提：
                1、要有继承关系，
                2、要有方法重写。
                3、要有父类引用执行子类对象。
                        Fu f = new Zi();
                        f.num;                //父类的
                        f.eat()                //子类的
       
        多态中成员的访问特点：
                成员变量：
                        编译看左边（父类），运行看左边（父类）。

                                编译只检查语法问题。
                成员方法：（类中的非静态成员方法） ：动态绑定
                        编译看左边（父类），运行看右边（子类）。
                        大白话：编译时会去找父类中有没有这个方法，如果有，编译不报错，没有编译就报错。
                                        运行的时候，执行的还是子类的成员方法，原因很简单，因为方法有重写。

                静态方法：
                        编译看左边（父类），运行看左边（父类）。
                        原因：因为静态是和类相关的，算不上重写。

        多态中的向上，向下转型：
                向上转型： Fu f = new Zi();     // double d = 20; 这个叫隐式类型转换
                向下转型： Zi z = (Zi)f;                // int a = (int)d;这个叫强制类型转换

                               
                案例：
                        人类：
                                属性：姓名
                                方法：谈生意
                        超人继承人类：
                                属性：name
                                方法：
                                        谈生意
                                        fly();

                class Person{
                        String name = "jack";

                        public void 谈生意(){
                                System.out.println("谈生意");
                        }
                }
                class SuperMan extends Person{
                        String name = "superMan";
                        int age ;

                        public void 谈生意(){
                                System.out.println("谈一个大单子");
                        }
                        public void fly(){
                                System.out.println("我是超人，我会飞");
                        }
                }


                Person p = new SuperMan();
                p.name = "法海";
                p.谈生意();
                p.fly();


       
        多态的好处和弊端：
                好处：
                        1、复用性。
                        2、扩展性。
                        3、可以做为形参的数据类型，用来接收各个子类的对象。 (开发中较常用)
                                public void eat(Animal a){  // Animal a = new Cat();
                                        a.eat();
                                }
                        instanceof关键字：
                                格式：  对象名 instanceof 类名
                                作用：  判断前边的引用是否是后边的数据类型。
                                                （判断前边的对象是否是后边这个类的对象）
                弊端：
                        父类引用不能使用子类的特有属性和行为。


抽象类：
        特点：
                1、抽象类和抽象方法必须用关键字abstract修饰。
                2、抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类或者是接口。（接口不是类）
                3、抽象类不能被实例化。
                        怎么实例化？
                                通过使用多态的技术，同过其具体的子类来创建对象。（抽象类的多态）
                4、抽象类的子类：
                        A：如果子类也是抽象类，可以不用重写父类中的抽象方法。
                        B：如果子类是普通类，必须重写抽象类中的所有抽象方法。
        成员特点：
                成员变量：可以是常量，也可以是变量。
                构造方法：有。
                        抽象类不能被实例化，那为什么还要有构造方法？
                                用于子类对象访问父类数据前，对父类数据进行初始化。
                成员方法：可以是抽象方法，也可以是非抽象方法。
                        抽象方法：强制要求子类必须完成某些事情。
                        非抽象方法：子类可以继承过来，提高代码的复用性。

        面试题：
                一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
                        可以。 不让其他类来创建该类的对象。

                abstract关键字不能和哪些关键字共存：
                        private：
                                private修饰的方法不能被子类继承，而抽象方法强制要求子类必须重写，他们是矛盾的。
                        final
                                final修饰的方法不能被子类重写，而抽象方法强制要求子类必须重写，他们是矛盾的。
                        static
                                static修饰的内容，可以被类名.的形式调用，而我们知道抽象方法是没有方法体的。
                                所以：类名.抽象方法是没有意义的，所以他们不能共存。
                       



                案例演示：
                        具体事务：猫，狗
                        共性：姓名，年龄，吃饭
                        猫的特性：抓老鼠
                        狗的特性：看家

                       
                        abstract class Student{
                                //属性：name，age
                               
                                //空参，带参

                                //get，set

                                //抽象方法：study();
                        }

                        class BaseStudent{
                                //空参，带参
                                //重写study()方法
                        }



接口：
        特点：
                1、接口用关键字interface修饰。
                2、类实现接口用关键字：implements。
                3、接口不能被实例化。
                4、接口的子类：
                        A：可以是抽象类，不用重写接口中的抽象方法。
                        B：可以是普通的类，必须重写接口中的所有抽象方法。（开发中较常用）

        接口的思想特点：（电脑的USB口）
                1、接口是程序对外暴露的规则。
                2、接口是程序对外的功能扩展。
                3、接口不能被实例化。
                4、接口可以多实现。     

        接口中的成员特点：（推荐，默认修饰符自己手动给出）
                成员变量：只能是常量。有默认修饰符public static final
                构造方法：没有。
                成员方法：只能是抽象方法。有默认修饰符：public abstract
                记忆：接口中有且只能有常量或者抽象方法。

        类与接口之间的关系：
                类与类：
                        继承关系。只能单继承，不能多继承，支持多层继承。
                类与接口：
                        实现关系，可以单实现，也可以多实现。
                        还可以在继承一个类的同时实现多个接口。
                接口与接口：
                        继承关系，可以单继承，也可以多继承。

        抽象类和接口的区别是：
                1、成员区别
                2、关系区别
                3、设计理念的区别   
                        抽象类：体现是“is a”，抽象类中一般定义的是整个继承体系的共性内容。
                        接口：体现是的“like a”,接口中一般定义的是整个继承体系的扩展内容。  

多态：
        概述：事物存在多种形态。（大白话：同一事物在不同时刻，表现出来的不同状态）
        前提：
                1、要有继承关系，
                2、要有方法重写。
                3、要有父类引用执行子类对象。
                        Fu f = new Zi();
                        f.num;                //父类的
                        f.eat()                //子类的
       
        多态中成员的访问特点：
                成员变量：
                        编译看左边（父类），运行看左边（父类）。

                                编译只检查语法问题。
                成员方法：（类中的非静态成员方法） ：动态绑定
                        编译看左边（父类），运行看右边（子类）。
                        大白话：编译时会去找父类中有没有这个方法，如果有，编译不报错，没有编译就报错。
                                        运行的时候，执行的还是子类的成员方法，原因很简单，因为方法有重写。

                静态方法：
                        编译看左边（父类），运行看左边（父类）。
                        原因：因为静态是和类相关的，算不上重写。

        多态中的向上，向下转型：
                向上转型： Fu f = new Zi();     // double d = 20; 这个叫隐式类型转换
                向下转型： Zi z = (Zi)f;                // int a = (int)d;这个叫强制类型转换

                               
                案例：
                        人类：
                                属性：姓名
                                方法：谈生意
                        超人继承人类：
                                属性：name
                                方法：
                                        谈生意
                                        fly();

                class Person{
                        String name = "jack";

                        public void 谈生意(){
                                System.out.println("谈生意");
                        }
                }
                class SuperMan extends Person{
                        String name = "superMan";
                        int age ;

                        public void 谈生意(){
                                System.out.println("谈一个大单子");
                        }
                        public void fly(){
                                System.out.println("我是超人，我会飞");
                        }
                }


                Person p = new SuperMan();
                p.name = "法海";
                p.谈生意();
                p.fly();


       
        多态的好处和弊端：
                好处：
                        1、复用性。
                        2、扩展性。
                        3、可以做为形参的数据类型，用来接收各个子类的对象。 (开发中较常用)
                                public void eat(Animal a){  // Animal a = new Cat();
                                        a.eat();
                                }
                        instanceof关键字：
                                格式：  对象名 instanceof 类名
                                作用：  判断前边的引用是否是后边的数据类型。
                                                （判断前边的对象是否是后边这个类的对象）
                弊端：
                        父类引用不能使用子类的特有属性和行为。


抽象类：
        特点：
                1、抽象类和抽象方法必须用关键字abstract修饰。
                2、抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类或者是接口。（接口不是类）
                3、抽象类不能被实例化。
                        怎么实例化？
                                通过使用多态的技术，同过其具体的子类来创建对象。（抽象类的多态）
                4、抽象类的子类：
                        A：如果子类也是抽象类，可以不用重写父类中的抽象方法。
                        B：如果子类是普通类，必须重写抽象类中的所有抽象方法。
        成员特点：
                成员变量：可以是常量，也可以是变量。
                构造方法：有。
                        抽象类不能被实例化，那为什么还要有构造方法？
                                用于子类对象访问父类数据前，对父类数据进行初始化。
                成员方法：可以是抽象方法，也可以是非抽象方法。
                        抽象方法：强制要求子类必须完成某些事情。
                        非抽象方法：子类可以继承过来，提高代码的复用性。

        面试题：
                一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
                        可以。 不让其他类来创建该类的对象。

                abstract关键字不能和哪些关键字共存：
                        private：
                                private修饰的方法不能被子类继承，而抽象方法强制要求子类必须重写，他们是矛盾的。
                        final
                                final修饰的方法不能被子类重写，而抽象方法强制要求子类必须重写，他们是矛盾的。
                        static
                                static修饰的内容，可以被类名.的形式调用，而我们知道抽象方法是没有方法体的。
                                所以：类名.抽象方法是没有意义的，所以他们不能共存。
                       



                案例演示：
                        具体事务：猫，狗
                        共性：姓名，年龄，吃饭
                        猫的特性：抓老鼠
                        狗的特性：看家

                       
                        abstract class Student{
                                //属性：name，age
                               
                                //空参，带参

                                //get，set

                                //抽象方法：study();
                        }

                        class BaseStudent{
                                //空参，带参
                                //重写study()方法
                        }



接口：
        特点：
                1、接口用关键字interface修饰。
                2、类实现接口用关键字：implements。
                3、接口不能被实例化。
                4、接口的子类：
                        A：可以是抽象类，不用重写接口中的抽象方法。
                        B：可以是普通的类，必须重写接口中的所有抽象方法。（开发中较常用）

        接口的思想特点：（电脑的USB口）
                1、接口是程序对外暴露的规则。
                2、接口是程序对外的功能扩展。
                3、接口不能被实例化。
                4、接口可以多实现。     

        接口中的成员特点：（推荐，默认修饰符自己手动给出）
                成员变量：只能是常量。有默认修饰符public static final
                构造方法：没有。
                成员方法：只能是抽象方法。有默认修饰符：public abstract
                记忆：接口中有且只能有常量或者抽象方法。

        类与接口之间的关系：
                类与类：
                        继承关系。只能单继承，不能多继承，支持多层继承。
                类与接口：
                        实现关系，可以单实现，也可以多实现。
                        还可以在继承一个类的同时实现多个接口。
                接口与接口：
                        继承关系，可以单继承，也可以多继承。

        抽象类和接口的区别是：
                1、成员区别
                2、关系区别
                3、设计理念的区别   
                        抽象类：体现是“is a”，抽象类中一般定义的是整个继承体系的共性内容。
                        接口：体现是的“like a”,接口中一般定义的是整个继承体系的扩展内容。