day12

接口：

 1、如何声明一个接口
    【修饰符】 interface 接口名{

      }
   【修饰符】 class 类名{
     }
2、接口的成员
      JDK1.8之前：
     （1）全局静态的常量  public static final
     （2）公共的抽象的方法  public abstract
     JDK1.8之后：增加了两个成员
    （1）默认方法
    （2）静态方法
 3、如何使用接口？
    （1）全局静态的常量：通过接口名直接调用
    （2）抽象方法，由实现类（就是子类）来实现它
  
    【修饰符】 class 实现类名  implements 接口们{
      //如果这个类不是抽象类，那么必须实现接口的所有的抽象方法
       }
  
     接口可以比喻成“干爹”，可以有好几个
     继承可以比喻成“亲爹”，只能有一个，所以单继承
    
4、接口的特点
   （1）接口也是不能直接创建对象
   （2）一个类可以同时实现多个接口
   （3）一个类可以同时继承它的父类，又实现接口，要求必须继承在前，实现在后
    【修饰符】 class 实现类名 extends 父类  implements 接口们{
     //如果这个类不是抽象类，那么必须实现接口的所有的抽象方法
      }
   （4）接口和父类有点像，所以接口的变量与实现类对象可以构成多态引用
   （5）一个实现类实现接口时，必须实现接口的所有的抽象方法，否则这个实现类也得是抽象类
   （6）接口可以继承接口，并且可以继承多个接口。
    【修饰符】interface 接口名 extends 接口们{
      }

关系：
     类与类之间：继承，单继承  extends
     类与接口之间：类实现接口，可以多实现 implements
     接口与接口之间：继承，多继承 extends
  
JDK1.8之后，接口增加了两个成员：
  1、静态方法
       和类中的静态方法的格式一样。
       调用时：通过“接口名."调用即可
       原来为了为某个接口提供工具类，还要增加一个类，现在就不同了，直接在接口中声明静态方法即可。
       而且这些静态的实现和接口的实现类是什么类型无关。
  2、默认方法
      语法格式：
      【修饰符】 interface 接口{
                【修饰符】 default 返回值类型  方法名([形参列表]){
                         方法体
                         }
         }
 如何调用？
       必须通过接口的"实现类对象."才能调用
 
       某一个接口的某个抽象方法，可能它的多数实现类对该方法的实现是一样的，那么就没必要每一个实现类都写一遍。
       把这样的方法实现，提取到接口中声明为默认方法，如果其他不一样的实现类，可以选择“重写”。

默认方法的冲突问题：
    1、当某个类实现了多个接口，多个接口的默认方法的方法签名是一样的
         必须重写，但是在重写的时候可以选择（1）保留其中一个（2）选择完全重写
    2、当某个类继承了父类，又实现了接口，但是父类中有一个方法和接口中的默认方法的方法签名是一样的
        默认选择保留“父类”，当然也可以选择重写（1）选择父接口的（2）完全重写

简单工厂模式（了解）：
    （1）当创建某个对象比较麻烦
    （2）想要与被创建的对象的类型解耦合
 工厂模式的目的：对象的创建者与对象的使用者角色分离
 代码的结构：
    （1）接口
    （2）有接口的很多实现类
    （3）有一个工厂类，专门new接口的各种实现类的对象
    （4）使用接口的实现类对象的地方，通过工厂类之间获取对象，而不直接new实现类对象
代理模式：（了解）
     1、接口：主题接口
     2、被代理者
     3、代理者
    （1）被代理者和代理者都要实现主题接口。
    （2）要指定代理者为谁代理，即代理者中必须持有被代理者对象的引用

内部类：定义在另一个类里面的类叫做内部类。把外面的这个类称为外部类。
   内部类分为：
       1、成员内部类
            在外部类的里面，在外部类的方法的外面。
       （1）静态成员内部类：有static修饰
       （2）非静态成员内部类：没有static修饰
       2、局部内部类
          在外部类的方法体里面。
      （1）有名局部内部类
      （2）匿名局部内部类

为什么要用内部类？
       类的概念：一类具有相同特性的事物，用一个Java类进行描述。例如：学生类，身体类
       内部类也是类，当某个事物的内部，存在另一个事物，发现也需要一个Java类进行描述，而且这个内部的事物只为外部类服务，
       基本上不会单独使用，那么这个时候用内部类比较合适。定义内部类还有一个好处，内部类可以使用外部类的私有成员。

一、静态内部类
    1、语法格式：
       【修饰符】 class 外部类{
            //静态成员内部类
       【修饰符】 static class 内部类{
            }
         }

     2、静态内部类也是一个类
      （一）静态内部类的成员（都可以）
        （1）属性：类变量和实例变量
        （2）方法：静态方法和非静态方法，抽象方法(只有静态内部类是个抽象类就可以)
        （3）构造器：无参构造，有参构造
        （4）代码块：静态代码块和非静态代码块
        （5）内部类：各种内部类
     （二）静态内部类可以继承父类实现接口
     （三）有自己的字节码文件： 外部类名$静态内部类名.java
    3、如何使用静态内部类
     （1）在外部类中使用静态内部类， 和原来使用其他类一样。
     （2）在外部类的外面使用静态内部类
              使用静态内部类，前面要加“前缀”，“外部类名.内部类名”
     （3）在静态内部类中，使用外部类的成员
              不能在静态内部类中，使用外部类的非静态成员（属性和方法），其他的都能用
二、非静态的成员内部类
     1、语法格式：
       【修饰符】 class 外部类{
            //非静态成员内部类
            【修饰符】 class 内部类{
               }
         }
     2、非静态内部类也是一个类
     （一）非静态内部类的成员（都可以）
         （1）属性：实例变量
         （2）方法：非静态方法，抽象方法(只有非静态内部类是个抽象类就可以)
         （3）构造器：无参构造，有参构造
         （4）代码块：非静态代码块
         （5）内部类：各种非静态内部类
    （二）非静态内部类可以继承父类实现接口
    （三）有自己的字节码文件： 外部类名$非静态内部类名.java
   3、如何使用静态内部类
  （1）在外部类中使用非静态内部类
           在外部类的静态成员中不能使用非静态的内部类（特殊）
  （2）在外部类的外面使用非静态内部类
          步骤：
             第一步：先创建外部类的对象
             第二步：通过外部类的对象访问内部类的构造器创建内部类的对象  或者  通过外部类的某个方法来返回内部类的对象
             第三步：才能通过内部类的对象访问它的成员
 （3）在非静态内部类中，使用外部类的成员
           直接使用，没有限制