Java基础之枚举类和注解

1.枚举类的使用

1.1枚举类的使用

1. 枚举类的理解：类的对象只有有限个，确定的，我们称此类为枚举类
2. 当需要定义一组常量是强烈建议使用枚举类
3. 如果枚举类只有一个对象，则可以作为单例模式的实现方式

1.2枚举类的定义

1.2.1枚举类的属性

1. 枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰
2. 枚举类的使用 private final 修饰的属性应该在构造器中为其赋值
3. 若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的传入参数

1.2.2自定义枚举类

1. 私有化类的构造器，保证不能在类的外部创建其对象
2. 在类的内部创建枚举类的实例。声明为：public static final
3. 对象如果有实例变量，应该声明为private final，并在构造器中初始化

package com.blb.com;


public class Demo1 {

//私有的final属性
     private final  String reason;
     private final int day;
//私有构造方法
    private Demo1(String reason,int day)
    {
        this.day=day;
        this.reason=reason;
    }

    public static final Demo1 SPRING=new Demo1("春天",40);
    public static final Demo1 SUMMER=new Demo1("夏天",40);
    public static final Demo1 FULL=new Demo1("秋天",40);
    public static final Demo1 WINTER=new Demo1("冬天",40);

    @Override
    public String toString() {
        return "Demo1{" +
                "reason='" + reason + '\'' +
                ", day=" + day +
                '}';
    }

    public String getReason() {
        return reason;
    }

    public int getDay() {
        return day;
    }
}
class Text1{
    public static void main(String[] args) {
        Demo1 spring = Demo1.SPRING;
        System.out.println(spring);
    }
}

1.2.3使用enum关键字创建枚举类

使用说明

1. 使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类
2. 枚举类的构造器只能使用 private 权限修饰符
3. 枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾)。列出的实例系统会自动添加 public static final 修饰
4. 必须在枚举类的第一行声明枚举类对象

enum  Season1 {
    SPRING("春天",3),
    SUMMER("夏天",6),
    FULL("秋天",9),
    WINTER("冬天",12);
    private final String season;
   private final  int day;

   private Season1(String season,int day)
   {
       this.season=season;
       this.day=day;
   }

    public String getSeason() {
        return season;
    }

    public int getDay() {
        return day;
    }

    @Override
    public String toString() {
        return "Season1{" +
                "season='" + season + '\'' +
                ", day=" + day +
                '}';
    }
}
class text2{
    public static void main(String[] args) {
        Season1 spring = Season1.SPRING;
        System.out.println(spring);
        Season1 summer = Season1.SUMMER;
        System.out.println(summer);
    }
}

1.2.4Enum类的主要方法：

values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
toString()：返回当前枚举类对象常量的名称
举例

package com.blb.com;

enum  Season1 {
   SPRING("春天",3),
   SUMMER("夏天",6),
   FULL("秋天",9),
   WINTER("冬天",12);
   private final String season;
  private final  int day;

  private Season1(String season,int day)
  {
      this.season=season;
      this.day=day;
  }

   public String getSeason() {
       return season;
   }

   public int getDay() {
       return day;
   }

//    @Override
//    public String toString() {
//        return "Season1{" +
//                "season='" + season + '\'' +
//                ", day=" + day +
//                '}';
//    }
}
class text2{
   public static void main(String[] args) {
       Season1 spring = Season1.SPRING;
       System.out.println(spring);
       Season1 summer = Season1.SUMMER;
       System.out.println(summer);
       System.out.println("=========================");
       Season1[] values = Season1.values();
       for(Season1 season1:values)
       {
           System.out.println(season1);
       }
       System.out.println("----------------");
       Season1 season1 = Season1.valueOf("SPRING");
       System.out.println(season1);
       System.out.println(season1.toString());
   }
}

1.2.5使用enum关键字定义的枚举类实现接口的情况

1. 实现接口，在enum类中实现抽象方法
2. 让实现类的对象分别实现接口中的抽象方法

package com.blb.com;
interface Info{
    public void say();
}
enum  Season1 implements Info {
    SPRING("春天",3){
        @Override
        public void say() {
            System.out.println("春天");
        }
    },
    SUMMER("夏天",6){
        @Override
        public void say() {
            System.out.println("夏天");
        }
    },
    FULL("秋天",9){
        @Override
        public void say() {
            System.out.println("秋天");
        }
    },
    WINTER("冬天",12){
        @Override
        public void say() {
            System.out.println("冬天");
        }
    };
    private final String season;
   private final  int day;

   private Season1(String season,int day)
   {
       this.season=season;
       this.day=day;
   }

    public String getSeason() {
        return season;
    }

    public int getDay() {
        return day;
    }

}
class text2{
    public static void main(String[] args) {
        Season1 spring = Season1.SPRING;
        System.out.println(spring);
        Season1 summer = Season1.SUMMER;
        System.out.println(summer);
        System.out.println("=========================");
        Season1[] values = Season1.values();
        for(Season1 season1:values)
        {
            System.out.println(season1);
            season1.say();
        }
        System.out.println("----------------");
        Season1 season1 = Season1.valueOf("SPRING");
        System.out.println(season1);
        System.out.println(season1.toString());
    }
}

2.注解

2.1注解的概述

• 从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)
• Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
• Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方 法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在Annotation 的 “name=value” 对中。
• 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
• 未来的开发模式都是基于注解的，JPA是基于注解的，Spring2.5以上都是基于注解的，Hibernate3.x以后也是基于注解的，现在的struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式

2.2注解实例

示例1

@author 标明开发该类模块的作者，多个作者之间使用,分割
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@since 从哪个版本开始增加的
@param 对方法中某参数的说明，如果没有参数就不能写
@return 对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception 对方法可能抛出的异常进行说明 ，如果方法没有用throws显式抛出的异常就不能写
其中
@param @return 和 @exception 这三个标记都是只用于方法的。
@param的格式要求：@param 形参名 形参类型 形参说明
@return 的格式要求：@return 返回值类型 返回值说明
@exception的格式要求：@exception 异常类型 异常说明
@param和@exception可以并列多个

示例2

在编译时进行格式检查(JDK内置的三个基本注解) 
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告

示例三

跟踪代码依赖性，实现替代配置文件功能
 Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署

2.3元注解

对现有注解进行解释说明的注解

2.3.1 4个常用的元注解

1. @Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 的生命周期, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用@Rentention 时必须为该 value 成员变量指定值:

• RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释
• RetentionPolicy.CLASS:在class文件中有效（即class保留） ， 当运行 Java 程序时, JVM 不会保留注解。 这是默认值
• RetentionPolicy.RUNTIME:在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会保留注释。程序可以通过反射获取该注释。

2. @Target: 用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。
   
3. @Documented: 用于指定被该元 Annotation 修饰的 Annotation 类将被javadoc 工具提取成文档。默认情况下，javadoc是不包括注解的。 定义为Documented的注解必须设置Retention值为RUNTIME。
4. @Inherited: 被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited 修饰的 Annotation, 则其子类将自动具有该注解。

2.4 jdk5注解新特性

Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。此外，反射也得到了加强，在Java8中能够得到方法参数的名称。这会简化标注在方法参数上的注解。
示例