【Java学习总结】注解与反射

一、注解（Annotation）

1.概述

注解（Annotation）是JDK5.0开始引用的新技术。
目前大部分框架都在使用注解来简化代码。
注解不同于注释，它不仅可以被人看到，同时也可以被程序所读取。
注解相当于给程序添加了额外的辅助信息。
注解可以使用在package ,class , method , field 等上面。

2.内置注解

是作用在代码的注解，定义在 java.lang 中。

@Override：表示方法是重写父类的方法。
@Deprecated：表示该方法已过时，不建议使用，但不是不能使用。
@SuppressWarnings：抑制警告，可以用来关闭编译器的警告，可以传递参数。

3.元注解

作用在其他注解的注解，定义在在 java.lang.annotation 中。

@Target ：表示我们的注解可以用在哪些地方。
(1).TYPE：该注解可以用于类、接口（包括注解类型）或enum声明。
(2).FIELD：该注解可以用于字段声明（包括enum实例）。
(3).METHOD：该注解可以用于方法声明。
(4).PARAMETER：该注解可以用于参数声明。
(5).CONSTRUCTOR：该注解可以用于构造器声明。
(6).LOCAL_VARIABLE：该注解可以用于局部变量声明。
(7).ANNOTATION_TYPE：该注解可以用于注解声明。
(8).PACKAGE：该注解可以用于包声明。
(9).TYPE_PARAMETER：该注解可以用于参数类型声明。1.8新加入。
(10).TYPE_USE：该注解可以用于类型声明。1.8新加入。
@Retention：表示注解在什么地方生效，用于描述注解的生命周期。源码级别（SOURCE）< 类文件级别（CLASS）< 运行时级别（RUNTIME）。

SOURCE：注解将被编译器丢弃。

CLASS：注解在class文件中可用，但会被JVM丢弃。

RUNTIME：注解信息将在运行期(JVM)也保留，因此可以通过反射机制读取注解的信息。

@Document：表示是否将我们的注解生成在Javadoc中。
@Inherited：子类可以继承父类的注解。

4.自定义注解

二、反射（Reflection）

1.什么是反射

反射是Java被称为“准动态语言”的关键技术。反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
正常方式是通过完整的“包类”名称通过new来实例化对象。反射方式可以通过实例化对象调用getClass()方法来获得完整的“包类”名称。

2.Class类

在Object类中定义了getClass()方法，该方法的返回值是Class类，这个类是Java反射的源头。针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

    //获取Class对象的方法
    public static void main(String[] args) throws ClassNotFoundException {
    
    

        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1);

        //方式二：forName获得
        Class c2 = Class.forName("包名+类名");
        System.out.println(c2);

        //方式三：通过类名.class获得
        Class c3 = Person.class;
        System.out.println(c3);
    }

3.类加载器

类的加载过程：
（1）加载（Load）：将class文件加载到内存中，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
（2）链接（Link）：将类的二进制数据合并到JVM中的过程。
（3）初始化（Initialize）：执行类构造器()方法的过程。由JVM负责对类进行初始化。
类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

	public static void main(String[] args) throws ClassNotFoundException {
    
    
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-->扩展加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父加载器-->根加载器(C/C++)
        ClassLoader parentParent = parent.getParent();
        System.out.println(parentParent);
	}

4.从Class对象获取信息

（1）访问 Class 对应的类所包含的属性

批量的属性：
public Field[] getFields()：获取所有public属性
public Field[] getDeclaredFields()：获取所有的属性
获取单个属性:
public Field getField(String name): 获取单个的public属性
public Field getDeclaredField(String name):获取任何属性

（2）访问 Class 对应的类所包含的方法

批量的方法：
public Method[] getMethods()：获取所有public构造器
public Method[] getDeclaredMethods()：获取所有的构造器
获取单个的方法:
public Method getMethod(String name, Class… parameterTypes): 获取单个的public方法
public Method getDeclaredMethod(String name, Class… parameterTypes):获取任何方法

（3）访问 Class 对应的类所包含的构造方法

批量的方法：
public Constructor[] getConstructors()：获取所有public构造器
public Constructor[] getDeclaredConstructors()：获取所有的构造器
获取单个的方法:
public Constructor getConstructor(Class… parameterTypes): 获取单个的public构造器
public Constructor getDeclaredConstructor(Class…parameterTypes):获取任何构造器

测试代码如下：

首先创建一个User实体类

class User{
    
    
    private int id;
    private int age;
    private String name;

    public User() {
    
    }

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

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public int getAge() {
    
    
        return age;
    }

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

    public String getName() {
    
    
        return name;
    }

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

通过Class对象获取该实体类的方法、属性以及构造器

   public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
    
    
        Class c1 = Class.forName("com.carry.reflection.User");

        //获得类的名字
        System.out.println(c1.getName());//包名+类名
        System.out.println(c1.getSuperclass());//类名

        //获得类的属性
        System.out.println("=======================");
        Field[] fields = c1.getFields();//只能找到public的属性
        fields = c1.getDeclaredFields();//找到全部属性
        for(Field field : fields){
    
    
            System.out.println(field);
        }

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类及其父类的所有方法
        for (Method method : methods) {
    
    
            System.out.println("正常的"+method);
        }
        methods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method method : methods) {
    
    
            System.out.println("getDeclaredMethods"+method);
        }

        //获得指定方法
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得类的构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
    
    
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
    
    
            System.out.println("Declared"+constructor);
        }

        //获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(int.class,int.class,String.class);
        System.out.println("指定"+declaredConstructor);
    }

5.Class动态创建对象

使用 Class 对象的 newInstance() 方法创建对象
使用 Constructor 对象创建对象