本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布
 
为什么要写这一系列的博客呢？
 
因为在 Android 开发的过程中， 泛型，反射，注解这些知识进场会用到，几乎所有的框架至少都会用到上面的一两种知识，如 Gson 就用到泛型，反射，注解，Retrofit 也用到泛型，反射，注解 。学好这些知识对我们进阶非常重要，尤其是阅读开源框架源码或者自己开发开源框架。
 
java Type 详解
 
java 反射机制详解
 
注解使用入门（一）
 
Android 自定义编译时注解1 - 简单的例子
 
Android 编译时注解 —— 语法详解
 
带你读懂 ButterKnife 的源码
 
反射机制
 
什么是反射机制
 
简单来说，反射可以帮助我们在动态运行的时候，对于任意一个类，可以获得其所有的方法（包括 public protected private 默认状态的），所有的变量 （包括 public protected private 默认状态的）。是不是很强大呢。
 
反射机制有什么作用呢？
 
获取某些类的一些变量，调用某些类的私有方法。（例如在Android开发中我们可以用来开启 WiFi 热点，调用 WifiManager 中的 setWifiApEnabled() 方法 ）
增加代码的灵活性。很多主流框架都使用了反射技术.像ssh框架都采用两种技术 xml做配置文件+反射技术.
 
 
假如有这样一个类 Person，它拥有多个成员变量，country,city,name,province,height,age 等，同时它拥有多个 构造方法，多个方法，这些变量，方法的访问权限既有 public 也有 private 的。下面我们以这个为例子，一起看怎样使用反射获得相应的 Filed，Constructor，Method。
 
/**
 * 博客地址：http://blog.csdn.net/gdutxiaoxu
 * @author xujun
 * @time 2017/3/29 22:19.
 */
public class Person {
    public String country;
    public String city;
    private String name;
    private String province;
    private Integer height;
    private Integer age;


    public Person() {
        System.out.println("调用Person的无参构造方法");
    }

    private Person(String country, String city, String name) {
        this.country = country;
        this.city = city;
        this.name = name;
    }

    public Person(String country, Integer age) {
        this.country = country;
        this.age = age;
    }

    private String getMobile(String number) {
        String mobile = "010-110" + "-" + number;
        return mobile;
    }


    private void setCountry(String country) {
        this.country=country;

    }

    public void getGenericHelper(HashMap<String, Integer> hashMap) {
    }

    public Class getGenericType() {
        try {
            HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
            Method method = getClass().getDeclaredMethod("getGenericHelper",HashMap.class);
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                return null;
            }

            ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
            Type rawType = parameterizedType.getRawType();
            System.out.println("----> rawType=" + rawType);
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                return null;
            }

            for (int i = 0; i < actualTypeArguments.length; i++) {
                Type type = actualTypeArguments[i];
                System.out.println("----> type=" + type);
            }
        } catch (Exception e) {

        }
        return null;
    }

    @Override
    public String toString() {
        return "Person{" +
                "country='" + country + '\'' +
                ", city='" + city + '\'' +
                ", name='" + name + '\'' +
                ", province='" + province + '\'' +
                ", height=" + height +
                '}';
    }
}
 
使用反射获得所有构造方法（包括私有的，非私有的）
 
默认权限的指的是没有修饰符修饰的
 
几个重要的方法讲解
 
方法
描述
public Constructor getConstructor(Class<?>… parameterTypes)
获得指定的构造方法，注意只能获得 public 权限的构造方法，其他访问权限的获取不到
public Constructor getDeclaredConstructor(Class<?>… parameterTypes)
获得指定的构造方法，注意可以获取到任何访问权限的构造方法。
public Constructor<?>[] getConstructors() throws SecurityException
获得所有 public 访问权限的构造方法
public Constructor<?>[] getDeclaredConstructors() throws SecurityException
获得所有的构造方法，包括（public, private,protected,默认权限的）
看了上面的几个方法，其实很好区分
 
后缀带 s 的返回对象时数组类型，是可以获得相应权限的所有方法的，如 Constructor getConstructor() 方法 和 Constructor<?>[] getConstructors() 方法。几乎可以这样说，java 99% 的代码风格是这样的。 同时这里也引申出一个问题，平时你在开发中有没有遵循一定的开发规范。
getConstructor() 方法和 getDeclaredConstructor 中间只相差一个单词 Declared ，区别在与是获得 public 权限的方法还是所有权限的方法。
 
这里为什么要强调这一点呢？因为以下要讲解的 getMethod(), getMethods(),getDeclaredMethod(),getDelcaredMethods() 等方法与这个类似，下面不再阐述。
 
获得所有的构造方法
 
public static void printConstructor(String className) {
    try {
        Class<?> aClass = Class.forName(className);
        Constructor<?>[] constructors = aClass.getConstructors();
        print(constructors);
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        print(declaredConstructors);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

}
 
 
 
print: private com.example.reflectdemo.Person(java.lang.String,java.lang.String,java.lang.String)
 
 
 
 
print: public com.example.reflectdemo.Person()
 
 
 
 
print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)
 
 
 
 
print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)
 
 
对比 Person 里面所有的构造方法，可以知道我们代码的逻辑是正确的
 
获得指定的构造方法
 
public static Constructor getConstructor(String className, Class<?>... clzs) {
    try {
        Class<?> aClass = Class.forName(className);
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(clzs);
        print(declaredConstructor);
        //   if Constructor is not public,you should call this
        declaredConstructor.setAccessible(true);
        return declaredConstructor;

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    return null;

}

public class TestHelper {

    public static  final String TAG="xujun";
    public static final String CLASS_NAME = "com.example.reflectdemo.Person";
    public static final String CHINA = "China";

    public static void testConstructor(){
        ReflectHelper.printConstructor(CLASS_NAME);
        Constructor constructor = ReflectHelper.getConstructor(CLASS_NAME, String.class, Integer.class);
        try {
            Object meinv = constructor.newInstance(CHINA, 12);
            Person person = (Person) meinv;
            Log.i(TAG, "testConstructor: =" + person.toString());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}
 
我们将可以看到以下的输出结果
 
 
 
testConstructor: =Person [country=China, city=null, name=null, province=null, height=null, age=12]
 
 
可以看到 country=China，age=12 这说明我们成功通过反射调用 Person 带两个参数的沟改造方法。
 
注意事项
 
如果该方法，或者该变量不是 public 访问权限的，我们应该调用相应的 setAccessible(true) 方法，才能访问得到
 
//if Constructor is not public,you should call this
declaredConstructor.setAccessible(true);
 
使用反射获得所有的 Field 变量
 
获得所有的 Field 变量
 
public static void printField(String className) {
    try {
        Class<?> aClass = Class.forName(className);
        Field[] fields = aClass.getFields();
        PrintUtils.print(fields);
        Field[] declaredFields = aClass.getDeclaredFields();
        PrintUtils.print(declaredFields);

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
 
获得指定的成员变量
 
现在假如我们要获得 Person 中的私有变量 age ，我们可以通过以下的代码获得，同时并打印出所有的成员变量。
 
public static Field getFiled(String className, String filedName) {
    Object o = null;
    try {
        Class<?> aClass = Class.forName(className);

        Field declaredField = aClass.getDeclaredField(filedName);
        //   if not public,you should call this
        declaredField.setAccessible(true);
        return declaredField;


    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
    return null;

}

public  static void testFiled(){
    ReflectHelper.printFileds(CLASS_NAME);
    Person person = new Person(CHINA, 12);
    Field field = ReflectHelper.getFiled(CLASS_NAME, "age");
    try {
        Integer integer = (Integer) field.get(person);
        PrintUtils.print("integer="+integer);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }

}


 
我们可以看到以下的输出结果
 
 
 
print: public java.lang.String com.example.reflectdemo.Person.country
 
 
 
 
print: public java.lang.String com.example.reflectdemo.Person.city
 
 
 
 
print: public java.lang.String com.example.reflectdemo.Person.country
 
 
 
 
print: public java.lang.String com.example.reflectdemo.Person.city
 
 
 
 
print: private java.lang.String com.example.reflectdemo.Person.name
 
 
 
 
print: private java.lang.String com.example.reflectdemo.Person.province
 
 
 
 
print: private java.lang.Integer com.example.reflectdemo.Person.height
 
 
 
 
print: private java.lang.Integer com.example.reflectdemo.Person.age
 
 
 
 
print:integer=12
 
 
使用反射执行相应的 Method
 
主要有以下几个方法，
 
public Method[] getDeclaredMethods()
public Method[] getMethods() throws SecurityException
public Method getDeclaredMethod()
public Method getMethod(String name, Class<?>… parameterTypes)
 
几个方法的作用我就不一一阐述了，因为上面在讲解 使用反射获得所有构造方法（包括私有的，非私有的） 的时候已经提到过了。
 
获取所有的 Method
 
    public static void printMethods(String className) {
        try {
            Class<?> aClass = Class.forName(className);
            Method[] declaredMethods = aClass.getDeclaredMethods();
            PrintUtils.print(declaredMethods);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
 
 
 
print: public java.lang.String com.example.reflectdemo.Person.toString()
 
 
 
 
print: public java.lang.Class com.example.reflectdemo.Person.getGenericType()
 
 
 
 
print: private void com.example.reflectdemo.Person.setCountry(java.lang.String)
 
 
 
 
print: public void com.example.reflectdemo.Person.getGenericHelper(java.util.HashMap)
 
 
 
 
print: private java.lang.String com.example.reflectdemo.Person.getMobile(java.lang.String)
 
 
对比 Person 里面的所有方法，毫无疑问我们的代码逻辑是正确的。
 
获取指定的 Method
 
我们可以使用 getDeclaredMethod(String name, Class<?>... parameterTypes) 或者 getMethod(String name, Class<?>… parameterTypes) 获得指定的方法，只不过 getMethod 方法只能获得 public 访问权限的方法，getDeclaredMethod 可以获得任何访问权限的方法。
 
注意一下方法参数， name 代表的是方法的名称，Class<?>… parameterTypes 代表的是方法参数的类型，至于为什么是 … 数组类型的，因为我们参数可能是一个也可能是多个的。
 
这里我们以 Person 类 里面的 private void setCountry(String country) 方法为例子讲解，可以看到方法名称为 setCountry ，方法参数的类型为 String ,所以我们在传递参数的时候 name 为 setCountry ，parameterTypes 为 String.class 。如果有多个参数，在加上该参数的 Class 类型即可。
 
   public static void testMethod(){
    	ReflectHelper.printMethods(CLASS_NAME);
        Person person=new Person();
        Method method = ReflectHelper.getMethod(CLASS_NAME,
                "setCountry", String.class);
        try {
           // 执行方法，结果保存在 person 中
            Object o = method.invoke(person, CHINA);
           // 拿到我们传递进取的参数 country 的值 China          
            String country=person.country;
            PrintUtils.print(country);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
    
    
public class ReflectHelper {

    private static final String TAG = "ReflectHelper";

    public static Method getMethod(String className, String methodName, Class<?>... clzs) {
        try {
            Class<?> aClass = Class.forName(className);
            Method declaredMethod = aClass.getDeclaredMethod(methodName, clzs);
            declaredMethod.setAccessible(true);
            return declaredMethod;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }
}
 
执行上面的函数，将可以看到下面的结果
 
 
 
print:China
 
 
即我们成功利用反射调用 Person 的 setCountry 方法，并将值成功改变。
 
 
使用反射操作数组
 
/**
     * 利用反射操作数组
     * 1 利用反射修改数组中的元素
     * 2 利用反射获取数组中的每个元素
     */
    public static void testArrayClass() {
        String[] strArray = new String[]{"5","7","暑期","美女","女生","女神"};
        Array.set(strArray,0,"帅哥");
        Class clazz = strArray.getClass();
        if (clazz.isArray()) {
            int length = Array.getLength(strArray);
            for (int i = 0; i < length; i++) {
                Object object = Array.get(strArray, i);
                String className=object.getClass().getName();
                System.out.println("----> object=" + object+",className="+className);
            }
        }
    }
 
 
 
----> object=帅哥,className=java.lang.String
 
 
 
 
----> object=7,className=java.lang.String
 
 
 
 
----> object=暑期,className=java.lang.String
 
 
 
 
----> object=美女,className=java.lang.String
 
 
 
 
----> object=女生,className=java.lang.String
 
 
 
 
----> object=女神,className=java.lang.String
 
 
从结果可以说明，我们成功通过 Array.set(strArray,0,“帅哥”) 改变数组的值。
 
使用反射获得泛型类型
 
public static void getGenericHelper(HashMap<String, Person> map) {

    }
 
现在假设我们有这样一个方法，那我们要怎样获得 HashMap 里面的 String，Person 的类型呢？
 
对于 Java Type还不熟悉的可以先读这一篇博客  java Type 详解
 
public static  void getGenericType() {
        try {
            Method method =TestHelper.class.getDeclaredMethod("getGenericHelper",HashMap.class);
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            // 检验是否为空
            if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                return ;
            }
            // 取 getGenericHelper 方法的第一个参数
            
            ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
            Type rawType = parameterizedType.getRawType();
            System.out.println("----> rawType=" + rawType);
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                return ;
            }
            //  打印出每一个类型          
            for (int i = 0; i < actualTypeArguments.length; i++) {
                Type type = actualTypeArguments[i];
                System.out.println("----> type=" + type);
            }
        } catch (Exception e) {

        }

    }
 
执行上面的代码，输出结果
 
 
 
----> rawType=class java.util.HashMap
 
 
 
 
----> type=class java.lang.String
 
 
 
 
----> type=class com.example.reflectdemo.Person
 
 
 
怎样获得 Metho,Field,Constructor 的访问权限 （ public,private,ptotected 等）
 
其实很简单，我们阅读文档可以发现他们都有 getModifiers() 方法，该方法放回 int 数字， 我们在利用 Modifier.toString() 就可以得到他们的访问权限
 
int modifiers = method.getModifiers();
Modifier.toString(modifiers);
 
 
demo 下载地址
 
好了，今天就写这么多了，明天准备回一下家，接着回一下学校。下一篇准备写 关于怎样编写自定义注解（基于编译时期的），敬且期待。
 
推荐阅读
 
一步步拆解 LeakCanary
 
Android 面试必备 - http 与 https 协议
 
Android 面试必备 - 计算机网络基本知识（TCP，UDP，Http，https）
 
Android 面试必备 - 线程
 
Android_interview github 地址
 
 
扫一扫，欢迎关注我的微信公众号 stormjun94， 目前专注于 Android 开发，主要分享 Android开发相关知识和技术人成长历程，包括个人总结，职场经验，面试经验等。

一、什么是反射机制
 
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
 
“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。Java不是动态语言。但是Java有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。
 
二、初识Java反射机制
 
反射之中包含了一个“反”的概念，要解释反射就必须先从“正”开始解释，一般而言，一定是先有类再产生实例化对象。如下：
 
package com.wz.reflectdemo;

import java.util.Date;//先有类

public class ReflectTest {

    public static void main(String[] args) {
        Date date = new Date();//再产对象
        System.out.println(date);
    }
}
 
而所谓的“反”，是通过对象找到类。在Object类里面提供有一个方法， 
 取得class对象：
 
public final Class<?> getClass()
 
注：反射之中的所有泛型都定义为?，返回值都是Object。
 
实例如下：
 
package com.wz.reflectdemo;

import java.util.Date;//先有类

public class ReflectTest {

    public static void main(String[] args) {
        Date date = new Date();//再产对象
        System.out.println(date.getClass());
    }
}
 
执行结果：
 
class java.util.Date
 
我们发现，调用getClass()后，得到了类的完整名称。也就找到了对象的出处。
 
三、Class类对象实例化
 
java.lang.Class是一个类，它和一般类一样继承自Objec。这个类是反射操作的源头，即所有的反射都要从此类开始进行，这个类有三种实例化方式：
 
方式一：调用Object类的getClass()方法（很少用到）：
 
package com.wz.reflectdemo;

import java.util.Date;

public class ReflectTest {

    public static void main(String[] args) {
        Date date = new Date();
        Class<?> cls = date.getClass();
        System.out.println(cls);
    }
}
 
运行结果：
 
class java.util.Date
 
方式二：使用“类.class”取得：
 
package com.wz.reflectdemo;

import java.util.Date;

public class ReflectTest {

    public static void main(String[] args) {
        //Date date = new Date();
        Class<?> cls = Date.class;
        System.out.println(cls);
    }
}
 
运行结果：
 
class java.util.Date
 
注意：先前取得Class类对象之前需要实例化，但此时并没有进行实例化。
 
方式三：调用Class类提供的一个方法：
 
public static Class<?> forName(String className) throws ClassNotFoundException
 
实例如下：
 
package com.wz.reflectdemo;

//import java.util.Date;

public class ReflectTest {

    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("java.util.Date");
        System.out.println(cls);
    }
}
 
运行结果：
 
class java.util.Date
 
此时，无需使用import语句导入一个明确的类，而类名称是采用字符串的形式进行描述的。
 
四、反射实例化对象
 
一般情况下，对象的实例化操作需要依靠构造方法和关键字new完成。可是有了Class类对象之后，可以利用反射来实现对象的实例化。 
 通过反射实例化对象：
 
public T newInstance() throws InstantiationException, IllegalAccessException
 
实例：
 
package com.wz.reflectdemo;

class Book{

    public Book(){
        System.out.println("Book类的无参构造方法");
    }

    @Override
    public String toString() {

        return "This a book !";
    }
}

public class TestDemo {

    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
        Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象

        Book book = (Book)obj;
        System.out.println(book);
    }

}
 
运行结果：
 
Book类的无参构造方法
This a book !
 
如上，有了反射之后，进行实例化的操作不再只有依靠关键字new来完成了。但这个操作要比之前使用的new复杂一些，并且并不表示用new来进行实例化被完全取代了。为什么呢？
 
对于程序的开发一直强调：尽量减少耦合。而减少耦合的最好做法是使用接口，但是就算使用了接口也逃不出关键字new，所以实际上new是造成耦合的关键元凶。
 
先看一个简单的工厂设计模式：
 
package com.wz.reflectdemo;


interface Fruit{
    public void eat();
}

class Apple implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat apple");
    }
}

class Factory{
    public static Fruit getInstance(String className){
        if("apple".equals(className)){
            return new Apple();
        }
        return null;
    }
}

public class FactoryDemo{
    public static void main(String[] args){
        Fruit f = Factory.getInstance("apple");
        f.eat();
    }
}
 
运行结果：
 
eat apple
 
以上是一个简单的工厂设计模式，但是在这个工厂设计模式之中有一个问题：如果增加了Fruit接口子类，那么就需要修改工厂类。
 
增加了Fruit接口子类Orange ：
 
class Orange implements Fruit {
    public void eat() {
        System.out.println("eat orange");
    };
}
 
需要修改工厂类：
 
class Factory{
    public static Fruit getInstance(String className){
        if("apple".equals(className)){
            return new Apple();
        }else if("orange".equals(className)){
            return new Orange();
        }
        return null;

    }
}
 
问题来了，每增加一个接口子类，就需要去修改工厂类，那么若随时可能增加多个子类呢？那么就要一直对工厂类进行修改！
 
根本原因：工厂类中的对象都是通过关键字new直接实例化的。那么如果说现在不使用关键字new了，变为了反射机制呢？
 
反射机制实例化对象的时候实际上只需要“包.类”就可以，于是根据此操作，修改工厂设计模式如下：
 
package com.wz.reflectdemo;


interface Fruit{
    public void eat();
}

class Apple implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat apple");
    }
}

class Orange implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat orange");
    }
}

class Factory{
    public static Fruit getInstance(String className){
        /*if("apple".equals(className)){
            return new Apple();
        }else if("orange".equals(className)){
            return new Orange();
        }
        return null;*/
        Fruit f = null;
        try {
            f = (Fruit)Class.forName(className).newInstance();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;

    }
}

public class FactoryDemo{
    public static void main(String[] args){
        /*Fruit f = Factory.getInstance("apple");
        f.eat();

        Fruit f1 = Factory.getInstance("orange");
        f1.eat();*/

        Fruit f1= Factory.getInstance("com.wz.reflectdemo.Apple");
        f1.eat();

        Fruit f2 = Factory.getInstance("com.wz.reflectdemo.Orange");
        f2.eat();

    }
}
 
运行结果：
 
eat apple
eat orange
 
这个时候即使增加了接口的子类，工厂类照样可以完成对象的实例化操作，这个才是真正的工厂类，可以应对于所有的变化。这就完成了解耦合的目的，而且扩展性非常强。
 
五、反射调用构造方法
 
之前我们通过反射实例化对象都是这么写的：
 
Class<?> cls = Class.forName(“*****className*****”);
Object  obj =  cls.newInstance();
 
这只能调用默认的无参构造方法，那么，问题来了：若类中不提供无参构造方法呢？怎么解决？
 
看一个范例：
 
先写一个Book类：
 
package com.wz.reflectdemo;

public class Book {

    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    @Override
    public String toString() {

        return "图书名称："+this.title + " ,价格："+this.price;
    }

}
 
然后实例化对象：
 
package com.wz.reflectdemo;

public class ReflectTest {

    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
        Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象

        Book book = (Book)obj;
        System.out.println(book);

    }
}
 
执行结果：
 
Exception in thread "main" java.lang.InstantiationException: com.wz.reflectdemo.Book
    at java.lang.Class.newInstance(Unknown Source)
    at com.wz.reflectdemo.ReflectTest.main(ReflectTest.java:8)
Caused by: java.lang.NoSuchMethodException: com.wz.reflectdemo.Book.<init>()
    at java.lang.Class.getConstructor0(Unknown Source)
    ... 2 more
 
由此可见，由于此时Book类没有提供无参构造方法，而cls.newInstance()的时候又调用了无参构造方法，所以无法进行对象实例化。那么，怎么解决？只能明确的调用有参构造方法。
 
在Class类里面，提供了方法来取得构造： 
 （1）取得全部构造：
 
public Constructor<?>[] getConstructors() throws SecurityException
 
（2）取得一个指定参数顺序的构造：
 
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
 
以上两个方法返回的都是”java.lang.reflect.Constructor”类的对象。在这个类中提供有一个明确传递有参构造内容的实例化对象方法：
 
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
 
改写上面范例的实例化对象方法，明确调用有参构造方法：
 
package com.wz.reflectdemo;

import java.lang.reflect.Constructor;

public class ReflectTest {

    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
        /*Object obj = cls.newInstance();//相当于使用new调用无参构造实例化对象
        Book book = (Book)obj;
        System.out.println(book);*/

        Constructor<?> con = cls.getConstructor(String.class,double.class);
        Object obj = con.newInstance("Java开发",79.8);//实例化对象

        System.out.println(obj);

    }
}
 
执行结果：
 
图书名称：Java开发 ,价格：79.8
 
很明显，调用无参构造方法实例化对象要比调用有参构造的更加简单、方便。so，简单的Java开发中不过提供有多少个构造方法，请至少保留有无参构造。
 
六、反射调用普通方法
 
我们都知道：类中的普通方法只有在一个类产生实例化对象之后才可以调用。
 
先看一个例子。我们先定义一个类：
 
package com.wz.reflectdemo;

public class Book {

    private String title;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

}
 
这个类有无参构造方法，所有实例化对象的时候可以直接利用Class类提供的newInstance()方法。
 
在Class类里面提供以下取得类在Method的操作： 
 （1）取得一个类中的全部方法：
 
public Method[] getMethods() throws SecurityException
 
（2）取得指定方法：
 
public Method getMethod(String name, Class<?>... parameterTypes) throws
NoSuchMethodException, SecurityException
 
以上的方法返回的都是”java.lang.reflect.Method”类的对象，在这个类中有一个调用方法：
 
public Object invoke(Object obj, Object... args) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException
 
我们接着上面的例子来看反射调用方法：
 
package com.wz.reflectdemo;

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

public class ReflectTest {

    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
        Object obj = cls.newInstance();

        Method setMet = cls.getMethod("setTitle", String.class);
        setMet.invoke(obj, "Java开发");//等价于Book类的setTitle("Java开发")

        Method getMet = cls.getMethod("getTitle");
        System.out.println(getMet.invoke(obj));//等价于Book类的getTitle()
    }
}
 
执行结果：
 
Java开发
 
此时，我们完全看不见具体的操作类型，也就是说，利用反射可以实现任意类的指定方法的调用。
 
七、反射调用成员
 
我们都知道，类中的属性一定要在本类实例化对象之后才可以分配内存空间。在Class类里面提供有取得成员的方法：
 
（1）取得全部成员：
 
public Field[] getDeclaredFields() throws SecurityException
 
（2）取得指定成员：
 
public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException
 
这两个方法的返回值类型是”java.lang.reflect.Field”类的对象。在这个类里面有两个重要的方法：
 
（1）取得属性内容（类似于：对象.属性）：
 
public Object get(Object obj)
throws IllegalArgumentException, IllegalAccessException
 
（2）设置属性内容（类似于：对象.属性=内容）：
 
public void set(Object obj, Object value)
throws IllegalArgumentException, IllegalAccessException
 
接着看一个例子： 
 先定义一个类：
 
package com.wz.reflectdemo;

public class Book {

    private String title;

}
 
这个类只定义了一个私有属性，按照之前的做法，它一定无法被外部所使用。但是，可以反射调用：
 
package com.wz.reflectdemo;

import java.lang.reflect.Field;

public class ReflectTest {

    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("com.wz.reflectdemo.Book");
        Object obj = cls.newInstance();

        Field titleField = cls.getDeclaredField("title");
        titleField.setAccessible(true);//解除封装
        titleField.set(obj, "Java开发");//相当于Book类对象.title = "Java开发"
        System.out.println(titleField.get(obj));//相当于Book类对象的.title
    }
}
 
执行结果：
 
Java开发
 
注：构造方法和普通方法一样可以解除封装，只是很少这么去做。而对于属性的访问还是建议使用setter和getter方法完成。

java基础(jdk1.8)
 
**
 
反射
 
**
 
JAVA反射机制是在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法
 
      对于任意一个对象，都能调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
 
常用于在不改变原有代码基础上增加功能
/**
 * 加载器加载类后会有一个类对象
 * 拿到这个类的文件对象（反射）
 * 然后用这个对象实现功能的增加
 */
 
获取文件对象
 
1.对象获取
 

    Demo d = new Demo();
    Class c = d.getClass();
    //c为class文件对象

 
2.类名获取
 

    Class c = Demo.class;
    //c为class文件对象

 
3.Class类静态方法获取
 

    Class c = Class.forName("package.Demo");//包名.类名
    //c为class文件对象

 
三者获取的class文件对象相等
 
运行构造方法
 
1.获取class文件对象
 
2.从class文件对象中，获取构造方法
 

    Class c = Class.forName("package.Demo");//包名.类名
    //获得所有公共构造方法
    Constructor[] cons = c.getConstructors();

    //获取指定构造方法(传参则获取指定构造方法,无参为无参构造)
    Constructor con = c.getConstructor();
    Constructor con1 = c.getConstructor(int.class);

    //运行构造方法
    Object o = con.newInstance();
    Object o1 = con.newInstance(1);
    
    //使用泛型可直接获取需要类的类对象
 
扩展：
 
如果被反射的类具有 空参构造方法 并且为public，即可如下操作
 

    Class c = Class.forName("package.Demo");

    Object object = c.newInstance();

 
注意：
 
以上只能执行public修饰的构造方法
 
执行private修饰则应该使用getDeclaredConstructor()方法（暴力反射）
 
成员变量
 
1.获取class文件对象
 
2.从class文件对象中，获取成员变量
 

    Class c = Class.forName("package.Demo");//包名.类名
    //获取所有公共成员变量
    Field[] fields = c.getFields();

    //获取指定成员变量(id)
    Field id = c.getField("id");

    //修改参数值
    Object obj = c.newInstance();
    id.set(obj,2);//需要传入指定类（无泛型则Object）

 
同样private修饰应该使用Declared
 
方法
 
1.获取class文件对象
 
2.从class文件对象中，获取方法
 

    Class c = Class.forName("package.Demo");//包名.类名
    //获取所有public方法
    Method[] methods = c.getMethods();

    //获取指定方法
    Method method = c.getMethod("eat");
    Method method1 = c.getMethod("eat", int.class);

    //运行方法
    Object obj = c.newInstance();
    method.invoke(obj);
    method1.invoke(obj,1);

 
上一篇 》类加载过程
 
 
下一篇 》Java集合