枚举、成员内部类

枚举
使用自定义的方式，来组织一个季节性的枚举类型
1. 提供一堆可以向外界暴露的该类型的对象
2. 构造器私有化
3. 可以提供属性，用来描述对象信息, 使用private final修饰
4. 给属性提供getXXX方法，向外界暴露，不要提供setXXX方法，因为只读。

public class Season {
    public static final Season SPRING = new Season("春天","春暖花开");
    public static final Season SUMMER = new Season("夏天","烈日炎炎");
    public static final Season AUTUMN = new Season("秋天","落叶归根");
    public static final Season WINTER = new Season("冬天","白雪皑皑");

    private final String name;  //对象的名字
    private final String desc;  //对象的描述
    private Season(String name,String desc){
        this.name = name;
        this.desc = desc;
    }
    public String getName(){
        return name;
    }
    public String getDesc(){
        return desc;
    }
    @Override
    public String toString(){
        return name;
    }
}

枚举的测试 

public class SeasonTest {
    public static void main(String[] args) {
        Season s = Season.AUTUMN;
        //直接输出。 打印的是对象的地址
        System.out.println(s);
        //打印这个季节的名字
        System.out.println(s.getName());

        //获取这个季节的描述信息
        System.out.println(s.getDesc());

    }
}

使用构造器获取一堆枚举对象。
1. 枚举类里的第一行，必须是枚举的对象
2. 如果提供构造器，构造器必须私有化，枚举对象必须显式调用构造器
3. 可以提供属性，必须私有化。
4. 自定义的枚举，默认继承了java.lang.Enum抽象类

public enum Season {
    SPRING("春天","春暖花开"),SUMMER("夏天","烈日炎炎"),
    AOTUMN("秋天","落叶归根"),WINTER("冬天","白雪皑皑");

    private String name;
    private String desc;
    private Season(String name,String desc){
        this.name = name;
        this.desc = desc;
    }
    public String getName(){
        return name;
    }
    public String getDesc(){
        return desc;
    }

    public static void main(String[] args) {
        Season season = Season.SUMMER;
        System.out.println(season.name);
        System.out.println(season.desc);
    }
}

内部类

与成员平级，没有static
private,默认，protected,public
成员内部类：
1. 定义在一个类的里面，与类的其他成员是平级关系。没有static修饰
2. 该内部类的访问权限可以是private，默认的，protected,public

静态内部类：
定义在一个类的内部，与这个类的成员（属性、方法）平级，并且使用static修饰的类。
1、访问权限可以是任意的权限，类似于一个类中的成员。
2、实例化的过程中，直接使用 new实例化一个外部类 .内部类对象即可。
3、内部类编译后，也会生成.class字节码文件。格式：外部类$内部类 .class

局部内部类：（方法中用的最少）
定义在某一个代码段中的中。
1、没有访问权限修饰符。
2、在当前方法中，直接实例化即可
3、内部类编译后，也会生成.class字节码文件。格式：外部类$序号内部类 .class
4、在方法中定义的内部类，和局部变量的用法一样。出了作用域就失效了。

public class Outer {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);

        class Inner{
            private String name;
            public Inner(String name) {
                this.name = name;
            }
            public String getName() {
                return name;
            }
        }

        Inner inner = new Inner("小明");
        System.out.println(inner.getName());

    }

}

匿名内部类

没有名字的内部类，内部类，通常是需要配合其他的类或者接口一块使用的。

在匿名内部类中，一般情况下不去添加新的成员（属性、方法），因为即便进行了添加，得到的对象也是向 上转型后的对象，不能访问子类中的成员。在匿名内部类中，一般是用来做方法的重写实现的。
匿名内部类也会生成 .class字节码文件，命名格式 : 外部类$序号 .class

// 实例化了一个匿名子类对象，并向上转型为父类类型
Person xiaoming = new Person() {
   // 这里，其实就是一个内部类的类体
   // 这个类，因为没有名字，因此是一个匿名内部类 // 这个类，是继承自 Person类的
   // 因此，这个类是Person类的匿名子类
   @Override
   public void work() {
      System.out.println("搬砖 "); }
};