1.什么是接口？
        比抽象类更加抽象的表现形式，就称为接口

2.接口的成员特点？
        接口中的成员变量：默认修饰符public static final

        接口中的成员方法：默认修饰符public abstract

        接口中没有构造方法

        例：
        interface aaa {
                public static final int num1 = 1;
                /*public*/ static final int num2 = 2;
                /*public static*/ final int num3 = 3;
                /*public static final*/ int num4 = 4;

                // public abstract void print();

                // /*abstract*/ public void print();

                // /*public*/ abstract void print();

                // /*public abstract*/void print();

                // /*public abstract*/ static void print();//错误的，因为static
        
                // /*public abstract*/ final void print();//错误的，因为final
        }

3.接口与类的关系
        类与类：单继承，不可以多继承，可以多层继承，不可以循环继承

        类与接口：单实现，多实现

        接口与接口：单继承，多继承

4.接口和抽象类的区别？
        最主要的区别，就是设计理念的不同，也就是说咱们什么时候要用抽象类，什么时候要接口？
        
        抽象类：当两个类之间存在"is a"的关系的时候，就可以使用抽象类，让另一个继承该抽象类
        人类，学生类，老师类
        abstract class Person {
                public abstract void eat();
                public abstract void drink();
        }

        class Student extends Person {
                public void eat() {
                        System.out.println("吃肉");
                }

                public void drink() {
                        System.out.println("喝牛奶");
                }
        }

        class Teacher extends Person {
                public void eat() {
                        System.out.println("吃蔬菜");
                }

                public void drink() {
                        System.out.println("喝茶");
                }
        }

        接口：是额外扩展的功能，它与实现类本身是没什么关系的，只不过是因为实现类要使用接口里的方法，才实现的

5.运动员案例(必须会敲)

6.什么是多态？
        对象在不同的时刻表现出来的不同状态

        举例：七龙珠里的孙悟空的不同的形态

7.多态的前提条件？
        要有继承或者实现关系
        要有方法的重写
        要有父类或者父接口引用指向子类对象

8.多态间子父类之间成员变量的关系？
        比如说父类中有一个成员变量，子类中有一个成员变量

        条件：如果这两个变量的名字都不相同的话
        class Fu {
                int i = 1;
        }

        class Zi extends Fu {//要有继承关系
                int j = 2;
        }

        class Demo {
                public static void main(String[] args) {
                        Fu fu = new Zi();//要有父类引用指向子类对象
                        System.out.println(fu.i);//编译正确，1
                        System.out.println(fu.j);//编译错误
                }
        }

        条件：如果这两个变量的名字都相同的话
        class Fu {
                int i = 1;
        }

        class Zi extends Fu {//要有继承关系
                int i = 2;
        }

        class Demo {
                public static void main(String[] args) {
                        Fu fu = new Zi();//要有父类引用指向子类对象
                        System.out.println(fu.i);//编译正确，1
                        System.out.println(fu.i);//编译正确，1
                }
        }
        
        通过这两个条件的结果，我们会发现，在调用成员变量的时候，父类引用只能使用父类自身里的变量，不能使用子类里的变量
        记住口诀：编译看左边，运行看左边

9.多态间子父类继承之间成员方法的关系？
        比如说父类中有一个成员方法，子类中有一个成员方法

        条件：如果这两个方法的名字都不相同的话
        class Fu {
                public void printFu() {
                        System.out.println("Fu");
                }
        }

        class Zi extends Fu {
                public void printZi() {
                        System.out.println("Zi");
                }
        }

        class Demo {
                public static void main(String[] args) {
                        Fu fu = new Zi();
                        fu.printFu();//编译正确，Fu
                        fu.printZi();//编译错误
                }
        }

        条件：如果这两个方法的名字都相同的话
        class Fu {
                public void print() {
                        System.out.println("Fu");
                }
        }

        class Zi extends Fu {
                public void print() {
                        System.out.println("Zi");
                }
        }

        class Demo {
                public static void main(String[] args) {
                        Fu fu = new Zi();
                        fu.print();//编译正确，Zi
                        fu.print();//编译正确，Zi
                }
        }

        通过这两个条件，我们能够知道，父类引用不能使用子类里特有的方法，如果子类里有重写的方法，调用的结果就是子类重写方法里的内容
        记住口诀：编译看左边，运行看右边

10.向上和向下转型
        首先我们知道，多态的弊端是父类引用不能使用子类里特有的成员

        解决方案：使用向下转型
        
        Fu fu = new Zi();//向上转型
        Zi zi = (Zi)fu;//向下转型

        转完之后，就可以使用子类里特有的成员了

11.多态的优缺点？
        弊端：多态的弊端是父类引用不能使用子类里特有的成员
        优点：提高了扩展性，怎么体现出的扩展性呢？父类引用做为形式参数，子类对象作为实际参数进行传递
        public void print(Animal a) {
               
        }

        print(new Dog());
        print(new Cat());
        print(new Pig());

11111111111

路过蜻蜓 ~~

吊大的来了