反射之中包含了一个“反”的概念，所以要想解释反射就必须先从“正”开始解释，一般而言，当用户使用一个类的时候，应该先知道这个类，而后通过这个类产生实例化对象，但是“反”指的是通过对象找到类

程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。

反射的核心是JVM在 运行时 才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁

Java反射机制的实现要借助于4个类：Class，Constructor，Field，Method

定义如下一个类：

public class RefModel {
    private Integer id;
    private String name;
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

测试：

/**
 * 使用了一个getClass()方法，而后就可以得到对象所在的“包.类”名称，这就属于“反”了
 * getClass()就作为发起一切反射操作的开端
 */
public class TestRefModel {
    public static void main(String[] args){
        RefModel ref = new RefModel();//正着来
        String className = ref.getClass().getName();//反着来
        System.out.println("className:"+className);//className:com.tutorial.annotation.RefModel
    }
}

RefModel的父类是Object类，getClass()方法就是Object类之中所定义的方法。
取得Class对象：public final Class<?> getClass()，反射之中的所有泛型都定义为?，返回值都是Object。 而这个getClass()方法返回的对象是Class类的对象，所以这个Class就是所有反射操作的源头。但是在讲解其真正使用之前还有一个需要先解释的问题，既然Class是所有反射操作的源头，那么这个类肯定是最为重要的，而如果要想取得这个类的实例化对象，Java中定义了三种方式：

1. 使用“类.class”取得

Class cls = RefModel.class;//取得Class对象

2. public static Class<?> forName(String className) throws ClassNotFoundException；

Class cla = Class.forName("com.tutorial.annotation.RefModel");//取得Class对象

3. 通过Object类的getClass()方法取得，基本不用

Class cla = ref.getClass();//取得Class对象

反射的应用：

• 实例化对象
  对于对象的实例化操作之前一直依靠构造方法和关键字new完成,现在可以利用反射完成

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        Class<?> cla = Class.forName("com.tutorial.annotation.RefModel");
        RefModel ref = (RefModel) cla.newInstance();//等价于new RefModel();
        System.out.println(ref);
    }

• 利用反射实现工厂模式

1.接口
public interface Fruit {
    public void eat();
}
2.实现类
public class Apple implements Fruit{
    @Override
    public void eat() {
        System.out.println("吃苹果");
    }
}
3.工厂类
public class FruitFactory {
    public static Fruit getInstance(String name){
        Fruit fruit = null;
        try {
            fruit =  (Fruit) Class.forName(name).newInstance();//反射实例化--此处是重点
        } catch (Exception e) {
            e.printStackTrace();
        } 
         return fruit;
    }
}
4.测试类
public class TestFactory {
    public static void main(String[] args) {
        Fruit fruit = FruitFactory.getInstance("com.tutorial.annotation.Apple");
        fruit.eat();//吃苹果
    }
}

• 调用构造方法
  在RefModel中添加2个构造方法

public RefModel() {
        super();
    }
    
    public RefModel(Integer id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

获取构造方法

Class cla = Class.forName("com.tutorial.annotation.RefModel");
        /**
         * 1.获取所有的构造方法
         * public com.tutorial.annotation.RefModel()
         * public com.tutorial.annotation.RefModel(java.lang.Integer,java.lang.String)
         */
        Constructor[] constructors = cla.getConstructors();
        for(Constructor constructor:constructors){
            System.out.println(constructor);
        }
        
        //实例化对象
        Object obj1 = cla.newInstance();
        System.out.println(obj1);
        
        /**
         * 2.获取指定的构造方法
         */
        Constructor<?> constructor = cla.getConstructor(Integer.class,String.class);
        Object obj2 = constructor.newInstance(1,"Jimmy");
        RefModel model = (RefModel)obj2;
        System.out.println(model.getName());//Jimmy

注意：如果实现了有参数的构造方法，却没有无参构造方法，Object obj1 = cla.newInstance()会报如下错误

Exception in thread "main" java.lang.InstantiationException: com.tutorial.annotation.RefModel
    at java.lang.Class.newInstance(Class.java:364)
    at com.tutorial.annotation.TestRefModel.main(TestRefModel.java:38)

• 调用普通方法-Method

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
        Class<?>  cla = Class.forName("com.tutorial.annotation.RefModel");//取得Class对象
        //1.返回所有公用（public）方法，包括其继承类的公用方法
        Method[] methodAlls = cla.getMethods();
        for(int x= 0; x< methodAlls.length; x++) {
            System.out.println(methodAlls[x]);
        }
        //返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法
        Method[] methodDecs = cla.getDeclaredMethods();
        for(Method method:methodDecs){
            System.out.println(method);
        }
        //2.获取指定的方法
        //------------方法的调用-------------
        Object obj = cla.newInstance();//实例化对象
        String attribute = "name";//要调用类之中的属性
        Method setMet = cla.getMethod("set"+initcap(attribute), String.class);
        Method getMet = cla.getMethod("get"+initcap(attribute));
        //调用
        setMet.invoke(obj, "Jimmy");//相当于RefModel对象.setName("Jimmy");
        System.out.println(getMet.invoke(obj));//相当于RefModel对象.getName("Jimmy");
    }
    public static String initcap(String str) {
        return str.substring(0,1).toUpperCase().concat(str.substring(1)) ;
    }

• 调用成员（属性）-Field

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
        Class<?>  cla = Class.forName("com.tutorial.annotation.RefModel");//取得Class对象
        //1.获取所有的属性
        Field[] fields = cla.getDeclaredFields();
        for(Field field:fields){
            System.out.println(field);
        }
        //2.获取指定的属性
        Object obj = cla.newInstance();//对象实例化之后才会为属性分配空间
        Field nameField = cla.getDeclaredField("name");//获取name属性 
        nameField.setAccessible(true);//
        nameField.set(obj, "Lucy");//RefModel对象.name="Lucy"
        System.out.println(nameField.get(obj));
        nameField.setAccessible(false);
    }

用setAccessible方法设置为true,若override的值为true，表示忽略权限规则，调用方法时无需检查权限（也就是说可以调用任意的private方法，违反了封装