目录：

接口

接口定义的语法

接口作用：

内部类

局部内部类

匿名内部类

枚举

jar命令

为什么要制作 JAR 包

接口：

        接口的作用是非常丰富，接口是往往和设计模式结合在一起的。

        接口的概念：  —  可以认为接口是一种 “彻底” 的抽象类。

        接口：是从多个相似的类中抽取出来的一种规范。接口体现的是规范。

        接口体现的：通信规范。

        主板上各种不同类型的 “插槽” ，无论哪个厂商、无论哪个型号的主板，它们都可以与 CPU、显卡、内存进行数据通信。

        ——因为国际上有一套【公开】的 “标准”（规范），就是通过接口体现出来的。

接口定义的语法：

      [ 修饰符 ] interface 接口名

      {

             // 0~N 个Field 定义

             // 0~N 个抽象方法

             // 0~N 个内部类、内部接口、内部枚举定义

       }

      修饰符：  public 或 省略

      接口名：  多个单词连缀而成，每个单词的首字母大写

                       推荐接口用 “形容词”。

                       c# 推荐接口以 I 开头，所以后来有些Java程序员也喜欢这种方式。

【接口里的成分，都是 public  ——  因为接口体现的是【公开】的 “标准”】

    A。接口不能有构造器。也不能有初始化块。

    B。接口里的 Field ，默认有 3 个修饰符：public  static  final 

                                     无论你写还是不写，反正都有。

                  【接口里的 Field ，声明必须指定初始值

                      原因：final 修饰的类变量只能在声明时、静态初始化块中指定初始值，

                                 又由于接口不包含初始化块，所以只能在声明时指定初始值。】

   C。接口里的方法，默认有 2 个 ：  public  abstract

                                     无论你写还是不写，反正都有。

              接口里的方法不可能是 static，因为接口里的方法默认有 abstract 修饰

   D。接口里的内部类、内部接口、内部枚举，默认也有 2 个修饰符：public  static 

                                    无论你写还是不写，反正都有。

   E。一个接口可以有 N 个直接父接口。

接口作用：

    A。接口可用于定义变量！

    B。接口不能直接创建实例

    C。接口最大用途就是供其他类来实现自己

    implements，实现一个或N个接口。

    当一个类实现接口之后，

            A。实现类要么为接口的所有抽象方法提供实现

                     否则你的实现类也只能是抽象类

    接口主要是在 ”面向接口编程“ 时提供更灵活的机制。

接口与抽象类之间的相似之处：

         A。都可以包含抽象方法。

         B。都不能创建实例

         C。子类继承抽象类或者实现了接口，都要求实现所有的抽象方法，

               否则子类也只能是抽象类。

接口与抽象类之间的区别：

         A。接口里只能有抽象方法，但抽象类可以没有抽象方法，只包含普通方法。

         B。接口里不能定义静态方法，但抽象类可以包含静态方法

        C。接口里的 Field 总是有 public static final 

              但抽象类中的 Field 完全可以是最普通的 Field

        D。接口不能包括构造器，但抽象类完全可以有构造器。

        E。接口不能包括初始化块，但抽象类完全可以有初始化块。

        F。接口可以有多个直接的父接口，抽象类只能有一个直接父类

简单工厂模式，命令模式。

类中的 5 种成员：

    Field

    方法

    构造器

    初始化块

    内部类/接口/枚举

  可以把接口理解成一个【完全抽象、彻底抽象】的特殊类

  枚举是一种实例数固定的类。

内部类

      — 就是把一个类放在类里面定义。

     内部类 — 寄生类       外部类 — 宿主类

        内部类，由于它的上一级程序单元是类。

                           因此它完全可以使用 private | protected | 默认 | public 这 4 个访问控制符。

                      由于内部的上一级程序单元是类。可以用 static 修饰

                           有 static 修饰的内部类，属于外部类本身。

                           无 static 修饰的内部类，属于外部类的实例。

         内部类的生成的 class 文件名字为：外部类$内部类.class

~~~~~~~~~~~~~~非静态内部类~~~~~~~~~~~~~~~~~

内部类一个好处：它可以直接访问外部类的 private 成员（包括 field/方法/构造器）

    内部类可以直接访问外部类的成员，包括 private 成员！

    反过来，外部类不可以访问内部类的成员。

    内部类，还有一个名称 ”寄生类“。

        如果是没有 static 修饰的内部类的实例，必须寄生在”外部类“ 的实例里。

        如果是 static 修饰的内部类的实例，寄生在”外部类“ 的类本身里。

    非静态内部类，也是属于非静态成员，

              —— 因为不能被外部类的静态成员所访问。

~~~~~~~~~~~~~~静态内部类~~~~~~~~~~~~~~~~~

   用 static 修饰

      static 修饰的内部类的实例，必须寄生在”外部类“ 的类本身里。

      静态内部类，也是属于静态成员，因此它不能访问外部类的非静态成员（Field 方法）

使用内部类

       A。定义变量     B。创建实例     C。访问它的类 Field / 类方法

      1. 如果在外部类的里面，使用内部类。

              并没有太多需要注意的地方

      2. 在外部类的外面，使用内部类。

            A。非静态内部类

                   声明变量：  外部类.内部类   变量名

                   创建非静态内部类的实例，在此之前，必须先创建外部类的实例 — 先建宿主

                   接下来，用    宿主.new 外部类构造器();

                   非静态内部类派生子类

.                  由于子类的构造器，必须调用父类构造器一次

                   因此必须在子类构造器中使用宿主对象去调用非静态内部类的构造器

局部内部类

匿名内部类

枚举（JDK 1.5才有）

       用于代表“实例已经固定”的类

       修饰符  enum 枚举名

       {

              // 立即在第一行列出该枚举的所有实例

       }

        - 修饰符  可以是  public | 省略、abstract | final（a  f  总有其中一个）

       所有枚举都有一个values() 方法，该方法返回所有的枚举实例

枚举类可以有 Field 、方法、构造器、初始化块、内部类

       列出枚举值，并不是简单的定义几个枚举值的变量名

       而是调用枚举类的构造器来创建相应的实例

定义枚举的方法注意点：

    jar命令

命令

为什么要制作 JAR 包

/*

补充：  对于执行“宏替换”，变量名应该多个单词连缀而成

            对于字母全部大写，单词与单词之间以下划线隔开

*/