第07章_java枚举类和注解

已于 2023-02-12 22:58:45 修改
阅读量137 收藏
点赞数
分类专栏： java 文章标签： java spring 开发语言
于 2023-02-10 14:37:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46655235/article/details/128969785
版权

7.枚举类和注解

7.1 枚举类

/*
1.枚举类的说明：
    1.1 枚举类的理解：类的对象只有确定的有限个
    1.2 当需要定义一组常量时，强烈建议使用枚举类
    1.3 如果枚举类中只有一个对象，则可以作为单例模式的实现方式
2.如何自定义枚举类？步骤：
 */
class Season{
    //2.1 声明属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.2 私有化类的构造器
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //2.3 提供当前枚举类的多个对象：public static final修饰
    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("冬天","冰天雪地");

    //2.4 其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    //2.5 其他诉求2：提供toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}
/*
3.使用enum定义枚举类。（JDK 5.0 新增）步骤：
 */
enum Season1{
    //3.1 提供当前枚举类的多个对象，多个对象之间用","隔开，末尾对象用";"结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");
    //3.2 声明属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;
    //3.3 私有化类的构造器
    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //3.4 其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

}
/*
4.使用enum定义的枚举类实现接口的两种情况
    4.1 在enum类中实现接口中的抽象方法
 */

interface Info{
    void show();
}
enum Season2 implements Info{
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    private final String seasonName;
    private final String seasonDesc;
    private Season2(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public void show() {
        System.out.println("春夏秋冬");
    }
}

/*
    4.2 让枚举类的对象分别实现接口中的抽象方法
 */

enum Season3 implements Info{
    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("冬天");
        }
    };

    private final String seasonName;
    private final String seasonDesc;
    private Season3(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

public class Main {
    @Test
    public void test1(){
        Season2.SPRING.show();//春夏秋冬
        Season2.SUMMER.show();//春夏秋冬
        Season2.AUTUMN.show();//春夏秋冬
        Season2.WINTER.show();//春夏秋冬

        Season3.SPRING.show();//春天
        Season3.SUMMER.show();//夏天
        Season3.AUTUMN.show();//秋天
        Season3.WINTER.show();//冬天
    }
/*
5.使用enum定义的枚举类的常用方法：（继承于java.lang.Enum类）
    5.1 values():返回所有的枚举类对象所构成的数组
    5.2 valueOf(String objName):返回枚举类中名为objName的对象
    5.3 toString():返回枚举类对象的名称
 */
    @Test
    public void test2(){
        //values():返回所有枚举类对象所构成的数组
        Season3[] values = Season3.values();
        for(int i=0;i< values.length;i++){
            System.out.println(values[i]);
        }
        /*输出：
        SPRING
        SUMMER
        AUTUMN
        WINTER
        */
        //valueOf(String objName):返回枚举类中名为objName的对象
        //如果枚举类中没有名为objName的对象，则抛异常：IllegalArgumentException
        Season3 winter = Season3.valueOf("WINTER");
        System.out.println(winter);//WINTER
        //toString():返回枚举类对象的名称
        System.out.println(winter);//WINTER
    }
}

7.2 注解

public class Main {
/*
1.注解（Annotation）的理解
    1.1 jdk 5.0 新增的功能
    1.2 Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。
        通过使用 Annotation，程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息
    1.3 在JavaSE中，注解的使用目的比较简单。例如标记过时，忽略警告等。
        在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等
    1.4 框架 = 注解 + 反射机制 + 设计模式
2.注解的使用示例
    2.1 示例一：生成文档相关的注解(略)
    2.2 示例二：在编译时进行格式检查(JDK内置的几个基本注解)
        2.2.1 @Override: 限定重写父类方法, 该注解只能用于方法
        2.2.2 @Deprecated: 用于表示所修饰的结构(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
        2.2.3 @SuppressWarnings: 抑制编译器警告
 */
    @Test
    public void test1(){
        @SuppressWarnings("unused")
        int num=10;
    }
}
/*
3.如何自定义注解：参照@SuppressWarnings定义
    3.1 注解声明为：@interface
    3.2 内部可以定义成员：通常使用value表示
    3.3 可以指定成员的默认值：使用default指定
    3.4 如果自定义注解没有定义成员，表明该注解起标识作用,如:@Override
    3.5 说明：
        3.5.1 如果注解有成员，而且没有指定成员默认值，那么在使用注解时，需要指明成员的值
        3.5.2 自定义注解必须配合反射才有意义
        3.5.3 自定义注解通常都会指明两个元注解：Retention、Target
 */
@Retention(RetentionPolicy.CLASS)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@interface MyAnnotation1{
    String[] value();
}
@MyAnnotation1({"hello","jj"})
class Person{
}

@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@interface MyAnnotation2{
    String[] value() default "hello";
}
@MyAnnotation2
class Boy{
}
/*
4.元注解 ：对现有的注解进行解释说明的注解
    4.1 jdk 提供的4种元注解：
        4.1.1 Retention：指定所修饰的 Annotation 的生命周期：SOURCE\CLASS（默认行为)\RUNTIME
              只有生命周期声明为RUNTIME的注解，才能通过反射获取
        4.1.2 Target：用于指定所修饰的 Annotation 能用于修饰哪些程序结构
        4.1.3 Documented：所修饰的 Annotation 在被javadoc解析时会保留下来，如：Data的有参构造器
        4.1.4 Inherited：所修饰的 Annotation 将具继承性。如果某个类使用了被@Inherited修饰的 Annotation，则其子类将继承该注解
5.如何获取注解信息:通过反射来进行获取、调用
  前提：要求此注解的元注解Retention中声明的生命周期状态为：RUNTIME        
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@Inherited
@interface MyAnnotation3{
}
@MyAnnotation3
class Girl{
}
class GirlStudent extends Girl{
    @Test
    public void test() {
        Class<Person> personClass = Person.class;
        Annotation[] annotations1 = personClass.getAnnotations();
        for(int i=0;i<annotations1.length;i++){
            System.out.println(annotations1[i]);
        }
        /*
        无输出，因为MyAnnotation1的生命周期状态为：CLASS
         */
        System.out.println("*****");

        Class<Boy> boyClass = Boy.class;
        Annotation[] annotations2 = boyClass.getAnnotations();
        for(int i=0;i< annotations2.length;i++){
            System.out.println(annotations2[i]);
        }
        /*输出
        @jiple.MyAnnotation2({"hello"})
         */
        System.out.println("*****");

        Class<Girl> girlClass = Girl.class;
        Annotation[] annotations3 = girlClass.getAnnotations();
        for(int i=0;i< annotations3.length;i++){
            System.out.println(annotations3[i]);
        }
        /*输出
        @jiple.MyAnnotation3()
         */
        Class<GirlStudent> girlStudentClass = GirlStudent.class;
        Annotation[] annotations4 = girlStudentClass.getAnnotations();
        for(int i=0;i<annotations4.length;i++){
            System.out.println(annotations4[i]);
        }
        /*输出
        @jiple.MyAnnotation3()，因为父类的注解被@Inherited修饰
         */
    }
}
/*
6.JDK8中注解的新特性：可重复注解、类型注解
    6.1 可重复注解：
        6.1.1 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
        6.1.2 MyAnnotation的Target和Retention等元注解与MyAnnotations相同
 */
@Repeatable(MyAnnotation4s.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@interface MyAnnotation4{
    String[] value();
}
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@interface MyAnnotation4s{
    MyAnnotation4[] value();
}
//jdk8.0之前的写法
//@MyAnnotation4s({@MyAnnotation4({"simple","wu"}),@MyAnnotation4("hello")})
//jdk8.0之后的写法
@MyAnnotation4({"simple","wu"})
@MyAnnotation4("hello")
class Student{
}

/*
    6.2 类型注解
        6.2.1 ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）
        6.2.2 ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE,TYPE_PARAMETER,TYPE_USE})
@interface MyAnnotation5{
}
class Dog<@MyAnnotation5 T>{
    public void show() throws @MyAnnotation5 RuntimeException{
        ArrayList<@MyAnnotation5 String> list=new ArrayList<>();
        int num=(@MyAnnotation5 int)10L;
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值