接口、多态、面向对象【学习笔记】

一、接口
1.接口的定义格式
public interface 接口名 {
//接口中的内容
}

2.接口中的抽象方法的定义
        /*
        在任何版本的Java中，接口都能定义抽象方法。
        格式：
        public abstract 返回值类型 方法名称(参数列表);

        注意事项：
        1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
        2. 这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐。）
        3. 方法的三要素，可以随意定义。
         */

        public interface MyInterfaceAbstract {

                // 这是一个抽象方法
                public abstract void methodAbs1();

                // 这也是抽象方法
                abstract void methodAbs2();

                // 这也是抽象方法
                public void methodAbs3();

                // 这也是抽象方法
                void methodAbs4();
            }

3.接口中的抽象方法如何去使用
    注意事项：接口不能直接创建对象使用
              类和接口是实现的关系，实现： implements
    A：定义一个实现类去实现该接口
    B：重写接口中的所有抽象方法
    C：创建实现类对象，调用重写后的方法即可

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
            @Override
            public void methodAbs1() {
                System.out.println("这是第一个方法！");
            }

            @Override
            public void methodAbs2() {
                System.out.println("这是第二个方法！");
            }

            @Override
            public void methodAbs3() {
                System.out.println("这是第三个方法！");
            }

            @Override
            public void methodAbs4() {
                System.out.println("这是第四个方法！");
            }
        }

4.接口中默认的方法定义和使用

    public interface MyInterfaceDefault {
            // 抽象方法
            public abstract void methodAbs();

            // 新添加的方法，改成默认方法
            public default void methodDefault() {
                System.out.println("这是新添加的默认方法");
            }
        }

        //实现类-一
        public class MyInterfaceDefaultA implements MyInterfaceDefault {
            @Override
            public void methodAbs() {
                System.out.println("实现了抽象方法，AAA");
            }
        }

        //实现类-二
        public class MyInterfaceDefaultB implements MyInterfaceDefault {
            @Override
            public void methodAbs() {
                System.out.println("实现了抽象方法，BBB");
            }

            @Override
            public void methodDefault() {
                System.out.println("实现类B覆盖重写了接口的默认方法");
            }
        }

        //测试类
        public class Demo02Interface {
            public static void main(String[] args) {
                // 创建了实现类对象
                MyInterfaceDefaultA a = new MyInterfaceDefaultA();
                a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。

                // 调用默认方法，如果实现类当中没有，会向上找接口
                a.methodDefault(); // 这是新添加的默认方法
                System.out.println("==========");

                MyInterfaceDefaultB b = new MyInterfaceDefaultB();
                b.methodAbs();
                b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
            }
        }

5.接口中静态的方法定义和使用

    //接口
        /*
        从Java 8开始，接口当中允许定义静态方法。
        格式：
        public static 返回值类型 方法名称(参数列表) {
            方法体
        }
        提示：就是将abstract或者default换成static即可，带上方法体。
         */
        public interface MyInterfaceStatic {
            public static void methodStatic() {
                System.out.println("这是接口的静态方法！");
            }
        }

        //测试类
        public class Demo03Interface {
            public static void main(String[] args) {
                // 直接通过接口名称调用静态方法
                MyInterfaceStatic.methodStatic();
            }
        }

6.接口中私有的方法定义和使用
    /*
    问题描述：
    我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
    但是这个共有方法不应该让实现类使用，应该是私有化的。

    解决方案：
    从Java 9开始，接口当中允许定义私有方法。
    1. 普通私有方法，解决多个默认方法之间重复代码问题
    格式：
    private 返回值类型 方法名称(参数列表) {
        方法体
    }

    2. 静态私有方法，解决多个静态方法之间重复代码问题
    格式：

    private static 返回值类型 方法名称(参数列表) {
            方法体
        }
         */
        public interface MyInterfacePrivateA {
            public default void methodDefault1() {
                System.out.println("默认方法1");
                methodCommon();
            }

            public default void methodDefault2() {
                System.out.println("默认方法2");
                methodCommon();
            }

            private void methodCommon() {
                System.out.println("AAA");
                System.out.println("BBB");
                System.out.println("CCC");
            }
        }

        //接口中的私有的静态方法
        public interface MyInterfacePrivateB {
            public static void methodStatic1() {
                System.out.println("静态方法1");
                methodStaticCommon();
            }

            public static void methodStatic2() {
                System.out.println("静态方法2");
                methodStaticCommon();
            }

            private static void methodStaticCommon() {
                System.out.println("AAA");
                System.out.println("BBB");
                System.out.println("CCC");
            }
        }

7.接口中的其他成员-成员变量
    接口中只能有公共的静态的最终的常量
    public static final 数据类型 变量名 = 值;

8.接口中的其他成员-构造方法
    接口中没有构造方法

9.接口的组成格式和注意事项
    1. 成员变量其实是常量，格式：
    [public] [static] [final] 数据类型 常量名称 = 数据值;
    注意：
        常量必须进行赋值，而且一旦赋值不能改变。
        常量名称完全大写，用下划线进行分隔。

    2. 接口中最重要的就是抽象方法，格式：
    [public] [abstract] 返回值类型 方法名称(参数列表);
    注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

    3. 从Java 8开始，接口里允许定义默认方法，格式：
    [public] default 返回值类型 方法名称(参数列表) { 方法体 }
    注意：默认方法也可以被覆盖重写

    4. 从Java 8开始，接口里允许定义静态方法，格式：
    [public] static 返回值类型 方法名称(参数列表) { 方法体 }
    注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

    5. 从Java 9开始，接口里允许定义私有很乏，格式：
    普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }
    静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }
    注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

    6.接口中没有构造方法

10.类和接口的关系
    类和类：继承关系，只支持单继承、不能多继承。但是可以多层继承
    类和接口：实现关系，可以多实现。还可以在继承一个类的同时，再去实现多个接口
    1. 接口是没有静态代码块或者构造方法的。
    2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
    格式：
    public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
        // 覆盖重写所有抽象方法
    }
    3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
    4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
    5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
    6. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

11.接口和接口之间的关系
    接口和接口之间可以单继承，也可以多继承

12.抽象类和接口的区别是什么？
    成员特点：
        成员变量：
            抽象类：既可以有变量也可以有常量
            接口：只有常量

        成员方法：
            抽象类：既可以有抽象方法、也可以有普通方法
            接口：即可以有抽象方法、还可以有默认方法、静态方法、私有方法

        构造方法：
            抽象类：有构造方法
            接口：没有构造方法

    关系区别：
        类与类：继承关系。java只支持单继承、不能多继承。但是可以多层继承
        类与接口：实现关系。可以单实现、也可以多实现。还可以继承一个类的同时再去实现多个接口
        接口与接口：继承关系。可以单继承、也可以多继承

    设计初衷：
        抽象类完成的是一些共性的功能，但是抽取出的共性功能没有具体的实现
        接口完成的是一些特性的功能。


13.抽象类和接口的案例
    参考课堂补充代码

二、多态
1.什么是多态
多态指的就是对象的多种表现形态
水：液体、固体、气体

2.多态的前提
    A：继承或者实现关系
    B：要有方法重写
    C：父类引用指向子类对象

3.多态访问中成员特点
    成员变量：编译看左边、运行也看左边
    成员方法：编译看左边。运行看右边
    静态方法：编译看左边。运行也看左边

4.多态的好处和弊端
    好处：
        可以提高代码的复用性和维护性(继承保证)
        可以提高代码的扩展性(多态保证)
    弊端：
        无法使用子类特有的成员

5.多态转型
    向上转型：父类引用指向子类对象
               Animal animal = new Cat();
    举例：一只猫，猫就是一只猫
          猫是动物
    向下转型：子类名称 对象名 = (子类名称)父类的引用;
               Cat cat = (Cat)animal;
            注意事项：
                必须是本来什么子类对象那就转成什么子类对象。不能转换成其他的子类
                Dog dog = (Dog)animal;  // 错误的

                Animal animal = new Animal();   // 创建父类对象
                Cat c = (Cat)animal;    // 错误的

6.instanceof关键字

        用来判断引用是否是某个具体的对象类型
        public class Demo02Instanceof {
            public static void main(String[] args) {
                Animal animal = new Dog(); // 本来是一只狗
                animal.eat(); // 狗吃SHIT

                // 如果希望掉用子类特有方法，需要向下转型
                // 判断一下父类引用animal本来是不是Dog
                if (animal instanceof Dog) {
                    Dog dog = (Dog) animal;
                    dog.watchHouse();
                }
                // 判断一下animal本来是不是Cat
                if (animal instanceof Cat) {
                    Cat cat = (Cat) animal;
                    cat.catchMouse();
                }
            }
        }