static、接口、多态、内部类

静态
     我们希望类中的某些成员是被全局共享的，在内存中也只存储一份，这样有利于我们后期的代码维护。
     静态使用 static 进行修饰，静态成员是属于类/接口的，可以在没有对象的情况下，直接使用类名调用。
     可以使用对象去访问静态成员，但不推荐！！！
     静态代码块
         使用 static 修饰的构造代码块就是静态代码块，它的特点是在类加载的时候执行，由于类只加载一次
         所有静态代码块也只会执行一次。
接口
     接口也是 Java 中的一种数据类型，和类一样，也会被编译成字节码文件。
     接口使用 interface 关键字定义，接口中可以定义的成员有
         - 静态常量
         - 抽象方法
         - 默认方法（1.8）
         - 静态方法（1.8）
     定义格式
         public interface MyInterface {
             // 静态常量
             public static final int MIN_VALUE = 1;
             int MAX_VALUE = 99;
             // 抽象方法
             public abstract void method1();
             void method2();
             // 默认方法（1.8）
             public default void method3() {
                 //方法体
             }
             default void method4() {
                 //方法体
             }
             // 静态方法（1.8）
             public static void method5() {
                 //方法体
             }
             static void method6() {
                 //方法体
             }
         }
     接口实现
         类和类之间是继承关系，类和接口之间是实现关系（类似继承），支持多实现，使用 implements 关键字。
         实现的语法格式：
             public interface MyInterface {
             }
             public class MyInterfaceImpl implements MyInterface {
             }
         多实现的语法格式
             public class 实现类 extends 父类 implements 接口A, 接口B... {
             }
         多实现后的注意事项
             如果多个父接口中有重名的抽象方法，实现类【仅需】重写一次。
             如果多个父接口中有重名的默认方法，实现类【必须】重写一次。
             如果父类中的成员方法和接口中的默认方法重名，优先执行父类的。
     接口继承
         接口和接口之间是继承关系，使用 extends 关键字，并且支持多继承。
         语法格式
             public interface 子接口 extends 父接口A, 父接口B... {
             }
         多继承后的注意实现
             多个父接口中的默认方法重名，子接口必须要重写一次。
多态
     什么是多态？
         在面向对象的编程语言中，多态指的是同一个方法，在不同的对象上，有不同的实现。在执行的时候也会有不同的表现。
     多态的前提？
         1. 继承或实现关系（二选一）
         2. 方法重写（不重写，无意义）
         3. 父类引用指向子类对象（多态的语法格式）
     多态的格式
         父类类型 对象名 = new 子类类型();
         举例：
             Animal a = new Dog();
     多态时访问成员的特点
         成员变量：访问的是父类的
         成员方法：访问的是子类的
         静态方法：访问的是父类的
         总结：多态时，成员方法访问的是子类的，其他都是父类的。
     多态的表现形式
         - 普通父类多态
         - 抽象父类多态
         - 接口多态
     多态的应用场景
         - 变量多态
         - 参数多态
         - 返回值多态
     多态的好处
         - 多态能够提升我们程序的可扩展性和可维护性。
     多态的弊端
         - 无法调用子类中特有的方法。
引用类型的转换
     向上转型：多态的语法格式就是向上转型
     向下转型：将一个父类类型的对象，转换成一个子类类型的对象，需要使用强制类型转换的语法。
     Animal a = new Cat();
     a.eat();
     a.sleep();
     //a.catchMouse(); //错误，无法访问子类中特有的成员
     //向下转型
     if (a instanceof Cat) {
         Cat c = (Cat)a;
         c.catchMouse();
     }
     在向下转型的过程中，可能会有类型转换错误的风险，Java 给我们提供了一个 instanceof 关键字，用于
     判断一个对象是否属于某个类型。
内部类
     一个类中又定义了一个类，里面的类就是内部类。
     语法格式
         public class Car { //外部类
             public class Engine { //内部类
             }
         }
     创建内部类对象
         在外部类中创建：
             和普通的类的对象创建格式是一样的，没有区别，内部类名 对象名 = new 内部类名();
         在其他类中创建：
             外部类.内部类 对象名 = new 外部类().new 内部类();
     匿名内部类
         如果要【临时】使用一个接口/抽象类，可以使用匿名内部类对象的方式，临时的创建一个实现类/子类对象。
         语法格式
             public abstract class Animal {
                 public abstract void eat();
             }
             Animal a = new Animal() {
                 public void eat() {
                     //方法体;
                 }
             };
             a.eat();
         应用场景
             - 将匿名内部类对象赋值给一个变量
             - 将匿名内部类对象作为方法的参数进行传递
             - 将匿名内部类对象做法方法的返回值