首页 / JAVA / 复习java第五天(枚举、Annotation(注释) 概述)

复习java第五天(枚举、Annotation(注释) 概述)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了复习java第五天(枚举、Annotation(注释) 概述)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5648字，纯文字阅读大概需要9分钟。

内容图文

一、枚举

传统的方式：

?在某些情况下，一个类的对象是有限而且固定的。例如季节类，只能有 4 个对象
?手动实现枚举类：
—private 修饰构造器。
—属性使用 private final 修饰。
—把该类的所有实例都使用 public static final 来修饰。
练习代码：
                     1
                    public
                    class
                     Season {

                     2
                     3
                    //
                    1、因为类的对象是固定的，所以类的属性是常量
                     4
                    public
                    final
                     String name;

                     5
                    public
                    final
                     String desc;

                     6
                     7
                    //
                    2、因为类的对象是有限个，所以不能在类的外部创建对象，构造器必须私有
                     8
                    private
                     Season(String name,String desc){

                     9
                    this.name = name;
10this.desc = desc;
11    }
1213//3、在类的内部创建对象，但要在类的外部能够访问到该对象，而且还不能修改。14publicstaticfinal Season SPRING = new Season("春天","春风又绿江南岸");
15publicstaticfinal Season SUMMER = new Season("夏天","映日荷花别样红");
16publicstaticfinal Season FALL = new Season("秋天","秋水共长天一色");
17publicstaticfinal Season WINTER = new Season("冬天","窗寒西岭千秋雪");
1819public String getName() {
20return name;
21    }
22public String getDesc() {
23return desc;
24    }
2526    @Override
27public String toString() {
28return "Season [name=" + name + ", desc=" + desc + "]";
29    }
30 }
Season类 
                    1
                    public
                    class
                     TestSeason {

                    2
                    3
                    public
                    static
                    void
                     main(String[] args) {

                    4
                    5         Season SPRING = Season.SPRING;
6        System.out.println(SPRING);
78    }
9 }
TestSeason类

现在的方式：

?JDK 1.5 新增的 enum 关键字用于定义枚举类。
?枚举类和普通类的区别：
—使用 enum 定义的枚举类默认继承了 java.lang.Enum 类。
—枚举类的构造器只能使用 private 访问控制符。
—枚举类的所有实例必须在枚举类中显式列出(, 分隔    ; 结尾). 列出的实例系统会自动添加
   public static final 修饰。
—所有的枚举类都提供了一个 values 方法, 该方法可以很方便地遍历所有的枚举值。
?JDK 1.5 中可以在 switch 表达式中使用枚举类的对象作为表达式, case 子句可以直接使用枚举值的名字,
  无需添加枚举类作为限定。
?若枚举只有一个成员, 则可以作为一种单子模式的实现方式。
 
注意枚举类的属性：
?枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰。
?枚举类使用 private final 修饰的属性应该在构造器中为其赋值。
?若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的传入参数。
 
实现接口的枚举类：
?和普通 Java 类一样枚举类可以实现一个或多个接口。
?若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式, 则可以让每个枚举值分别来实现该方法。
 （采用匿名内部类实现方法的重写）
 
枚举类的方法：
 
练习代码：
                            1
                            public
                            interface
                             DateInfo {

                            2
                            public
                             String getDateInfo();

                            3 }
DateInfo接口 
                             1
                            public
                            enum Season2 implements DateInfo {
 2 3     SPRING("春天","春风又绿江南岸"){
 4        @Override
 5public String getDateInfo() {
 6return "2-5";
 7        }
 8    },
 9     SUMMER("夏天","映日荷花别样红"){
10        @Override
11public String getDateInfo() {
12return "5-8";
13        }
14    },
15     FALL("秋天","秋水共长天一色"){
16        @Override
17public String getDateInfo() {
18return "8-11";
19        }
20    },
21     WINTER("冬天","窗寒西岭千秋雪"){
22        @Override
23public String getDateInfo() {
24return "11-2";
25        }
26    },;
2728private String name;
29private String desc;
3031private Season2(String name,String desc){
32this.name = name;
33this.desc = desc;
34    }
3536public String getName() {
37return name;
38    }
3940public String getDesc() {
41return desc;
42    }
4344/*    @Override 改为利用匿名内部类重写的方法更酷些
45    public String getDateInfo() {
46        System.out.println(this.toString().equals("SPRING"));
47        return null;
48    }  */49 }
Season2类继承接口DateInfo 
                             1
                            public
                            class
                             TestSeason {

                             2
                             3
                            public
                            static
                            void
                             main(String[] args) {

                             4
                             5
                            //
                                    Season SPRING = Season.SPRING;

                             6
                            //
                                    System.out.println(SPRING);

                             7
                            //
                                    System.out.println(Season2.SPRING);
                             8
                            for
                            (Season2 s:Season2.values()){

                             9
                            //
                                        System.out.println(s);

                            10
                            //
                                        System.out.println(s.toString().equals("SPRING"));
                            11
                                        System.out.println(s.getDateInfo());    

                            12
                                    }

                            13
                            14         String str = "WINTER";
15         Season2 s = Season2.valueOf(Season2.class, str);
16         System.out.println(s.getName()+" "+s.getDesc());
17    }
18 }
TestSeason测试类

 

二、Annotation(注释)

1、概述：

?从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是 Annotation(注释)。
?Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理.
 通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。
?Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明,
  这些信息被保存在 Annotation 的 “name=value” 对中。
?Annotation 能被用来为程序元素(类, 方法, 成员变量等) 设置元数据。

2、基本的 Annotation：

?使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成一个修饰符使用,
  用于修饰它支持的程序元素。
?三个基本的 Annotation:
— @Override: 限定重写父类方法, 该注释只能用于方法
— @Deprecated: 用于表示某个程序元素(类, 方法等)已过时
— @SuppressWarnings: 抑制编译器警告. 

 3、自定义 Annotation：

?定义新的 Annotation 类型使用 @interface 关键字。
?Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明. 其方法名和返回值定义了
  该成员的名字和类型。
?可以在定义 Annotation 的成员变量时为其指定初始值, 指定成员变量的初始值可使用 default 关键字。
?没有成员定义的 Annotation 称为标记; 包含成员变量的 Annotation 称为元数据 Annotation。
 
4、提取 Annotation 信息：
?JDK 5.0 在 java.lang.reflect 包下新增了 AnnotatedElement 接口, 该接口代表程序中可以
  接受注释的程序元素。
?当一个 Annotation 类型被定义为运行时 Annotation 后, 该注释才是运行时可见, 当 class 文件被载入时
  保存在 class 文件中的 Annotation 才会被虚拟机读取。
?程序可以调用 AnnotationElement 对象的如下方法来访问 Annotation 信息。
 
 
5、JDK 的元 Annotation：
?JDK 的元 Annotation 用于修饰其他 Annotation 定义
?@Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 可以保留多长时间,
 @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用 @Rentention 时必须为该 value 成员变量
    指定值:
–RetentionPolicy.CLASS: 编译器将把注释记录在 class 文件中. 当运行 Java 程序时,
  JVM 不会保留注释. 这是默认值。
–RetentionPolicy.RUNTIME:编译器将把注释记录在 class 文件中. 当运行 Java 程序时, JVM 会保留注释,
  程序可以通过反射获取该注释。
–RetentionPolicy.SOURCE: 编译器直接丢弃这种策略的注释。
?@Target: 用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素,
 @Target 也包含一个名为 value 的成员变量.
?@Documented: 用于指定被该元 Annotation 修饰的 Annotation 类将被 javadoc 工具提取成文档.
?@Inherited: 被它修饰的 Annotation 将具有继承性.如果某个类使用了被 @Inherited 修饰的 Annotation,
  则其子类将自动具有该注释.
 
练习例子：
                                         1
                                        import
                                         java.lang.annotation.ElementType;

                                         2
                                        import
                                         java.lang.annotation.Target;

                                         3
                                         4
                                        /**
                                         5
                                         * 1. 使用 @interface 定义注解

                                         6
                                         * 2. 使用类似于接口方法声明的方式来定义注解的属性: 其中返回值称为属性的类型, 方法名为属性的名称. 

                                         7
                                         * 

                                         8
                                        */
                                         9 @Target(value={ElementType.METHOD, ElementType.TYPE})
10public @interface HelloAnnotation {
1112public String name() default "atguigu";
1314 }
@interface与@Target用法 
                                         1
                                        public
                                        class
                                         TestAnnotation {

                                         2
                                         3     @SuppressWarnings("unused")
 4publicstaticvoid main(String[] args) {
 5 6         A a = new A();
 7        a.method2();
 8 9         String str = "abc";        
10    }
11}
1213 @HelloAnnotation(name="abc")
14class A{
1516    @HelloAnnotation()
17void method1(){}
1819    @Deprecated
20void method2(){}
2122}
2324class B extends A{
2526    @Override
27void method1(){}
2829 }
TestAnnotation类
 
 
 

原文：http://www.cnblogs.com/shellway/p/3719952.html

内容总结

以上是互联网集市为您收集整理的复习java第五天(枚举、Annotation(注释) 概述)全部内容，希望文章能够帮你解决复习java第五天(枚举、Annotation(注释) 概述)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1223981.html

来源：【匿名】