day10--java高级编程：枚举类，注解
3 枚举类+注解
3.1 枚举类概念
-
枚举类型本质上也是一种类，只不过是这个类的对象是有限的、固定的几个，不能让用户随意创建。
-
枚举类的例子举不胜举：
星期：Monday(星期一)…Sunday(星期天)性别：Man(男)、Woman(女)月份：January(1月)…December(12月)季节：Spring(春节)…Winter(冬天)三原色：red(红色)、green(绿色)、blue(蓝色)支付方式：Cash（现金）、WeChatPay（微信）、Alipay(支付宝)、BankCard(银行卡)、CreditCard(信用卡)就职状态：Busy(忙碌)、Free(空闲)、Vocation(休假)、Dimission(离职)订单状态：Nonpayment（未付款）、Paid（已付款）、Fulfilled（已配货）、Delivered（已发货）、Checked（已确认收货）、Return（退货）、Exchange（换货）、Cancel（取消）线程状态：创建、就绪、运行、阻塞、死亡
-
若枚举只有一个对象, 则可以作为一种单例模式的实现方式。
-
枚举类的实现：
- 在JDK5.0 之前，需要程序员自定义枚举类型。
- 在JDK5.0 之后，Java支持
enum关键字来快速定义枚举类型。
经验之谈：
- 开发中，当需要定义一组常量时，强烈建议使用枚举类。
- 开发中，如果针对于某个类，其实例是确定个数的。则推荐将此类声明为枚举类。
3.2 定义枚举类（JDK5.0 之前）
在JDK5.0 之前如何声明枚举类呢？
私有化类的构造器，保证不能在类的外部创建其对象- 在类的内部创建枚举类的实例。声明为：
public static final，对外暴露这些常量对象 - 对象如果有
实例变量，应该声明为private final（建议，不是必须），并在构造器中初始化
3.2.1 举例1：无参构造
枚举类：
package com.cn;
public class Light {
//创建红绿灯的3个实例:红 绿 黄
public static final Light RED= new Light();
public static final Light GREEN = new Light();
public static final Light YELLOW = new Light();
//提供私有的构造方法用来创建对象（默认提供的构造方法就是私有的，所以可以省略）
private Light(){
}
}
在main方法中调用枚举类对象：
package com.cn;
public class LightDemo {
public static void main(String[] args) {
Light r = Light.GREEN;//通过类名调用静态变量对象
System.out.println(r);//com.cn.Light@4eec7777
}
}
3.2.2 举例2：有参构造
枚举类：
package com.cn;
public class Light2 {
//4.创建当前类的实例(红绿灯)，需要使用public static final修饰
public static final Light2 RED = new Light2("红");
public static final Light2 GREEN = new Light2("绿");
public static final Light2 YELLOW = new Light2("黄");
//2. 声明当前类的对象的实例变量,使用private final修饰
//想要让外界只能获取不能修改，所以设置为final修饰的
private final String name;
//1. 私有化类的构造器,提供带参构造
private Light2(String name){
this.name=name;
}
//3. 提供实例变量的get方法，获取属性值
public String getName() {
return name;
}
@Override
public String toString() {
return "Light2{" +
"name='" + name + '\'' +
'}';
}
}
在main方法中调用枚举类对象：
package com.cn;
public class LightDemo2 {
public static void main(String[] args) {
Light2 r2 = Light2.GREEN;
//Light2.GREEN=null;对象是final修饰的，所以外界不能赋值
System.out.println(r2);//Light2{name='绿'}
System.out.println(r2.getName());//绿
}
}
3.2.3 举例3：含有抽象方法
枚举类：
package com.cn;
//2.含有抽象方法的类必须是抽象类
public abstract class Light3 {
//3.抽象类不能实例化，子类实现后必须重写所有的抽象方法（匿名子类）
public static final Light3 RED = new Light3("红") {
@Override
public void show() {
System.out.println("红");
}
};
public static final Light3 GREEN = new Light3("绿"){
@Override
public void show() {
System.out.println("绿");
}
};
public static final Light3 YELLOW = new Light3("黄"){
@Override
public void show() {
System.out.println("黄");
}
};
private final String name;
private Light3(String name){
this.name=name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Light3{" +
"name='" + name + '\'' +
'}';
}
//1.提供抽象方法
public abstract void show();
}
在main方法中调用枚举类对象：
package com.cn;
public class LightDemo3 {
public static void main(String[] args) {
Light3 r3 = Light3.GREEN;
System.out.println(r3);//Light2{name='绿'}
System.out.println(r3.getName());//绿
r3.show();//绿
}
}
3.3 定义枚举类（JDK5.0 之后）
发现自己定义一个枚举类，比较麻烦，所以，java就提供了枚举类供我们使用
格式：只有枚举项的枚举类
【修饰符】 enum 枚举类名{
枚举项1,枚举项2,枚举项3...;
}
注意事项：
- 枚举类的常量对象列表
必须在枚举类的首行，因为是常量，所以建议大写。 - 列出的实例系统会自动添加 public static final 修饰。
- 如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。
- 编译器给枚举类
默认提供的是private的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数 - 如果枚举类需要的是
有参构造，需要手动定义，有参构造的private可以省略，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。 - 枚举类默认继承的是java.lang.Enum类，因此不能再继承其他的类型。
- 枚举类也可以有
抽象方法，但是枚举项必须重写该方法 - JDK5.0 之后switch，提供支持枚举类型，case后面可以写枚举常量名，无需添加枚举类作为限定。
3.3.1 举例1：无参构造&在switch中的用法
枚举类：
package com.cc;
//自定义的枚举类默认的父类就是Enum，因此不能再继承其他的类型，哪怕是Object
//如：public enum Light2 extends Object{ } 会报错
public enum Light {
//枚举项：创建light类的对象（枚举类的第一行必须是枚举项）
//调用的是无参构造（默认就是private修饰的）
RED,GREEN,YELLOW;
/* 查看底层源码，发现底层做了以下事情：
public final class Light extends Enum {
//创建了3个对象
public static final Light RED = new Light("RED"",0);
public static final Light GREEN = new Light("GREEN",1);
public static final Light YELLOw = new Light("YELLOW",2);
//提供了有参构造
private Light(String s, int i) {
super(s,i); //调用父类的有参构造
}
}
public abstract class Enum ... {
private final String name ;
protected Enum (String name,int ordinal) {
//会把对象的值RED赋值给name
this.name = name ;
this.ordinal = ordinal;
}
public String toString() {
//最终通过toString()方法返回name
return name;
}
}
*/
}
在main方法中调用枚举类对象：
package com.cc;
import static com.cc.Light.*;
public class LightDemo {
public static void main(String[] args) {
Light r = Light.RED;
//打印的不是地址值，说明底层源码重写了toString()
System.out.println(r);//RED
Light ll = Light.GREEN;
//测试枚举在switch中的用法
//因为里面放的是枚举项，所以case后的值必须是在枚举中出现过的,否则会报错。
switch (ll){
case RED:
System.out.println("红");
break;
case GREEN:
System.out.println("绿");//绿
break;
case YELLOW:
System.out.println("黄");
break;
}
}
}
3.3.2 举例2：有参构造
枚举类：
package com.cc;
//自定义的枚举类默认的父类就是Enum，因此不能再继承其他的类型，哪怕是Object
//如：public enum Light2 extends Object{ } 会报错
public enum Light2 {
//1. 必须在枚举类的开头声明多个对象。对象之间使用,隔开
//调用有参构造
RED("红"),GREEN("绿"),YELLOW("黄");
/* jdk5之前的形式，在jdk5之后必须要简写为以上方式,并且位于枚举类的首行
public static final Light2 RED = new Light2("红");
public static final Light2 SUMMER = GREEN Light2("绿");
public static final Light2 AUTUMN = new YELLOW("黄");
*/
//2. 声明当前类的对象的实例变量,使用private final修饰
//想要让外界只能获取不能修改，所以设置为final修饰的
private String name;
//3. 私有化类的构造器，private可以省略
private Light2(String name){
this.name = name;
}
//4. 提供实例变量的get方法，获取属性值
public String getName() {
return name;
}
@Override
public String toString() {
return "Light2{" +
"name='" + name + '\'' +
'}';
}
}
在main方法中调用枚举类对象：
package com.cc;
public class LightDemo2 {
public static void main(String[] args) {
Light2 r2 = Light2.RED;
//打印的值不再是源码中toString返回的 RED，
// 而是自己重写后的toString方法的返回值 红
System.out.println(r2);//Light2{name='红'}
System.out.println(r2.getName());//红
}
}
3.3.3 举例3：含有抽象方法
枚举类：
package com.cc;
//含有抽象方法的枚举类不需要添加abstract
public enum Light3 {
//枚举项：创建light类的对象
//调用有参构造
RED("红"){
@Override
public void show() {
System.out.println("红");
}
},
GREEN("绿"){
@Override
public void show() {
System.out.println("绿");
}
},
YELLOW("黄"){
@Override
public void show() {
System.out.println("黄");
}
};
private String name;
private Light3(String name){
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Light3{" +
"name='" + name + '\'' +
'}';
}
//提供抽象类
public abstract void show();
}
在main方法中调用枚举类对象：
package com.cc;
public class LightDemo3 {
public static void main(String[] args) {
Light3 r3 = Light3.RED;
//打印的值不再是源码中toString返回的 RED，
// 而是自己重写后的toString方法的返回值 红
System.out.println(r3);//Light3{name='红'}
System.out.println(r3.getName());//红
r3.show();//红
}
}
3.4 enum中的常用方法
String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
static 枚举类型[] values():返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值，是一个静态方法
static 枚举类型 valueOf(String name)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
String name():得到当前枚举常量的名称。建议优先使用toString()。
int ordinal():返回当前枚举常量的次序号，默认从0开始
测试：
枚举类：
package com.cc;
public enum Light2 {
//创建枚举类对象
RED("红"),GREEN("绿"),YELLOW("黄");
private String name;
private Light2(String name){
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Light2{" +
"name='" + name + '\'' +
'}';
}
}
在main方法中调用枚举类对象：
package com.cc;
public class LightDemo2 {
public static void main(String[] args) {
Light2 r2 = Light2.RED;
//测试方法
//1.toString()
//没重写输出的是 对象名： RED
//重写后输出的是 重写后的返回值： Light2{name='红'}
System.out.println(r2);
//2.name()
//得到当前枚举常量的名称: RED 跟重不重写oString没关系
System.out.println(r2.name());
//3.values()
//静态方法，返回枚举类型的对象数组
Light2[] l = Light2.values();
for (int i=0;i<l.length;i++){
/* Light2{name='红'}
Light2{name='绿'}
Light2{name='黄'}*/
System.out.println(l[i]);
}
//4.valueOf(String name)
//返回当前枚举类中名称为objName的枚举类对象。
//如果枚举类中不存在objName名称的对象，则报错。
String objName = "YELLOW";
Light2 ll = Light2.valueOf(objName);
System.out.println(ll);//Light2{name='黄'}
//5.ordinal()
//当前对象在枚举类中第几个声明的对象，默认从0开始
System.out.println(r2.ordinal());//0
}
}
3.5 枚举类实现接口
- 和普通 Java 类一样，枚举类可以实现一个或多个接口
- 若每个枚举值在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。
- 若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法
3.5.1 情况1：执行的是同一个方法
情况1：枚举类实现接口，在枚举类中重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是同一个方法。
枚举类：
package com.cc;
//1定义接口
interface Info{
void show();
}
//2枚举类实现接口
public enum Light2 implements Info{
//创建枚举类对象
RED("红"),GREEN("绿"),YELLOW("黄");
private String name;
private Light2(String name){
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Light2{" +
"name='" + name + '\'' +
'}';
}
//3重写的抽象方法
@Override
public void show() {
System.out.println("重写的抽象方法");
}
}
在main方法中调用枚举类对象：
package com.cc;
public class LightDemo2 {
public static void main(String[] args) {
Light2[] l = Light2.values();
for (int i=0;i<l.length;i++){
/* 重写的抽象方法
重写的抽象方法
重写的抽象方法*/
l[i].show();
}
}
}
3.5.2 情况2：执行的不是同一个方法
情况二：让枚举类的对象分别实现接口中的抽象方法，每个对象调这个方法时输出的内容不一样。
枚举类：
package com.cc;
//1定义接口
interface Info{
void show();
}
//2枚举类实现接口
public enum Light2 implements Info{
//3.创建枚举类对象
//不在枚举类中直接重写抽象方法了，而是使用匿名子类的方式分别重写抽象方法
RED("红"){
@Override
public void show() {
System.out.println(111);
}
},GREEN("绿"){
@Override
public void show() {
System.out.println(222);
}
},YELLOW("黄"){
@Override
public void show() {
System.out.println(333);
}
};
private String name;
private Light2(String name){
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Light2{" +
"name='" + name + '\'' +
'}';
}
}
在main方法中调用枚举类对象：
package com.cc;
public class LightDemo2 {
public static void main(String[] args) {
Light2[] l = Light2.values();
for (int i=0;i<l.length;i++){
/*111
222
333*/
l[i].show();
}
}
}
3.6 注解
总结：为了优化以前的开发模式，提出注解开发。减少了代码量，提高了注解的复用。标志是@ Annotation
3.7 注解的使用示例
3.7.1 生成文档相关的注解
3.7.2 JDK内置的注解
package com.atguigu.java1;
import java.util.ArrayList;
import java.util.Date;
/**
* 注解的使用
*
* 1. 理解Annotation:
* ① jdk 5.0 新增的功能
*
* ② Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,
* 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。
*
* ③在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android
* 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗
* 代码和XML配置等。
*
* 2. Annocation的使用示例
* 示例一：生成文档相关的注解
* 示例二：在编译时进行格式检查(JDK内置的三个基本注解)
* @Override: 限定重写父类方法, 该注解只能用于方法
* @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
* @SuppressWarnings: 抑制编译器警告
* @SafeVarargs jdk1.7出现，堆污染，不常用
* @FunctionallInterface jdk1.8出现，配合函数式编程拉姆达表达式，不常用
*
* 示例三：跟踪代码依赖性，实现替代配置文件功能
* @author shkstart
* @create 2019 上午 11:37
*/
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
Date date = new Date(2020, 10, 11);//已过时，但仍然能用，源码中用@Deprecated注解修饰了
System.out.println(date);
@SuppressWarnings("unused")//加上注解警告会消失，unused属性：没有用。 里面的值可以看成是成员变量
int num = 10;//定义了一个变量没有用，在eclipse中会有一个警告：定义了变量没有用。在idea中变量名变为灰色。
@SuppressWarnings({ "unused", "rawtypes" }) //变量没有用，没有添加泛型
ArrayList list = new ArrayList();
}
}
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("人走路");
}
public void eat(){
System.out.println("人吃饭");
}
}
interface Info{
void show();
}
class Student extends Person implements Info{
@Override//不加上注解不一定不是重写，加上注解会在编译期检查是否为重写父类的方法 如果不是则报错。
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
3.7.3 跟踪代码依赖性，实现替代配置文件功能
3.8 元注解
3.8.1 概念
3.8.2 测试
自定义注解中加上元注解：
package com.atguigu.java1;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
/**
* 1.如何自定义注解：参照@SuppressWarnings定义
* ① 注解声明为：@interface
* ② 内部定义成员，通常使用value表示
* ③ 可以指定成员的默认值，使用default定义
* ④ 如果自定义注解没有成员，表明是一个标识作用。public @interface MyAnnotation {},使用时也不需要写属性值
*
* 注意：
* 如果注解有成员，在使用注解时，需要指明成员的值。
* 自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
* 自定义注解通过都会指明两个元注解：Retention、Target
*
* 2.jdk 提供的4种元注解
* 元注解：对现有的注解进行解释说明的注解
* Retention：指定所修饰的 Annotation 的生命周期：SOURCE(在源文件中有效)\CLASS（默认行为, 在class文件中有效）\RUNTIME(在运行时有效)
* 只有声明为RUNTIME生命周期的注解，才能通过反射获取。
* Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素:如果不指定则代表那都可以用。
* ElementType.ANNOTATION_TYPE 应用于注释类型
* ElementType.CONSTRUCTOR 应用于构造函数
* ElementType.FIELD 应用于字段或属性
* ElementType.LOCAL_VARIABLE 应用于局部变量
* ElementType.METHOD 应用于方法级
* ElementType.PACKAGE 应用于包声明
* ElementType.PARAMETER 应用于方法的参数
* ElementType.TYPE 应用于类的元素
* *******出现的频率较低*******
* Documented:表示所修饰的注解在被javadoc解析时，保留下来。默认情况下，javadoc是不包括注解的。定义为Documented的注解必须设置Retention值为RUNTIME。
*
* Inherited:被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited 修饰的 Annotation, 则其子类将自动具有该注解。
* 如何证明子类继承了注解--->通过反射获取注解信息 ---到反射内容时系统讲解
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
@Inherited
public @interface MyAnnotation {
//如果只有一个参数成员，建议使用参数名为value。注意这是一个属性不是方法，虽然有()。
//String value() ;//形式一：可以是任意类型的，如果value值可以指定多个可以定义为数组如：String[] value() ;
String value() default "hello";//形式二：通过default关键字指定一个默认值
}
使用注解：
package com.atguigu.java1;
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
}
}
//@MyAnnotation(value="hello")//形式一：使用注解，因为自定义注解@MyAnnotation有变量value,所以这里需要指定一个值 否则会报错。暂时随便指定个值，没有特殊含义.只有一个值可以简写为：@MyAnnotation("hello")
@MyAnnotation()//形式二：因为使用的value属性有默认值，此时不用指定，也不会报错。不想要默认值，可以进行修改如：@MyAnnotation(value="hi")
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("人走路");
}
public void eat(){
System.out.println("人吃饭");
}
}
interface Info{
void show();
}
//student继承了person类，person添加了自定义注解@MyAnnotation()，又因为自定义注解设置了元注解@Inherited具有可继承性，所以
//student也有@MyAnnotation()注解。如何证明student继承了注解？？---->通过反射
class Student extends Person implements Info{
@Override
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
3.9 自定义注解
3.9.1 概述
3.9.2 测试
定义注解：
package com.atguigu.java1;
/**
* 如何自定义注解：参照@SuppressWarnings定义
* ① 注解声明为：@interface
* ② 内部定义成员，通常使用value表示
* ③ 可以指定成员的默认值，使用default定义
* ④ 如果自定义注解没有成员，表明是一个标识作用。public @interface MyAnnotation {},使用时也不需要写属性值
*
* 注意：
*1. 如果注解有成员，在使用注解时，需要指明成员的值。
*2. 自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
*3. 自定义注解通过都会指明两个元注解：Retention、Target---详情查看3.6元注解
*
*/
public @interface MyAnnotation {
//如果只有一个参数成员，建议使用参数名为value。注意这是一个属性不是方法，虽然有()。
//String value() ;//形式一：可以是任意类型的，如果value值可以指定多个可以定义为数组如：String[] value() ;
String value() default "hello";//形式二：通过default关键字指定一个默认值
}
使用注解：
package com.atguigu.java1;
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
}
}
//@MyAnnotation(value="hello")//形式一：使用注解，因为自定义注解@MyAnnotation有变量value,所以这里需要指定一个值 否则会报错。暂时随便指定个值，没有特殊含义。只有一个值可以简写为：@MyAnnotation("hello")
@MyAnnotation()//形式二：因为使用的value属性有默认值，此时不用指定，也不会报错。不想要默认值，可以进行修改如：@MyAnnotation(value="hi")
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("人走路");
}
public void eat(){
System.out.println("人吃饭");
}
}
interface Info{
void show();
}
class Student extends Person implements Info{
@Override
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
3.10 jdk1.8注解新特性
3.10.1 可重复注解 和 类型注解
类AnnotationTest：
package com.atguigu.java1;
import java.util.ArrayList;
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
}
}
//@MyAnnotation(value="hello")//形式一：使用注解，因为自定义注解@MyAnnotation有变量value,所以这里需要指定一个值 否则会报错。暂时随便指定个值，没有特殊含义.只有一个值可以简写为：@MyAnnotation("hello")
//@MyAnnotation()//形式二：因为使用的value属性有默认值，此时不用指定，也不会报错。不想要默认值，可以进行修改如：@MyAnnotation(value="hi")
//jdk 8之前的写法想要使用重复的注解：想要写多个注解,在自定义注解MyAnnotations中声明为MyAnnotation类型的数组：MyAnnotation[] value();
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
//jdk 8开始想要这样使用重复的注解：
@MyAnnotation(value="hi")
@MyAnnotation(value="abc")
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("人走路");
}
public void eat(){
System.out.println("人吃饭");
}
}
interface Info{
void show();
}
//student继承了person类，person添加了自定义注解@MyAnnotation()，又因为自定义注解设置了元注解@Inherited具有可继承性，所以
//student也有@MyAnnotation()注解。如何证明student继承了注解？？---->通过反射
class Student extends Person implements Info{
@Override
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
//类型注解的使用：
class Generic<@MyAnnotation T>{
public void show() throws @MyAnnotation RuntimeException{
ArrayList<@MyAnnotation String> list = new ArrayList<>();
int num = (@MyAnnotation int) 10L;
}
}
注解MyAnnotation：
package com.atguigu.java1;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
/**
* 1.如何自定义注解：参照@SuppressWarnings定义
* ① 注解声明为：@interface
* ② 内部定义成员，通常使用value表示
* ③ 可以指定成员的默认值，使用default定义
* ④ 如果自定义注解没有成员，表明是一个标识作用。public @interface MyAnnotation {},使用时也不需要写属性值
*
* 注意：
* 如果注解有成员，在使用注解时，需要指明成员的值。
* 自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
* 自定义注解通过都会指明两个元注解：Retention、Target
*
* 2.jdk 提供的4种元注解
* 元注解：对现有的注解进行解释说明的注解
* Retention：指定所修饰的 Annotation 的生命周期：SOURCE(在源文件中有效)\CLASS（默认行为, 在class文件中有效）\RUNTIME(在运行时有效)
* 只有声明为RUNTIME生命周期的注解，才能通过反射获取。
* Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素:如果不指定则代表那都可以用。
* ElementType.ANNOTATION_TYPE 应用于注释类型
* ElementType.CONSTRUCTOR 应用于构造函数
* ElementType.FIELD 应用于字段或属性
* ElementType.LOCAL_VARIABLE 应用于局部变量
* ElementType.METHOD 应用于方法级
* ElementType.PACKAGE 应用于包声明
* ElementType.PARAMETER 应用于方法的参数
* ElementType.TYPE 应用于类的元素
* *******出现的频率较低*******
* Documented:表示所修饰的注解在被javadoc解析时，保留下来。默认情况下，javadoc是不包括注解的。定义为Documented的注解必须设置Retention值为RUNTIME。
*
* Inherited:被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited 修饰的 Annotation, 则其子类将自动具有该注解。
* 如何证明子类继承了注解--->通过反射获取注解信息 ---到反射内容时系统讲解
* 3.可重复注解：① 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
* ② MyAnnotation的Target和Retention等元注解(如：@Inherited)与MyAnnotations相同。
* 4. 类型注解写在@Target注解中：
* ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
* ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
@Inherited
@Repeatable(MyAnnotations.class)//jdk 8开始想要这样使用重复的注解
public @interface MyAnnotation {
//如果只有一个参数成员，建议使用参数名为value。注意这是一个属性不是方法，虽然有()。
//String value() ;//形式一：可以是任意类型的，如果value值可以指定多个可以定义为数组如：String[] value() ;
String value() default "hello";//形式二：通过default关键字指定一个默认值
}
注解MyAnnotations：
package com.atguigu.java1;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Inherited
public @interface MyAnnotations {
MyAnnotation[] value();// jdk 8之前的写法：想要写多个注解声明为数组
}