13 Java枚举和注解

Java枚举

在某些情况下，一个类的对象是有限而且固定的。例如季节类，只能有 4 个对象。

当类的对象是有限时，就应该使用枚举，而不使用普通类。（枚举对象是单例模式）

 枚举的属性

 实现接口的枚举类

 例子

public class Test5 {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        spring.showInfo();
        spring.test();
        
        Season summer = Season.SUMMER;
        summer.showInfo();
        summer.test();
        
        Season spring2 = Season.SPRING;
        //每次执行Season.SPRING获得是相同的对象，枚举类中的每个枚举对象都是单例模式
        System.out.println(spring.equals(spring2));//true
    }
}

enum Season implements ITest{
    //枚举的实例对象都是默认修饰：private static final
    //下面的四个实例对象虽然没有修饰，但是已经是修饰了，只是没显式修饰。
    SPRING("春天","春暖花开"),//此处相当于在调用有参的私有构造private season(String name,String desc)
    SUMMER("夏天","炎炎夏日"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","寒风凛冽");
    
    private final String name;
    private final String desc;
    
    private Season(String name,String desc) {
        this.name = name;
        this.desc = desc;
    }
    public void showInfo() {
        System.out.println(this.name+ ": "+this.desc); 
    }
    
    @Override
    public void test() {
        System.out.println("实现接口的方法，这是("+this.name+")的调用。");
    }
}


interface ITest{
    public void test();
}

枚举类的常用方法

 比较重要的是compareTo()方法，这个之前TreeSet和TreeMap都有例子，这里就不演示了。

Annotation注解

注解概述

注解作用：每当你创建描述符性质的类或者接口时,一旦其中包含重复性的工 作，就可以考虑使用注解来简化与自动化该过程。 Java提供了四种元注解，专门负责新注解的创建工作。  

基本的注解

 例子

import java.util.ArrayList;
import java.util.List;

public class Test6 {
    public static void main(String[] args) {
        TestB n = new TestB();
        n.test1();//可以看见方法名有删除线，但是还是可以使用
        
        //通常集合没有指定泛型，会有警告
        //可以使用@SuppressWarnings()注解 ： 抑制编译器警告
        @SuppressWarnings({ "rawtypes", "unused" })
        List list = new ArrayList();
    }
}

class TestA{
    public void test() {}
}

class TestB extends TestA{
    //常见 @Override注解，作用：重写方法
    @Override
    public void test() {
        // TODO Auto-generated method stub
        super.test();
    }
    
    //过时的方法注解：@Deprecated，声明该方法已经过时了
    @Deprecated
    public void test1() {
        //过时的方法
        System.out.println("过时的方法");
    }
}

自定义注解

 

 例子

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class Test7 {
    
    //注解这些属性有什么用呢，通常都是要取出注解的属性使用，要通过反射取注解的属性，反射暂时没学，略过
    @TestAnn(id=1,desc = "test")
    int i;
//    @TestAnn(id=1,desc = "test")这里会报错，因为该注解已经限定只能在属性使用。
    public static void main(String[] args) {
        
    }
}

/**
 * 
 * @author leak
 *    自定义注解格式 : @interface 注解名
 *    @Target: 注解声明该自定义注解的“作用对象”，比如这个注解是作用于属性/类/方法/接口/枚举
 *    @Retention()：声明该注解的生命周期，就是该注解什么时候有效
 *    @Documented:Javadoc工具会将此注解标记元素的注解信息包含在javadoc中。默认，注解信息不会包含在Javadoc中。
 */

@Target(ElementType.FIELD)//这里是作用于属性，也就是说这个自定义注解只能在属性上使用
@Retention(RetentionPolicy.RUNTIME)//这里是运行时都有效
@Documented
@interface TestAnn{
    public int id() default 0;
    public String desc() default "";
}

下面是注解的详细信息，上面的只是简单的介绍。

元注解     

元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的metaannotation类型，它们被用来提供对其它 annotation类型作说明。 Java5.0定义的元注解：      

1.@Target      

2.@Retention       

3.@Documented   

4.@Inherited  

这些类型和它们所支持的类在java.lang.annotation包中可以找到。

下面我们看一下每个元注解的作用和相应分参数的使用说明。

@Target    

@Target说明了Annotation所修饰的对象范围：Annotation可被用 于 packages、types（类、接口、枚举、Annotation类型）、类型成员 （方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、 catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰 的目标。  

作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）    

取值(ElementType)有：      

1.CONSTRUCTOR: 用于描述构造器        

2.FIELD: 用于描述域    

3.LOCAL_VARIABLE: 用于描述局部变量      

4.METHOD: 用于描述方法    

5.PACKAGE: 用于描述包  

6.PARAMETER: 用于描述参数  

7.TYPE: 用于描述类、接口(包括注解类型) 或enum声明
使用示例：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/*** * * 实体注解接口 */
@Target(value = { ElementType.TYPE })
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Entity {
    /**
     * 实体默认firstLevelCache属性为false
     * 
     * @return boolean
     */
    boolean firstLevelCache() default false;

    /**
     * 实体默认secondLevelCache属性为false
     * @return boolean
     */
    boolean secondLevelCache() default true;

    /**
     * 表名默认为空
     * @return String
     */
    String tableName() default "";

    /**
    *  默认以""分割注解 
    */
    String split() default "";
}

@Retention  

@Retention定义了该Annotation被保留的时间长短：某些Annotation 仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译 在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载 时将被读取（请注意并不影响class的执行，因为Annotation与class在使用
上是被分离的）。使用这个meta­Annotation可以对 Annotation的“生命 周期”限制。    

作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期 （即：被描述的注解在什么范围内有效）    

取值（RetentionPoicy）有：        

1.SOURCE:在源文件中有效（即源文件保留）        

2.CLASS:在class文件中有效（即class保留）        

3.RUNTIME:在运行时有效（即运行时保留）  

使用示例：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/*** * 字段注解接口 */
@Target(value = { ElementType.FIELD }) // 注解可以被添加在属性上
@Retention(value = RetentionPolicy.RUNTIME) // 注解保存在JVM运行时 刻,能够在运行时刻通过反射API来获取到注解的信息
public @interface Column {
    String name();
    // 注解的name属性   Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以
    // 通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理
}

@Documented  

@Documented用于描述其它类型的annotation应该被作为被标注的程序 成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是 一个标记注解，没有成员。

@Inherited    

@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的 类型是被继承的。

如果一个使用了@Inherited修饰的annotation类型被用于 一个class，则这个annotation将被用于该class的子类。
注意：

@Inherited annotation类型是被标注过的class的子类所继承。

类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继 承annotation。    

当@Inherited annotation类型标注的annotation的Retention是 RetentionPolicy.RUNTIME，则反射API增强了这种继承性。

如果我们使用 java.lang.reflect去查询一个@Inherited annotation类型的 annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指 定的annotation类型被发现，或者到达类继承结构的顶层。  

自定义注解概述     

使用@interface自定义注解时，自动继承了 java.lang.annotation.Annotation接口，由编译程序自动完成其他细 节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注 解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名 称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、 String、enum）。可以通过default来声明参数的默认值。    

定义注解格式：    

public @interface 注解名 {定义体}     注解参数的可支持数据类型：        

1.所有基本数据类型 （int,float,boolean,byte,double,char,long,short)        

2.String类型        

3.Class类型        

4.enum类型        

5.Annotation类型        

6.以上所有类型的数组    

Annotation类型里面的参数该怎么设定:

第一：只能用public或默认(default)这两个访问权修饰.例如,String  value();这里把方法设为defaul默认类型；    
第二：参数成员只能用基本类型 byte,short,char,int,long,float,double,boolean八种基本数据类型 和 String,Enum,Class,annotations等数据类型,以及这一些类型的数 组.例如,String value();这里的参数成员就为String;       

第三：如果只有一个参数成员,最好把参数名称设为"value",后加小括号. 例:下面的例子FruitName注解就只有一个参数成员。    

简单的自定义注解和使用注解实例：

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//示例1
/*** *主键注解接口 */
@Target(value = { ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Id {
}

//示例2
/** 属性不需要被持久化注解 **/
@Target(value = { ElementType.FIELD })
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@interface Transient {
}

注解元素的默认值：    

注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注 解时指定，非基本类型的注解元素的值不可为null。因此, 使用空字符串或0 作为默认值是一种常用的做法。这个约束使得处理器很难表现一个元素的存在或 缺失的状态，因为每个注解的声明中，所有元素都存在，并且都具有相应的值， 为了绕开这个约束，我们只能定义一些特殊的值，例如空字符串或者负数，一次 表示某个元素不存在，在定义注解时，这已经成为一个习惯用法。  

定义了注解，并在需要的时候给相关类，类属性加上注解信息，如果没有响应的 注解信息处理流程，注解可以说是没有实用价值。如何让注解真真的发挥作用，
主要就在于注解处理方法，下一步我们将学习注解信息的获取和处理！  

如果没有用来读取注解的方法和工作，那么注解也就不会比注释更有用处了。使 用注解的过程中，很重要的一部分就是创建于使用注解处理器。Java SE5扩展 了反射机制的API，以帮助程序员快速的构造自定义注解处理器。

注解处理器类库(java.lang.reflect.AnnotatedElement)：    

Java使用Annotation接口来代表程序元素前面的注解，该接口是所有 Annotation类型的父接口。除此之外，Java在java.lang.reflect 包下 新增了AnnotatedElement接口，该接口代表程序中可以接受注解的程序元 素，该接口主要有如下几个实现类：

Class：类定义    

Constructor：构造器定义    

Field：累的成员变量定义    

Method：类的方法定义    

Package：类的包定义    

java.lang.reflect 包下主要包含一些实现反射功能的工具类，实际 上，java.lang.reflect 包所有提供的反射API扩充了读取运行时 Annotation信息的能力。当一个Annotation类型被定义为运行时的 Annotation后，该注解才能是运行时可见，当class文件被装载时被保存在 class文件中的Annotation才会被虚拟机读取。    

AnnotatedElement 接口是所有程序元素（Class、Method和 Constructor）的父接口，所以程序通过反射获取了某个类的 AnnotatedElement对象之后，程序就可以调用该对象的如下四个个方法来访 问Annotation信息：

方法1：<T extends Annotation> T getAnnotation(Class<T>  annotationClass): 返回改程序元素上存在的、指定类型的注解，如果该类 型注解不存在，则返回null。    

方法2：Annotation[] getAnnotations():返回该程序元素上存在的 所有注解。    

方法3：boolean is AnnotationPresent(Class<?extends  Annotation> annotationClass):判断该程序元素上是否包含指定类型的注解，存在则返回true，否则返回false.    

方法4：Annotation[] getDeclaredAnnotations()：返回直接存在 于此元素上的所有注释。与此接口中的其他方法不同，该方法将忽略继承的注 释。（如果没有注释直接存在于此元素上，则返回长度为零的一个数组。）该方 法的调用者可以随意修改返回的数组；这不会对其他调用者返回的数组产生任何 影响。    

一个简单的注解处理器：

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;

import org.chen.day11.FruitColor.Color;

/***********注解声明***************/
/** 水果名称注解 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface FruitName {
    String value() default "";
}

/** 水果颜色注解 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface FruitColor {
    /** * 颜色枚举 * * */
    enum Color {
        BULE, RED, GREEN
    };

    /** * 颜色属性 * @return */
    Color fruitColor() default Color.GREEN;
}

/** 水果供应者注解 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface FruitProvider {
    /** * 供应商编号 * @return */
    public int id() default -1;

    /** * 供应商名称 * @return */
    public String name() default "";

    /** * 供应商地址 * @return */
    public String address() default "";
}

/*********** 注解使用 ***************/
class Apple {
    // 下面进行注解赋值
    @FruitName("Apple")
    private String appleName;
    @FruitColor(fruitColor = Color.RED)
    private String appleColor;
    @FruitProvider(id = 1, name = "陕西红富士集团", address = "陕西省西安市延安路89号红 富士大厦")
    private String appleProvider;

    // 下面的set/get方法对比注解，是不是注解更方便，如果赋值要属性一个个用set方法设置
    // get/set这里只是对比，没有使用到，可注释掉
    public void setAppleColor(String appleColor) {
        this.appleColor = appleColor;
    }

    public String getAppleColor() {
        return appleColor;
    }

    public void setAppleName(String appleName) {
        this.appleName = appleName;
    }

    public String getAppleName() {
        return appleName;
    }

    public void setAppleProvider(String appleProvider) {
        this.appleProvider = appleProvider;
    }

    public String getAppleProvider() {
        return appleProvider;
    }
}

/*********** 注解处理器 ***************/
public class FruitRun {
    public static void getFruitInfo(Class<?> clazz) {
        String strFruitName = " 水果名称：";
        String strFruitColor = " 水果颜色：";
        String strFruitProvicer = "供应商信息：";
        //getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的声明字段。
        Field[] fields = clazz.getDeclaredFields();
        // 遍历所有注解包含的信息
        for (Field field : fields) {
            //注解算特殊的类
            if (field.isAnnotationPresent(FruitName.class)) {
                FruitName fruitName = (FruitName) field.getAnnotation(FruitName.class);
                strFruitName = strFruitName + fruitName.value();
                System.out.println(strFruitName);// 输出水果名称
            } else if (field.isAnnotationPresent(FruitColor.class)) {
                FruitColor fruitColor = (FruitColor) field.getAnnotation(FruitColor.class);
                strFruitColor = strFruitColor + fruitColor.fruitColor().toString();
                System.out.println(strFruitColor);// 输出水果颜色
            } else if (field.isAnnotationPresent(FruitProvider.class)) {
                FruitProvider fruitProvider = (FruitProvider) field.getAnnotation(FruitProvider.class);
                strFruitProvicer = " 供应商编号：" + fruitProvider.id() + " 供应 商名称：" + fruitProvider.name() + " 供应商地址："
                        + fruitProvider.address();
                System.out.println(strFruitProvicer);// 输出水果详细信息
            }
        }
    }

    /*********** 输出结果 ***************/
    /** * @param args */
    public static void main(String[] args) {
        //在Apple.class对属性赋值的，getFruitInfo()取出注解里面的值
        FruitRun.getFruitInfo(Apple.class);
    }
}