概念

反射：是java被视为动态语言的关键，反射机制允许程序在执行期间借助反射接口取得任何类的内部信息，并能直接操作任意对象的内部属性和方法。

加载完类之后，在堆内存的方法区中产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一个镜子，透过这个镜子看到类的结构，所以称为“反射”。

优点

可以实现动态创建对象和编译，体现出很大的灵活性。

动态的体现：可以根据不同的名字创建不同的对象，是灵活的。

缺点

对性能有影响，使用反射基本上是一种解释操作，告诉jvm我们希望做什么并且它能满足我们的要求，这类操作总是慢于执行相同的操作。

类初始化

引起类初始化（类加载包括初始化）的几种现象：

1、虚拟机启动，先初始化main方法所在的类，只要执行main方法，其所在的类都会被初始化。

2、new一个对象的时候

3、调用类的静态变量和静态方法的时候（除了用final修饰，final会将变量放在常量池里面）

4、反射操作

5、当初始化一个类，如果父类没有被初始化，则会先初始化它的父类

不会引起初始化的现象：

1、子类调用父类的静态变量，子类不会被初始化

2、从常量池里面拿东西（使用final修饰的字段），也不会被初始化

package com.tfjybj.ming;

/**
 * @author Liu Yiming
 * CreateDate 2021/5/9 11:14
 * UpdateUser
 * UpdateDate
 * UpdateRemark
 * @version 1.0
 * Description 验证什么时候类会被加载
 */
public class Test04 {
    static {
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //主动引用类，类肯定是会被加载(打印出父类和子类)
        Son son = new Son();
        //反射也会引起类的加载;反射会消耗资源，速度变慢（打印出父类和子类）
        Class<?> aClass = Class.forName("com.tfjybj.ming.Son");
        //子类调用父类的静态变量，子类不会被初始化，父类会初始化
        System.out.println(Son.b);
        //子类和父类都不会被初始化，都不会被打印
        System.out.println(Son.c);
        //会打印父类和子类
        System.out.println(Son.a);
    }
}

class Father {
    static int b = 2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {
    static {
        System.out.println("子类被加载");
    }
    static int a =3;
    static final int c =3;

}

创建对象

1、直接new出对象

2、使用反射来创建对象

3、通过构造器来创建对象、通过反射来操作方法、通过反射来操作属性。

```java
package com.tfjybj.ming;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author Liu Yiming
 * CreateDate 2021/5/9 14:30
 * UpdateUser
 * UpdateDate
 * UpdateRemark
 * @version 1.0
 * Description 通过反射，动态的创建对象
 */
public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        创建Class类型的对象
        Class<?> aClass = Class.forName("com.tfjybj.ming.User");
        //创建类的对象,本质上调用的是无参的构造器
        User user = (User) aClass.newInstance();

        //通过构造器来创建对象
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class);
        User user1 = (User) declaredConstructor.newInstance("张三", 10);

        //通过反射来获取一个方法
        Method setName = aClass.getDeclaredMethod("setName", String.class);
        //激活这个方法
        //(对象，“方法的参数”)
        setName.invoke(user1, "李四");
        System.out.println(user1.getName());

        //通过反射来操作属性;但是属性是private，是无法访问的，需要关掉访问权限
        Field name = aClass.getDeclaredField("name");
        //不能直接操作private属性，需要关闭程序的安全监测
        name.setAccessible(true);
        name.set(user1, "haha");
        System.out.println(name.getName());
    }
}

自定义注解的使用

public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class aClass = Class.forName("com.tfjybj.ming.Student");
        //通过反射来获取注解
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获取注解value的值
        Table annotation = (Table)aClass.getAnnotation(Table.class);
        String value = annotation.value();
        System.out.println(value);

        //获得类指定的注解（name是字段的名字）
        java.lang.reflect.Field name = aClass.getDeclaredField("name");
        Field annotation1 = name.getAnnotation(Field.class);
        System.out.println(annotation1.columName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());

    }

}

@Table
class Student {
    @Field(columName = "tb_id", type = "int", length = "32")
    private int id;
    @Field(columName = "tb_id", type = "varchar", length = "32")
    private String name;

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

    public Student() {
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
    String value() default "123";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field {
    String columName();

    String type();

    String length();
}