枚举、注解、反射

1、枚举

1.1 定义格式

权限修饰符 enum 枚举名称 { 
	实例1,实例2，实例3，实例4; 
	}

public enum Level { 
	LOW(30), MEDIUM(15), HIGH(7), URGENT(1); 
	private int levelValue; 
	private Level(int levelValue) { 
		this.levelValue = levelValue; 
	}
	public int getLevelValue() { 
	return levelValue; 
	} 
}

1.2 Enum抽象类常见方法

1.3 实现接口的枚举类

public interface Show {
    void show();
}

public enum Level2 implements Show{
    LOW(1){
        @Override
        public void show() {
            System.out.println("低");
        }
    },
    MEDIUM(2){
        @Override
        public void show() {
            System.out.println("中");
        }
    },
    HIGH(3){
        @Override
        public void show() {
            System.out.println("高");
        }
    };

    private int levelValue;

    private Level2(int levelValue) {
        this.levelValue = levelValue;
    }

    public int getLevelValue() {
        return levelValue;
    }

    public void setLevelValue(int levelValue) {
        this.levelValue = levelValue;
    }


}

1.4 注意事项

• 一旦定义了枚举，最好不要妄图修改里面的值，除非修改是必要的。
• 枚举类默认继承的是java.lang.Enum类而不是Object类
• 枚举类不能有子类，因为其枚举类默认被final修饰
• 只能有private构造方法
• switch中使用枚举时，直接使用常量名，不用携带类名
• 不能定义name属性，因为自带name属性
• 不要为枚举类中的属性提供set方法，不符合枚举最初设计初衷。

2、注解

2.1 简介

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。
Java 语言中的类、方法、变量、参数和包等都可以被标注。和注释不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 它也支持自定义 Java 标注。

主要用于：

• 编译格式检查
• 反射中解析
• 生成帮助文档
• 跟踪代码依赖

2.2 内置注解

• @Override ： 重写
  定义在java.lang.Override
• @Deprecated：废弃
  定义在java.lang.Deprecated
• @SafeVarargs
  Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
• @FunctionalInterface： 函数式接口
  Java 8 开始支持，标识一个匿名函数或函数式接口。
• @Repeatable：标识某注解可以在同一个声明上使用多次
  Java 8 开始支持，标识某注解可以在同一个声明上使用多次。
• SuppressWarnings：抑制编译时的警告信息。
  定义在java.lang.SuppressWarnings
  三种使用方式

@SuppressWarnings(“unchecked”) [^ 抑制单类型的警告]
@SuppressWarnings(“unchecked”,“rawtypes”) [^ 抑制多类型的警告]
@SuppressWarnings(“all”) [^ 抑制所有类型的警告]

关键字	用途
all	抑制所有警告
boxing	抑制装箱、拆箱操作时候的警告
cast	抑制映射相关的警告
dep-ann	抑制启用注释的警告
deprecation	抑制过期方法警告
fallthrough	抑制确在switch中缺失breaks的警告
finally	抑制finally模块没有返回的警告
hiding	抑制相对于隐藏变量的局部变量的警告
incomplete-switch	忽略没有完整的switch语句
nls	忽略非nls格式的字符
null	忽略对null的操作
rawtypes	使用generics时忽略没有指定相应的类型
restriction	抑制禁止使用劝阻或禁止引用的警告
serial	忽略在serializable类中没有声明serialVersionUID变量
static-access	抑制不正确的静态访问方式警告
synthetic-access	抑制子类没有按最优方法访问内部类的警告
unchecked	抑制没有进行类型检查操作的警告
unqualified-field-access	抑制没有权限访问的域的警告
unused	抑制没被使用过的代码的警告

2.3 元注解

作用在其他注解上

• @Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
• @Documented - 标记这些注解是否包含在用户文档中 javadoc。
• @Target - 标记这个注解应该是哪种 Java 成员。
• @Inherited - 标记这个注解是自动继承的

1. 子类会继承父类使用的注解中被@Inherited修饰的注解
2. 接口继承关系中，子接口不会继承父接口中的任何注解，不管父接口中使用的注解有没有 被@Inherited修饰
3. 类实现接口时不会继承任何接口中定义的注解

2.4 自定义注解

定义格式

• @interface 自定义注解名{}
  注意事项
• 定义的注解，自动继承了java.lang,annotation.Annotation接口
• 注解中的每一个方法，实际是声明的注解配置参数
• 可以通过default来声明参数的默认值
• 如果只有一个参数成员，一般参数名为value
• 注解元素必须要有值，我们定义注解元素时，经常使用空字符串、0作为默认值。

案例

import java.lang.annotation.*;

@MyAnnotation
public class Demo02 {
    public static void main(String[] args) {
    }

    @MyAnnotation
    public static void show(){

    }
}

@Documented
@SuppressWarnings("all")
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
	参数类型 参数名() default 默认值;
}

2.5注解含义

1. @interface
   使用 @interface 定义注解时，意味着它实现了java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。

2. @Documented
   类和方法的 Annotation 在缺省情况下是不出现在 javadoc 中的。如果使用 @Documented 修饰该Annotation，则表示它可以出现在 javadoc 中。
   定义 Annotation 时，@Documented 可有可无；若没有定义，则 Annotation 不会出现在 javadoc中。

3. @Target(ElementType.TYPE)
   @Target 的作用，用来指定Annotation 的类型属性。
   @Target(ElementType.TYPE) 的意思就是指定该 Annotation 的类型是 ElementType.TYPE。这就意味着，MyAnnotation1 是来修饰"类、接口（包括注释类型）或枚举声明"的注解。
   定义 Annotation 时，@Target 可有可无。若有 @Target，则该 Annotation 只能用于它所指定的地方；若没有 @Target，则该 Annotation 可以用于任何地方。

4. @Retention(RetentionPolicy.RUNTIME)
   @Retention(RetentionPolicy.RUNTIME) 的意思就是指定该 Annotation 的策略是
   RetentionPolicy.RUNTIME。这就意味着，编译器会将该 Annotation 信息保留在 .class 文件中，并且能被虚拟机读取。
   定义 Annotation 时，@Retention 可有可无。若没有 @Retention，则默认是RetentionPolicy.CLASS

3、反射

JAVA反射机制是在运行状态中，获取任意一个类的结构 , 创建对象 , 得到方法，执行方法 , 属性 !； 这种在运行状态动态获取信息以及动态调用对象方法的功能被称为java语言的反射机制

3.1 得到Class的方式

		//1. 第一种方式，通过包名.类名.class 加载类
        Class<Person> c1 =com.java.Person.class;
        System.out.println(c1);
        //2. 第二种方式，通过类对象获取类信息
        Person person = new Person();
        Class<Person> c2 = (Class<Person>) person.getClass();
        System.out.println(c2);
        //3. 第三种方式
        Class<Person> c3 = (Class<Person>) Class.forName("com.java.Person");
        System.out.println(c3);

        System.out.println(c1==c2 && c1==c3 && c2==c3);

		/*
		class com.java.Person
		class com.java.Person
		class com.java.Person
		true
		*/

3.2 反射中的构造方法

public class Person {
    private String name;
    private int age;

    private Person(String name){
        this.name = name;
        this.age = 17;
    }

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

    public Person() {
    }

    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;
    }

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

		Class<Person> cp = (Class<Person>) Class.forName("com.java.Person");
        //找到无参构造方法
        Constructor<Person> c1 = cp.getConstructor();
        //使用无参构造，创建对象
        Person person = c1.newInstance();
        System.out.println(person);

        //找到包含String name 和 int age的构造方法
        Constructor<Person> c2 = cp.getConstructor(String.class, int.class);
        //使用这个构造方法，创建对象
        Person p = c2.newInstance("张三", 18);
        System.out.println(p);
		/*
		Person{name='null', age=0}
		Person{name='张三', age=18}
		*/

私有构造方法

		Constructor<Person> c3 = cp.getDeclaredConstructor(String.class);
        c3.setAccessible(true);
        Person p3 = c3.newInstance("张三");
        System.out.println(p3);

3.3 反射中的方法

//1.加载类
        Class<Person> cp = (Class<Person>) Class.forName("com.java.Person");
        //2.获取类构造方法
        Constructor<Person> constructor = cp.getConstructor();
        //3.创建对象
        Person person = constructor.newInstance();
        //4.获取类方法
        Method setName = cp.getMethod("setName", String.class);
        Method setAge = cp.getDeclaredMethod("setAge", int.class);
        setAge.setAccessible(true);
        setName.invoke(person,"zhangsan");
        setAge.invoke(person,18);
        System.out.println(person);

3.4 反射中的属性

1. get(Object o ); 
		参数: 
			要获取属性的对象 
			获取指定对象的此属性值 
2. set(Object o , Object value);
		参数1. 要设置属性值的 对象 
		参数2. 要设置的值 设置指定对象的属性的值
3. getName() 	
		获取属性的名称 
4. setAccessible(boolean flag) 
	如果flag为true 则表示忽略访问权限检查 !(可以访问任何权限的属性)

//1.加载类
        Class<Person> cp = (Class<Person>) Class.forName("com.java.Person");
        //2.获取类构造方法
        Constructor<Person> constructor = cp.getConstructor();
        //3.创建对象
        Person person = constructor.newInstance();
        Field name = cp.getDeclaredField("name");
        name.setAccessible(true);
        name.set(person,"zhangsan");
        System.out.println(person);