反射

package reflect;


public class Car {  
    public String brand;  
    private String color;  
    private int maxSpeed;  
      
     //①默认构造函数  
    public Car(){}  
       
     //②带参构造函数  
    public Car(String brand,String color,int maxSpeed){   
        this.brand = brand;  
        this.color = color;  
        this.maxSpeed = maxSpeed;  
    }  
  
     //③未带参的方法  
    public void introduce() {   
       System.out.println("brand:"+brand+";color:"+color+";maxSpeed:" +maxSpeed);  
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }  
    
}  

package reflect;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReflectTest {
    
    /** 
     *验证所有的类都是Class类的实例对象 
     * @throws ClassNotFoundException  
     */  
    public static void verifyIns() throws ClassNotFoundException{  
        System.out.println("-----验证所有的类都是Class类的实例对象 -----");
        //定义两个类型都未知的Class , 设置初值为null, 看看如何给它们赋值成Person类  
        Class<?> class1 = null;  
        Class<?> class2 = null;  
          
        //写法1, 可能抛出 ClassNotFoundException [多用这个写法]  
        class1 = Class.forName("reflect.Car");  
        System.out.println("(写法1) 包名: " + class1.getPackage().getName() + "，"   
                + "完整类名: " + class1.getName());  
          
        //写法2  
//        class2 = Car.class;  
//        System.out.println("(写法2) 包名: " + class2.getPackage().getName() + "，"   
//                + "完整类名: " + class2.getName());  
    } 

    /**
     * 通过获取类的默认构造器创建实例
     * @throws Throwable
     */
    public static void initByDefaultConst() throws Throwable {
        System.out.println("-----通过获取类的默认构造器创建实例-----");
        //写法1
        //通过类加载器获取car对象
        ClassLoader loader = Thread.currentThread().getContextClassLoader();//获取当前线程的ClassLoader
        Class clazz = loader.loadClass("reflect.Car");//通过指定的全限定类“reflect.Car”装载Car类对应的反射实例
        
        //获取类的默认构造器对象并通过它实例化car
        Constructor  cons = clazz.getDeclaredConstructor((Class[]) null);//通过Car的反射类对象获取Car的构造函数对象cons
        Car car = (Car) cons.newInstance();//通过构造函数对象的newInstrance()方法实例化Car对象，其效果等同于new Car()
        System.out.println("包名："+car.getClass().getPackage().getName()+",完整类名："+car.getClass().getName());
        //通过反射方法设置属性
        Method  setBrand = clazz.getMethod("setBrand", String.class);//通过Car的反射类对象的getMethod（String methodName,Class paramClass）获取属性的Setter方法对象，第一个参数是目标Class的方法名；第二个参数是方法入参的对象类型
        setBrand.invoke(car, "红旗");//获取方法反射对象后，即可通过invoke（Object obj,Object param）方法调用目标类的方法，该方法的第一个参数是操作的目标类对象实例；第二个参数是目标方法的入参。
        Method  setColor = clazz.getMethod("setColor", String.class);
        setColor.invoke(car, "红色");
        Method setMaxSpeed = clazz.getMethod("setMaxSpeed", int.class);
        setMaxSpeed.invoke(car, 200);
        Method introduce = clazz.getMethod("introduce",null);
        introduce.invoke(car, null);
        
        //写法2
//        Class clazz = Class.forName("reflect.Car");
//        Car car = (Car)clazz.newInstance();
//        System.out.println("包名："+car.getClass().getPackage().getName()+",完整类名："+car.getClass().getName());
    }
    /**
     * 通过获取类的指定构造器创建实例
     * @throws Throwable 
     */
    public static void  initBySpecifiedConst() throws Throwable {
        System.out.println("-----通过获取类的指定构造器创建实例-----");
        ClassLoader loader = Thread.currentThread().getContextClassLoader();//获取当前线程的ClassLoader
        Class clazz = loader.loadClass("reflect.Car");//通过指定的全限定类“reflect.Car”装载Car类对应的反射实例
        Constructor c = clazz.getConstructor(String.class,String.class,int.class);
        Car car = (Car) c.newInstance("Benz","黑色",100);
        Method introduce = clazz.getMethod("introduce",null);
        introduce.invoke(car, null);
    }
 
    /**
     *获取构造器列表并用其中一个创建实例
     * @throws Throwable 
     * @throws Exception 
     */
    public static void getAllConstsAndNewInstance() throws Throwable  {
        System.out.println("-----获取构造器列表并用其中一个创建实例-----");
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        Class clazz = loader.loadClass("reflect.Car");
        Constructor[] constructors = clazz.getConstructors();
        Car car0 = (Car)constructors[0].newInstance();
        System.out.println("包名："+car0.getClass().getPackage().getName()+",完整类名："+car0.getClass().getName());
        Object obj = (Car)constructors[1].newInstance("Benz","黑色",100);
        System.out.println("包名："+obj.getClass().getPackage().getName()+",完整类名："+obj.getClass().getName());
    }
    
    /**
     * 获取并操作成员变量
     * @throws Throwable
     */
    public static void getAndProcessField() throws Throwable{
        System.out.println("-----获取并操作成员变量-----");
        Class clazz = Class.forName("reflect.Car");
        Object obj = clazz.newInstance();
//        Field[] fields = clazz.getFields();//getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段
        Field[] fields = clazz.getDeclaredFields();//getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
        for(Object o :fields){
            System.out.println(o);
        }
//         AccessibleObject.setAccessible(fields, true); //对所有属性设置访问权限  当类中的成员变量为private时 必须设置此项
         Field fieldBrand = clazz.getField("brand");
         fieldBrand.setAccessible(true);
         fieldBrand.set(obj, "BWM");//对当前属性设置访问权限  当类中的成员变量为private时 必须设置此项
         System.out.println("修改属性之后得到属性变量的值：" + fieldBrand.get(obj));
         Field fieldColor = clazz.getDeclaredField("color");
         fieldColor.setAccessible(true);
         fieldColor.set(obj, "white");//对当前属性设置访问权限  当类中的成员变量为private时 必须设置此项
         System.out.println("修改属性之后得到属性变量的值：" + fieldColor.get(obj));
    }
    /**
     * 获取并操作成员方法
     * @throws Throwable
     */
    public static void getAndProcessMethods() throws Throwable{
        System.out.println("-----获取并操作成员方法-----");
        ClassLoader  loader = Thread.currentThread().getContextClassLoader();
        Class clazz = loader.loadClass("reflect.Car");
//        Method[] methods = clazz.getMethods(); //getMethods()返回某个类的所有公用（public）方法包括其继承类的公用方法，当然也包括它所实现接口的方法。
        Method[] methods = clazz.getDeclaredMethods();//getDeclaredMethods()对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。当然也包括它所实现接口的方法。
        for(Method m :methods){
            System.out.println("方法:"+m);
            System.out.println("方法名："+m.getName());
            System.out.println("方法返回类型："+m.getReturnType());
            System.out.println("函数访问修饰符：" + Modifier.toString(m.getModifiers()));  
        }
        Method methodIntroduce = clazz.getMethod("introduce",null);
        methodIntroduce.invoke(clazz.newInstance(), null);
        
        //取得类实现的接口,因为接口类也属于Class 
         Class interfaces[] = clazz.getInterfaces();  
            for (int i = 0; i < interfaces.length; i++) {  
                System.out.println("实现的接口类名: " + interfaces[i].getName() );  
            }  
    }
    
    /**得到类加载器信息
     * @throws Throwable
     */
    public static void getClassLoader() throws Throwable{
        System.out.println("-----得到类加载器信息-----");
        Class clazz = Class.forName("reflect.Car");
        String classLoaderName = clazz.getClassLoader().getClass().getName();
        System.out.println("classLoaderName:"+classLoaderName);
    }
    
    
    public static void main(String args[]) throws Throwable{
         verifyIns();
         initByDefaultConst();
         initBySpecifiedConst();
         getAllConstsAndNewInstance();
         getAndProcessField();
         getAndProcessMethods();
         getClassLoader();
    }
    
}

常用反射的一些地方

https://www.cnblogs.com/ldh-better/p/7148975.html#_label2_1

1.工厂模式：Factory类中用反射的话，添加了一个新的类之后，就不需要再修改工厂类Factory了
2.数据库JDBC中通过Class.forName(Driver).来获得数据库连接驱动
3.分析类文件：毕竟能得到类中的方法等等
4.访问一些不能访问的变量或属性：破解别人代码

 如何优化反射？

一. 善用API

比如，尽量不要getMethods()后再遍历筛选，而直接用getMethod(methodName)来根据方法名获取方法

二、缓存

比如，需要多次动态创建一个类的实例的时候，有缓存的写法会比没有缓存要快很多:

// 1. 没有缓存
void createInstance(String className){
    return Class.forName(className).newInstance();
}

// 2. 缓存forName的结果
void createInstance(String className){
    cachedClass = cache.get(className);
    if (cachedClass == null){
        cachedClass = Class.forName(className);
        cache.set(className, cachedClass);
    }
    return cachedClass.newInstance();
}
为什么？当然是因为forName太耗时了。