枚举，注解

自定义类实现枚举

1.不需要提供setXxx方法，因为枚举对象值通常为只读

2.对枚举对象/属性使用 final + static 共同修饰，实现底层优化

3.枚举对象名通常使用全部大写，常量的命名规范(XXX_XXX)

4.枚举对象根据需要，也可以有多个属性

package chapter;

public class Enum {
    public static void main(String[] args) {
        System.out.println(Season.Autumn);
    }
}
// 演示定义枚举实现
class Season{
    private String name;
    private String desc;

    //1.构造器私有化，防止new
    //2.去掉setXxx方法，防止属性被修改
    //3.在Season内部创建固定的对象
    //4.优化，可以加入final修饰符
    final public static Season Spring = new Season("春天","温暖");
    public static Season Summer = new Season("夏天","炎热");
    public static Season Autumn = new Season("秋天","凉爽");
    public static Season Winner = new Season("冬天","寒冷");

    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 "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

特点：

1.构造器私有化

2.本类内部创建对象

3.对外暴露对象(通过为对象添加public final static 修饰符)

4.可提供get方法，不能提供set

enum关键字实现枚举

1. 使用关键字enum代替class
2. 创建对象   常量名(实参列表) 
3. 多个常量，使用  逗号 作为间隔   

Spring("春天","温暖"),
Summer("夏天","炎热");

4.定义常量对象，需要写在前面

Spring("春天","温暖"), Summer("夏天","炎热");
private String name;
private String desc;

注意事项 

1.  使用enum关键字开发枚举类时，默认会继承Enum类，而且是final类 (javap)
2. 若使用无参构造器，实参列表，小括号都可以省略   

   Spring;

3.  多个枚举对象之间用逗号作为间隔，最后以分号结尾
4. 枚举对象必须放在枚举类的行首

5. 使用enum关键字后不能 继承 其他类，但可以实现接口

Enum中的方法

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

        Season spring = Season.Spring;
        //1.name
        System.out.println(spring.name());
        //2.ordinal()
        //输出枚举对象的编号，从0开始
        System.out.println(spring.ordinal());
        //3.values
        //含有定义的所有枚举对象
        Season[] values =Season.values();
        for(Season season : values){
            System.out.println(season);
        }
        //4.valueOf
        //将字符串替换为枚举对象，要求字符串必须为已经有的常量名，否则报错
        //Season spring1 = Season.valueOf("Java");
        //这句语句报错，因为Season中没有名为Java的枚举对象
        Season spring1 = Season.valueOf("Spring");
        System.out.println(spring1);
        System.out.println(spring1 == spring);

        //5.compareTo
        //比较两个枚举常量的编号,前者减后者
        System.out.println(Season.Spring.compareTo(Season.Summer));
    }
}

enum Season{
    Spring("A","A"),Summer("B","B");
    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;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

注解

1.注解Annotation也被称为 元数据Metadata ， 用于修饰 包，类，方法，睡醒，构造器，局部变量等数据信息

2.注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息

3.JavaSE，注解使用目的较为简单，如标记过时的功能，忽略警告等。

  JavaEE占据了比较重要的角色，如用来配置应用程序的切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置

基本介绍

使用Annotation时要在前面增加 @ 符号，并把该Annotation当做一个修饰符使用， 

1. @Override:限定于某个方法，是重写父类方法，只能用于方法

   @Override注解，若写，系统就会去检查该方法是否重写了父类的方法，如果没有，则报错
   
   @Target是修饰注解的注解，称为元注解

2. @Deprecated:用于表示某个程序元素(类，方法等)已过时

   public class Deprecated {
       public static void main(String[] args) {
           A a = new A();
           
           a.hi();
       }
   }
   //1.@Deprecated 修饰某个元素，表示该元素已经过时
   //2.即 不推荐使用，但仍可以使用
   //3.可以修饰 方法，类，参数，包，字段 等等
   //4.可用于升级时的过渡
   @java.lang.Deprecated
   class A{
       public int n1 = 1;
       @java.lang.Deprecated
       public void hi(){}
   }

3. @SuppressWarnings:抑制编译器警告