Java学习-第一部分-第二阶段-第二节：枚举和注释

枚举和注释

笔记目录：(https://www.cnblogs.com/wenjie2000/p/16378441.html)
自定义类实现枚举

先看一个需求
要求创建季节(Season)对象，请设计并完成。
创建Season对象有如下特点
1.季节的值是有限的几个值(spring, summer, autumn, winter)
2.只读，不需要修改。

1. public class Test {
2.     public static void main(String[] args) {
3.         //使用
4.         Season spring = new Season("春天", "温暖");
5.         Season winter = new Season("冬天","寒冷");
6.         Season summer = new Season("夏天","炎热");
7.         Season autumn = new Season("秋天","凉爽");
8.         //autumn.setName("XXX");
9.         //autumn.setDesc("非常的热..");
10.         //因为对于季节而已，他的对象(具体值)，是固定的四个，不会有更多
11.         //按照这个设计类的思路，不能体现季节是固定的四个对象
12.         //因此，这样的设计不好===>枚举类[枚:一个一个举:例举，即把具体的对象一个一个例举出来的类
13.         //就称为枚举类]
14.         Season other = new Season("红天","~~" );
15.     }
16. }
17. class Season {
18.     private String name;
19.     private String desc;//描述
20.     public Season(String name, String desc) {this.name = name;this.desc = desc;}
21.     public String getName() {return name;}
22.     public void setName(String name) {this.name = name;}
23.     public String getDesc() { return desc;}
24.     public void setDesc(String desc) {this.desc = desc;}
25. }

复制代码

解决方案-枚举

• 枚举对应英文(enumeration,简写enum)
  
• 枚举是一组常量的集合。
  
• 可以这里理解:枚举属于一种特殊的类,里面只包含一组有限的特定的对象。
  

枚举的二种实现方式

• 自定义类实现枚举
  
• 使用enum关键字实现枚举
  

1. package enum_;
3. public class Test {
4.     public static void main(String[] args) {
5.         System.out.println(Season.AUTUMN);
6.         System.out.println(Season.SPRING);
7.     }
8. }
10. //演示定义枚举实现
11. class Season {
12.     private String name;
13.     private String desc;//描述
15.     //定义了四个对象，固定.
16.     public static final Season SPRING = new Season("春天","温暖");
17.     public static final Season WINTER = new Season("冬天","寒冷");
18.     public static final Season AUTUMN = new Season("秋天","凉爽");
19.     public static final Season SUIMMER = new Season("夏天","炎热");
21.     //1．将构造器私有化,目的防止直接new
22.     //2．去掉setXxx方法，防止属性被修改
23.     //3．在Season内部，直接创建固定的对象
24.     //4.优化,可以加入final修饰符
25.     private Season(String name, String desc) {
26.         this.name = name;
27.         this.desc = desc;
28.     }
30.     public String getName() {
31.         return name;
32.     }
34.     public String getDesc() {
35.         return desc;
36.     }
38.     @Override
39.     public String toString() {
40.         return "Season{" +
41.                 "name='" + name + '\'' +
42.                 ", desc='" + desc + '\'' +
43.                 '}';
44.     }
45. }

复制代码

小结:进行自定义类实现枚举,有如下特点;

• 构造器私有化
  
• 本类内部创建一组对象
  
• 对外暴露对象(通过为对象添加public final static修饰符)
  
• 可以提供get方法,但是不要提供set
  

enum关键字实现枚举

使用enum来实现前面的枚举案例，看演示，主要体会和自定义类实现枚举不同的地方。

1. public class Test {
2.     public static void main(String[] args) {
3.         System.out.println(Season.SPRING);
4.     }
5. }
7. //演示定义枚举实现
8. enum Season {
9.     //定义了四个对象，固定.
10. //    public static final Season SPRING = new Season("春天","温暖");
11. //    public static final Season WINTER = new Season("冬天","寒冷");
12. //    public static final Season AUTUMN = new Season("秋天","凉爽");
13. //    public static final Season SUIMMER = new Season("夏天","炎热");
15.     //如果使用了enum来实现枚举类//1。使用关键字 enum替代 class
16.     //2. public static final Season SPRING = new Season("春天"，"温暖")直接使用//SPRING("春天"，"温暖")）解读常量名(实参列表I
17.     //3．如果有多个常量(对象)，使用，号间隔即可
18.     //4．如果使用enum 来实现枚举，要求将定义常量对象，写在前面
19.     SPRING("春天", "温暖"), WINTER("冬天", "寒冷");;
21.     private String name;
22.     private String desc;//描述
24.     //1．将构造器私有化,目的防止直接new
25.     //2．去掉setXxx方法，防止属性被修改
26.     //3．在Season内部，直接创建固定的对象
27.     //4.优化,可以加入final修饰符
28.     private Season(String name, String desc) {
29.         this.name = name;
30.         this.desc = desc;
31.     }
32.     public String getName() {
33.         return name;
34.     }
35.     public String getDesc() {
36.         return desc;
37.     }
38.     @Override
39.     public String toString() {
40.         return "Season{" +
41.                 "name='" + name + '\'' +
42.                 ", desc='" + desc + '\'' +
43.                 '}';
44.     }
45. }

复制代码

enum关键字实现枚举注意事项

• 当我们使用enum 关键字开发一个枚举类时，默认会继承Enum类[如何证明:用javap指令反编译能看见继承自Enum]
  
  
• 传统的public static final Season2 SPRING = new Season2("春天""温暖");简化成SPRING(“春天","温暖")，这里必须知道，它调用的是哪个构造器.
  
• 如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略
  1. enum Season {
  2.     SPRING("春天", "温暖"),AUTUMN;;
  3.     private Season() {
  4.     }
  5.     //......
  6. }

  复制代码
• 当有多个枚举对象时，使用,间隔，最后有一个分号结尾
  
• 枚举对象必须放在枚举类的行首.
  

举例说明enum常用的方法的使用

• toString:Enum类已经重写过了,返回的是当前对象名,子类可以重写该方法,用于返回对象的属性信息
  
• name:返回当前对象名(常量名）,子类中不能重写
  
• ordinal:返回当前对象的位置号，默认从0开始
  
• values:返回当前枚举类中所有的常量（此处常量即枚举对象）（value方法被隐藏了，源码中找不到）
  
• valueOf:将字符串转换成枚举对象,要求字符串必须为已有的常量名，否则报异常!
  
• compareTo: 比较两个枚举常量，比较的就是编号!
  

1. public class Test {
2.     public static void main(String[] args) {
3.         //使用Season2枚举类,来演示各种方法
4.         Season2 autumn = Season2.AUTUMN;
5.         //输出枚举对象的名字
6.         System.out.println(autumn.name());
7.         //ordinal()输出的是该枚举对象的次序/编号，从0开始编号
8.         // AUTUMN枚举对象是第三个，因此输出2
9.         System.out.println(autumn.ordinal());
10.         //从反编译可以看出values方法,返回Season2[]
11.         //含有定义的所有枚举对象
12.         Season2[] values = Season2.values();
13.         System.out.println("===遍历取出枚举对象(增强for)====");
14.         for (Season2 season : values) {//增强for循环
15.             System.out.println(season);
16.         }
17.         //valueOf:将字符串转换成枚举对象，要求字符串必须VT为已有的常量名，否则报异常
18.         // 执行流程
19.         // 1.根坍你输入的“AUTUMN ”到Season2的枚举对象去查找
20.         // 2.如果找到了，就返回，.如果没有找到，就报错
21.         Season2 autumn1 = Season2.valueOf("AUTUMN");
22.         System.out.println("autumn1=" + autumn1);
23.         System.out.println(autumn == autumn1);
24.         //compareTo:比较两个枚举常量，比较的就是编号
25.         //2．看看结果
26.         /*
27.         public final int compareTo(E o) {
28.             return self.ordinal - other.ordinal;
29.         }
30.         Season2.AUTUMN的编号[3] - Season2.SUMMER的编号[1]
31.         */
32.         System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));//3-1
33.     }
34. }
35. //演示定义枚举实现
36. enum Season2 {
37.     //定义了四个对象，固定.
38.     //    public static final Season SPRING = new Season("春天","温暖");
39.     //    public static final Season WINTER = new Season("冬天","寒冷");
40.     //    public static final Season AUTUMN = new Season("秋天","凉爽");
41.     //    public static final Season SUMMER = new Season("夏天","炎热");
42.     //如果使用了enum来实现枚举类//1。使用关键字 enum替代 class
43.     //2. public static final Season SPRING = new Season("春天"，"温暖")直接使用//SPRING("春天"，"温暖")）解读常量名(实参列表I
44.     //3．如果有多个常量(对象)，使用，号间隔即可
45.     //4．如果使用enum 来实现枚举，要求将定义常量对象，写在前面
46.     SPRING("春天", "温暖"),
47.     SUMMER("夏天", "炎热"),
48.     WINTER("冬天", "寒冷"),
49.     AUTUMN;
50.     Season2() {
51.     }
52.     private String name;
53.     private String desc;//描述
54.     //1．将构造器私有化,目的防止直接new
55.     //2．去掉setXxx方法，防止属性被修改
56.     //3．在Season内部，直接创建固定的对象
57.     //4.优化,可以加入final修饰符
58.     private Season2(String name, String desc) {
59.         this.name = name;
60.         this.desc = desc;
61.     }
62.     public String getName() {return name;}
63.     public String getDesc() { return desc;}
64. }

复制代码

注意

• 使用enum关键字后，就不能再继承其它类了，因为enum会隐式继承Enum,而Java是单继承机制。
  
• 枚举类和普通类一样，可以实现接口，如下形式。
  enum 类名 implements 接口1，接口2{}
  

JDK内置的基本注解类型(了解就行)

注解的理解

• 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。
  
• 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。
  
• 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替java EE旧版中所遗留的繁冗代码和XML配置等。
  

基本的Annotation介绍
使用Annotation时要在其前面增加@符号,并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
三个基本的Annotation:

• @Override:限定某个方法,是重写父类方法,该注解只能用于方法
  
• @Deprecated:用于表示某个程序元素(类,方法等)已过时
  
• @SuppressWarnings:抑制编译器警告
  

@Override

Override:限定某个方法，是重写父类方法,该注解只能用于方法

1. class Father{
2.     public void fly(){
3.         System.out.println("Father fly.….");
4.     }
5. }
6. class Son extends Father {
7.     //解读
8.     //1.@Override 注解放在fly方法上，表示子类的fly方法时重写了父类的fly
9.     //2.这里如果没有写@0verride还是重写了父类fly
10.     //3．如果你写了@Override注解，编译器就会去检查该方法是否真的重写了父类的
11.     // 方法，如果的确重写了，则编译通过，如果没有构成重写，则编译错误
12.     /*
13.         @Target(ElementType.HETHOD)
14.         @Retention(RetentionPolicy.SOURCE)
15.         public @interface Override {
16.         }
17.     */
18.     @Override  //说明
19.     public void fly() {
20.         System.out.println("Son fly...");
21.     }
22. }

复制代码

> 补充说明:@interface的说明
@interface不是interface，是注解类，是jdk5.0之后加入的
>Override使用说明

• @Override表示指定重写父类的方法（从编译层面验证)，如果父类没有fly方法，则会报错
  
• 如果不写@Override注解,而父类仍有public void fly00，仍然构成重写
  
• @Override只能修饰方法，不能修饰其它类，包，属性等等
  
• 查看@Override注解源码为@Target(ElementType.METHOD),说明只能修饰方法
  
• @Target是修饰注解的注解，称为元注解
  

@Deprecated

@Deprecated的说明

• 用于表示某个程序元素(类,方法等)已过时
  
• 可以修饰方法，类,字段,包,参数等等
  
• @Target(value={CONSTRUCTOR,FIELD, LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER, TYPE})
  
• @Deprecated的作用可以做到新旧版本的兼容和过渡
  

1. @Deprecated
2. class A{
4. }

复制代码

@suppresswarnings

@SuppressWarnings:抑制编译器警告

1. //关于SuppressWarnings作用范围是和你放置的位置相关
2. //看看@SuppressWarnings 源码
3. /*
4.     @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
5.     @Retention(RetentionPolicy.SOURCE)
6.     public @interface SuppressWarnings {
7.         String[] value();
8.     }
9. */
10. @SuppressWarnings({"unused","unchecked"})
11. public class Test {
12.     public static void main(String[] args) {
13.         int i;//没有 @SuppressWarnings({"unused"})会出现黄色警告:i没有被使用
14.     }
15. }

复制代码

>说明各种值

• all是忽略所有警告
  
• unchecked是忽略没有检查的警告
  
• rawtypes是忽略没有指定泛型的警告(传参时没有指定泛型的警告错误)
  
• unused是忽略没有使用某个变量的警告错误
  
• 其他关键字使用相对较少，需要可自行百度
  
• @SuppressWarnings可以修饰的程序元素为,查看@Target
  
• 生成@SupperssWarnings时，不用背，直接点击左侧的黄色提示，就可以选择(注意可以指定生成的位置)
  

元注解:对注解进行注解(不重要，仅需了解)

元注解的基本介绍
JDK的元 Annotation用于修饰其他Annotation
元注解:本身作用不大，讲这个原因主要用来辅助理解源码。看源码时，可以知道他是干什么.
元注解的种类(使用不多,了解,不用深入研究)

• Retention    //指定注解的作用范围，三种 SOURCE,CLASS,RUNTIME
  
• Target    //指定注解可以在哪些地方使用
  
• Documented     //指定该注解是否会在javadoc体现
  
• Inherited    //子类会继承父类注解
  

Retention注解

说明
只能用于修饰一个 Annotation定义，用于指定该 Annotation可以保留多长时间,@Rentention包含一个 RetentionPolicy类型的成员变量，使用@Rentention时必须为该vajue成员变量指定值:
@Retention的三种值

• RetentionPolicy.SOURCE:编译器使用后，直接丢弃这种策略的注解
  
• RetentionPolicy.CLASS:编译器将把注解记录在class文件中.当运行Java程序时,JVM不会保留注解。这是默认值
  
• RetentionPolicy.RUNTIME:编译器将把注解记录在 class 文件中.当运行Java程序时,JVM会保留注解.程序可以通过反射获取该注解
  

@Target

基本说明
用于修饰Annotation定义,用于指定被修饰的Annotation能用于修饰哪些程序元素.@Target也包含一个名为value的成员变量。
源码

1. @Documented
2. @Retention(RetentionPolicy.RUNTIME)//它的作用范围是RUNTIME
3. @Target(ElementType.ANNOTATION_TYPE)//这里的ANNOTATION TYPE 说明@Target只能修饰注解
4. public @interface Target {
5.     /**
6.      * Returns an array of the kinds of elements an annotation type
7.      * can be applied to.
8.      * @return an array of the kinds of elements an annotation type
9.      * can be applied to
10.      */
11.     ElementType[] value();//可以简单看一下ElementType的取值//通过Enum 比如:TYPE等
13. }

复制代码

@Documented

基本说明
@Documented:用于指定被该元 Annotation修饰的Annotation类将被javadoc工具提取成文档,即在生成文档时,可以看到该注解。
说明:定义为Documented的注解必须设置Retention值为RUNTIME。
案例

1. @Documented
2. @Retention(RetentionPolicy.RUNTIME)
3. @Target(value={CONSTRUCTOR, FIELD,LOCAL_VARIABLE, METHOD, PACKAGE,PARAMETER, TYPE)
4. public @interface Deprecated {//一个Deprecated 注解@Documented,则javadoc会看到Deprecated
5. }

复制代码

@Inherited

被它修饰的Annotation将具有继承性.如果某个类使用了被@Inherited修饰的Annotation,则其子类将自动具有该注解
说明:实际应用中,使用较少，了解即可。
元注解:本身作用不大,讲这个原因希望编程看源码时,可以知道他是干什么。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！