成员变量也是局部变量
    常量 final 纯大写： MAX_A = 10;
    命名：
    驼峰（变量、方法）
    类 首字母大写
    常量：大写+下划线
    命令行可以传参
    只有一个方法的接口叫函数式接口，可以使用lambda表达式简化

    接口中可以定义静态方法和默认方法。
    接口中定义的静态方法，只能通过接口来调用。
    接口中定义的默认方法，可以通过实现类的对象来调用。
    如果实现类重写了接口中的默认方法，调用时，调用重写以后的方法。
    实现类也可以继承。
    如果子类（或实现类）继承的父类和实现的接口中，声明了同名同参数的方法，那么子类在没有重写此方法的情况下默认调用父类中的同名同参数的方法，称为类优先原则。
    如果实现类实现了多个接口，而这些接口中有同名同参的方法，会冲突，称为接口冲突。解决是在实现类中重写此方法。
    代码：

    1. package com.codeday15.demo01;
    3. public interface CompareA {
    5.     // 静态方法
    6.     public static void method1(){
    7.         System.out.println("CompareA:北京");
    8.     }
    10.     // 默认方法
    11.     public default void method2(){
    12.         System.out.println("CompareA:上海");
    13.     }
    15.     default void method03(){
    16.         System.out.println("CompareA:上海");
    17.     }
    18. }
    1. package com.codeday15.demo01;
    3. public class SubClassTest {
    4.     public static void main(String[] args) {
    5.         SubClass s = new SubClass();
    6.         CompareA.method1();//通过接口来调用可以，通过对象s来调用不行
    7.         s.method2();
    8.         s.method03();
    9.     }
    10. }
    12. class SubClass implements CompareA{
    14.     public void method2(){
    15.         System.out.println("SubClass：上海");
    16.     }
    17. }

    成员变量和局部变量：

    1. 局部变量：方法体{}中、形参、代码块{}中
    2. 成员变量：类中方法外
      1. 类变量：有static修饰
      2. 实例变量：没有static修饰

    内部类：
    1、Java允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类；
    2、内部类的分类：成员内部类 、 局部内部类；
    3、成员内部类：

    • 作为外部类的成员：

      可以调用外部类的结构；
      可以用static修饰；
      可以被4中不同的权限修饰。

    • 作为一个类：

      类内可以定义属性、方法、构造器等；
      可以被final修饰，表示此类不能被继承；
      可以被abstract修饰

      4、一些问题：
      如何实例化成员内部类的对象
      如何在成员内部类中区分调用外部类的结构
      开发中局部内部类的使用（InnerClassTest1.java，注解说得比较清除，也说清楚了匿名类的是实质） ```java package com.codeday15.demo02;

    public class InnerClassTest { public static void main(String[] args) {

    1.     //创建Dog的实例（静态成员内部类）
    2.     Person.Dog dog = new Person.Dog();
    3.     dog.show();
    5.     //创建Bird实例（非静态的成员内部类）

    // Person.Bird bird = new Person.Bird();//错误写法，非静态类不能直接实例化 Person p = new Person(); Person.Bird bird = p.new Bird();//注意此处的语法，妈的绕死了操 bird.sing();

    1.     System.out.println();
    2.     bird.displat("黄鹂");
    3. }

    }

    class Person{ String name = “小明”; int age;

    1. public void eat(){
    2.     System.out.println("人：吃饭");
    3. }
    5. //静态成员内部类
    6. static class Dog{
    7.     String name;
    8.     int age;
    10.     public void show(){
    11.         System.out.println("卡拉是条狗");
    12.     }
    14. }
    15. //非静态成员内部类
    16. class Bird{
    17.     String name = "杜鹃";
    18.      public void sing(){
    19.          System.out.println("我是一只小鸟");
    20.          Person.this.eat();//调用外部类的方法
    21.      }
    23.      public void displat(String name){
    24.          System.out.println(name);//方法的形参
    25.          System.out.println(this.name);//内部类的属性
    26.          System.out.println(Person.this.name);//外部列的属性
    28.      }
    30. }
    31. public void method(){
    32.     //局部内部类
    33.     class AA{
    35.     }
    36. }
    37. {
    38.     //局部内部类
    39.     class BB{
    41.     }
    42. }

    }

    1. ```java
    2. package com.codeday15.demo02;
    4. public class InnerClassTest1 {
    6.     // 比较少见
    7.     public void method(){
    8.         //局部内部类
    9.         class AA{
    11.         }
    12.     }
    14.     //返回一个实现Comparable接口的类的对象
    15.     public Comparable getComparable(){ //这里可能是把返回值设置成接口的意思
    17.         //创建一个实现了Comparable接口的类：局部内部类。这是一个实现类，所以需要重写接口中的方法。
    18.         //方式一：
    19.         class MyComparable implements Comparable{
    20.             @Override
    21.             public int compareTo(Object o) {
    22.                 return 0;
    23.             }
    24.         }
    25.         return new MyComparable();//牛逼，返回一个new出来的对象
    28.         //方式二：匿名实现类的匿名对象
    29.         return new Comparable() {
    30.             @Override
    31.             public int compareTo(Object o) {
    32.                 return 0;
    33.             }
    34.         };
    35.         //这里其实是对 return new Comparable(){}; 这个大括号填充后的样子，
    36.         //所以要加上;号，然后呢这里如果是new了一个普通类，那么也可以进行重写。
    37.         //这里new了一个接口，那么要实现这个接口，就必须在里面重写接口的方法。
    38.         //其实就是匿名对象，new了一个没有名字的实现类。
    39.     }
    40. }

    ended at No.364
    to be continued…