5.枚举类和注解

最新推荐文章于 2024-08-09 22:53:34 发布

code1997

最新推荐文章于 2024-08-09 22:53:34 发布

阅读量143

点赞数

分类专栏： javase 文章标签： java 反射

本文链接：https://blog.csdn.net/qq_44739500/article/details/109190859

版权

javase 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

枚举类和注解

1 枚举类

1.1 出现背景

当类的对象只有有限个，确定的。例如：季节–>春夏秋冬，性别–>男女，双性。即当我们需要定义一组常量时，强烈建议使用枚举类。如果枚举类中只有一个对象，可以以单例模式作为实现方式。

1.2 如何定义枚举类

1.2.1 JDK5.0之前

/**
 * 自定义枚举类
 */
class Season{
    //1.声明Season对象的属性:private final来修饰。
    private final String seasonName;
    private final String seasonDesc;
    //2.私有化类的构造器
    private Season(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }
    //3.提供当前枚举类的多个对象
    public static final Season SPRING=new Season("春天","春暖花开");
    public static final Season SUMMER=new Season("春天","夏日炎炎");
    public static final Season AUTUMN=new Season("春天","秋高气爽");
    public static final Season WINTER=new Season("春天","冰天雪地");
    //4.其他诉求，获取枚举类对象的属性

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

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

1.2.2 JDK5.0之后

/**
 * 使用enum关键字来定义枚举类
 */
enum Season02 implements Info{
    //1.定义对象。不能写private static final
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("这是一个春天");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("这是一个夏天");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("这是一个秋天");
        }
    },
    WINTER("冬天","天寒地冻"){
        @Override
        public void show() {
            System.out.println("这是一个冬天");
        }
    };
    //2.定义对象的属性
    private final String seasonName;
    private final String seasonDesc;
    //3.私有化类的构造器
    private Season02(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }
    //4.其他诉求，获取枚举类对象的属性

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public void show() {
        System.out.println("这是一个季节");
    }
}
interface Info{
    void show();
}

1.3 常见方法

values( )：返回枚举类对象**==>**可以点出属性
valueOf(String name)：返回对象名为name的enum类对象。
toString( )：默认打印枚举类对象的名称。

1.4 简单使用

public static void main(String[] args) {
    Season spring = Season.SPRING;
    System.out.println(spring);
    Season02 summer = Season02.SUMMER;
    //toString方法。输出：SUMMER。说明父类不是Object
    System.out.println(summer);
    //enum类父类为：class java.lang.Enum
    System.out.println(summer.getClass().getSuperclass());
    //values()：返回枚举类对象
    Season02[] values = Season02.values();
    for (int i = 0; i < values.length; i++) {
        System.out.println(values[i].getSeasonDesc());
    }
    //如果没有这个名字的对象==>Exception in thread "main" java.lang.IllegalArgumentException:
    // No enum constant com.atguigu.enumjava.Season02.WINTER1
    Season02 winter = Season02.valueOf("WINTER");
    System.out.println(winter.getSeasonDesc());
    Season02.SPRING.show();
    Season02.SUMMER.show();
    Season02.AUTUMN.show();
    Season02.WINTER.show();
}
代码输出：
Season{seasonName='春天', seasonDesc='春暖花开'}
SUMMER
class com.atguigu.enumjava.Season02
春暖花开
夏日炎炎
秋高气爽
天寒地冻
天寒地冻
这是一个春天
这是一个夏天
这是一个秋天
这是一个冬天

2 注解

2.1 注解概述

JDK5.0开始，JAVA增加了对元数据（MetaData）的支持，也就是Annotation(注解)。注解就是代码中的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具，开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。

特点：Annotation可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息被保存在Annotation的“name=value”对中。

注解是一种趋势，一定程度上来说：框架=注解+反射+设计模式。

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: 抑制编译器警告。

3）跟踪代码依赖性，实现替代配置文件功能。

Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署。

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
       private static final long serialVersionUID = 1L;
       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
       }
       protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
             doGet(request, response);
       } 
}

<servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.servlet.LoginServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
</servlet-mapping>

4）Spring中关于事物的管理

2.3 自定义注解(参照@SuppressWarnings())

2.3.1 步骤

注解声明

@interface MyAnnotation{ }
内部定义成员，通常使用value表示

String value();
可以指定成员的默认值，使用default修饰

String value() default “hello”;

4.如果自定义注解没有成员，表明只是一个标识作用。

5.如果注解有成员，在使用注解时，需要指明成员的值，有默认值则不需要。

Annotation的成员变量在Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型我们称之为配置参数。类型只能是八大基本数据类型，String类，Class类，enum类，Annotation类型以上所有类型的数组。

如果只有一个参数成员，建议使用value
如果存在默认值，定义为default
如果定义的注解含有配置参数，那么使用时必须指定参数值，除非他有默认值，格式是“参数名=参数值”，如果只有一个参数成员，且名称为value，可以省略“value=”。
没有成员定义的Annotation称之为标记，包含成员变量的Annotation称之为元数据Annotation
自定义注解必须配上注解的信息处理流程(元注解)才有意义。

6.JDK中提供的元注解

元注解是用来修饰其他注解定义

JDK5.0提供了4个标准的meta-annotation类型，分别是：

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

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

//源码
public enum RetentionPolicy {
    SOURCE,
    
    CLASS,

    RUNTIME
}
//使用
@Retention(RetentionPolicy.SOURCE)
@interface MyAnnotation1{ }
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{ }

**Target：**用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量

Target常见取值

取值（ElementType）	描述
CONSTRUCTOR	描述构造器
FIELD	描述域，属性
LOCAL_VARIABLE	描述局部变量
METHOD	描述方法
PACKAGE	描述包
PARAMETER	描述参数
TYPE	描述类，接口（注解类型）或enum声明

Documented：@Documented: 用于指定被该元注解修饰的 Annotation 类将被javadoc 工具提取成文档。默认情况下，javadoc是不包括注解的。

定义为Documented的注解必须设置Retention值为RUNTIME。

Inherited：@Inherited: 被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited修饰的注解, 则其子类将自动具有该注解。

如果把标有@Inherited注解的自定义的注解标注在类级别上，子类则可以继承父类类级别的注解，实际应用中，使用较少。

2.3.3 通过反射获取元注解信息

/**
 * 获取注解信息：需要表明@Retention(RetentionPolicy.RUNTIME)
 * 想要根据子类来获取父类的注解信息，需要@Inherited
 */
@Test
public void testGetAnnotation(){
    Class<Person> personClass = Person.class;
    Annotation[] annotations = personClass.getAnnotations();
    for (int i = 0; i < annotations.length; i++) {
        //@com.atguigu.annotationjava.MyAnnotation(value=hi)
        System.out.println(annotations[i]);
    }
}

@MyAnnotation("hi")
class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

2.4 JDK8中注解的新特性

2.4.1 可重复注解

JDK8以前的方式：声明为数组

@interfaceMyAnnotations{

MyAnnotation[] value();

}

@MyAnnotations({@MyAnnotation(value = "hello"),@MyAnnotation(value="hi")})
class A

JDK8以后的结果：

在MyAnnotation上声明@Repeatable，成员值是MyAnnotations.class

MyAnnotation的target和Retention,@Documented,@Inherited和My Annotation相同。

@Repeatable(value = MyAnnotations.class)
@Inherited
@Documented
@Target(value = {ElementType.TYPE_USE,ElementType.FIELD,ElementType.METHOD,ElementType.TYPE,ElementType.PARAMETER,ElementType.TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    String value() default "hello";

}
使用：@MyAnnotation("hello")

     @MyAnnotation("hi")

2.4.2 声明位置的扩展

元注解@Target的参数类型ElementType枚举值多了两个，在8之前注解只能在声明的地方使用，JAVA8开始，注解可以使用在任何地方。

TYPE_PARAMETER:表明该注解可以写在类型变量的声明语句中（如：泛型声明）。
TYPE_USE:表示该注解能写在使用类型的任何语句中。

class Generic<@MyAnnotation T>{
    public void show() throws @MyAnnotation RuntimeException{
        ArrayList<@MyAnnotation Object> objects = new ArrayList<>();
        int num=(@MyAnnotation int)10L;
    }
}

2.5 练习

1 定义一个三个注解，一个类worker。

1）调用无参构造方法创建对象时，读取set方法上的所有注解，对其属性进行赋值，并打印输出其string( ).

2）重写toString( )：工人[名字=‘许三多’, 年龄=18, 工作=‘军人’, 工资=10000.0]

package com.atguigu.java1;

import java.lang.annotation.*;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class WorkTest {
    public static void main(String[] args) throws IllegalAccessException {
        //1.1 使用set方法给属性附上值
        Worker worker = new Worker();
        //将Work{name='许三多', age=18, job='军人', salary=10000.0}==>工人[名字='许三多', 年龄=18, 工作='军人', 工资=10000.0]
        System.out.println(worker);
        String string = getString(worker);
        System.out.println(string);

    }

    public static String getString(Object obj) throws IllegalAccessException {
        StringBuilder builder = new StringBuilder();
        //1.1获取类注解上的值
        if (!obj.getClass().isAnnotationPresent(InnotationClass.class)){
            throw new RuntimeException("不存在指定的注解类");
        }
        InnotationClass declaredAnnotation = obj.getClass().getDeclaredAnnotation(InnotationClass.class);
        String name = declaredAnnotation.name();
        builder.append(name+"[");
        Field[] declaredFields = obj.getClass().getDeclaredFields();
        for (int i = 0; i < declaredFields.length; i++) {
            Field declaredField = declaredFields[i];
            declaredField.setAccessible(true);
            if (!declaredField.isAnnotationPresent(InnotationField.class)){
                throw new RuntimeException("不存在指定的注解类");
            }
            InnotationField declaredAnnotation1 = declaredField.getDeclaredAnnotation(InnotationField.class);
            String name1 = declaredAnnotation1.name();
            Object value = declaredField.get(obj);
            builder.append(name1+"="+value+",");

        }
        builder.setCharAt(builder.length()-1,']');
        return builder.toString();
    }
    /**
     * 用来给worker对象进行赋值
     * @param obj ：赋值对象
     */
    public static void setFiled(Object obj) throws InvocationTargetException, IllegalAccessException {
        //1.1 获取class对象
        Class<?> aClass = obj.getClass();
        //1.2 获取所有的方法
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
            //1.3 获取带有指定注解的方法：InnotationMethod
            if(declaredMethods[i].isAnnotationPresent(InnotationMethod.class)){
                InnotationMethod annotation = declaredMethods[i].getAnnotation(InnotationMethod.class);
                Class type = annotation.type();
                String value = annotation.value();
                //1.4 将type转化为指定类型的value
                Object newValue = changeType(value, type);
                //1.5 执行相应的方法
                declaredMethods[i].invoke(obj,newValue);
            }
        }
    }
    public static Object changeType(String value,Class type){
        //规定 字段类型仅限于：基本数据类型 和包装类类型和字符串类型 date类型
        if(type==int.class||type==Integer.class) {
            return Integer.parseInt(value);
        }
        if(type==Byte.class||type==byte.class) {
            return Byte.parseByte(value);
        }
        if(type==short.class||type==Short.class) {
            return Short.parseShort(value);
        }
        if(type==long.class||type==Long.class) {
            return Long.parseLong(value);
        }
        if(type==float.class||type==Float.class) {
            return Float.parseFloat(value);
        }
        if(type==double.class||type==Double.class) {
            return Double.parseDouble(value);
        }
        if(type==boolean.class||type==Boolean.class) {
            return Boolean.parseBoolean(value);
        }
        if(type== Date.class) {
            try {
                return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(value);
            } catch (ParseException e) {
                throw new RuntimeException("日期类型格式必须是：yyyy-MM-dd HH:mm:ss");
            }
        }
        if(type==String.class) {
            return value;
        }
        throw new RuntimeException("属性类型仅限于：：：基本数据类型 和包装类类型和字符串类型 date类型");

    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface InnotationClass{
    String name();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface InnotationMethod{
    String value();
    Class type();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface InnotationField{
    String name();
}

@InnotationClass(name="工人")
class Worker {

    @InnotationField(name="名字")
    private String name;
    @InnotationField(name="年龄")
    private int age;
    @InnotationField(name="工作")
    private String job;
    @InnotationField(name="工资")
    private float salary;
    @InnotationMethod(value="许三多",type=String.class)
    public void setName(String name) {
        this.name = name;
    }
    @InnotationMethod(value="18",type=Integer.class)
    public void setAge(int age) {
        this.age = age;
    }
    @InnotationMethod(value="军人",type=String.class)
    public void setJob(String job) {
        this.job = job;
    }

    @InnotationMethod(value="10000",type=Float.class)
    public void setSalary(float salary) {
        this.salary = salary;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getJob() {
        return job;
    }
    public float getSalary() {
        return salary;
    }

    public Worker() {
        try {
            WorkTest.setFiled(this);
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public Worker(String name, int age, String job, float salary) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Work{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", salary=" + salary +
                '}';
    }
}

nTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public Worker(String name, int age, String job, float salary) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Work{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", salary=" + salary +
                '}';
    }
}