Java反射

反射创建的三种方式

//第一种
Class<Student> c1 = Student.class;
System.out.println(c1);

Class<Student> c2 = Student.class;
System.out.println(c1==c2);//true
System.out.println("--------");
//第二种
Student student = new Student();
Class<? extends Student> c3 = student.getClass();
System.out.println(c1==c3);//true
//第三种
Class<?> c4 = Class.forName("cn.qileyun.Student");
System.out.println(c1==c4);//true

构造方法

• Constructor<?>[] getConstructors() 返回所有的公共的Constructor
• Constructor<?>[] getDeclaredConstructors() 返回所有的Constructor
• Constructor<?> getConstructor() 返回公共构造方法的其中一个
• Constructor<?> getDeclaredConstructor() 返回所有构造方法的其中一个
• newInstance() 创建对象

//获取Class对象
Class<?> c = Class.forName("cn.qileyun.Student");
//        Constructor<?>[] cons = c.getConstructors();//返回所有的公共构造方法，
Constructor<?>[] cons = c.getDeclaredConstructors();//返回所有的构造方法
for (Constructor<?> con : cons) {
   System.out.println(con);
}
System.out.println("---------");
Constructor<?> con = c.getConstructor();//返回一个Constructor公共对象其中一个 传入什么参数调用什么构造方法
c.getDeclaredConstructor();//返回一个Constructor对象其中一个


//Constructor提供一个类的单个构造方法的信息和访问权限
//T newInstance(Object... initargs) 使用由此Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数
Object obj = con.newInstance();//通过构造方法来创建对象
System.out.println(obj);

Object o = c.newInstance();
System.out.println(o);//默认调用无参构造方法

调用有参的构造方法

Class<?> c = Class.forName("cn.qileyun.Student");
//调用有参的构造方法
Constructor<?> constructor = c.getConstructor(String.class,int.class,String.class);
Object o = constructor.newInstance("林青霞",30,"西安");
System.out.println(o);

调用非公共的构造方法

Class<?> c = Class.forName("cn.qileyun.Student");
Constructor<?> declaredConstructor = c.getDeclaredConstructor(String.class);
//暴露反射
declaredConstructor.setAccessible(true);//值为true，取消访问检查
Object o = declaredConstructor.newInstance("林青霞");
System.out.println(o);

返回成员变量

Class<?> c = Class.forName("cn.qileyun.Student");
//        Field[] fields = c.getFields();//拿公共成员变量
Field[] fields = c.getDeclaredFields();//拿全部成员变量
for (Field field : fields) {
    System.out.println(field);
}

System.out.println("----------");
Field address = c.getField("address");//公共
//        Field address = c.getDeclaredField("address");//私有

//获取无参构造方法创建对象
Constructor<?> constructor = c.getConstructor();
Object obj = constructor.newInstance();

//Field提供有关类或接口的单个字段的信息和动态访
address.set(obj,"西安");//给obj的成员变量address 赋值为西安

私有的成员变量赋值

Class<?> c = Class.forName("cn.qileyun.Student");
Constructor<?> constructor = c.getConstructor();
Object o = constructor.newInstance();
Field name = c.getDeclaredField("name");
//暴力反射
name.setAccessible(true);
name.set(o,"林青霞");
System.out.println(o);

获取成员方法

Class<?> c = Class.forName("cn.qileyun.Student");
//Method[] methods = c.getMethods();//返回该class的公共方法包超类继承的方法
Method[] methods = c.getDeclaredMethods();//返回本类的全部方法
for (Method method : methods) {
    System.out.println(method);
}


System.out.println("---------");
Method method = c.getMethod("method1");//获取单个方法
//        Method method = c.getDeclaredMethod("");
Constructor<?> constructor = c.getConstructor();
Object o = constructor.newInstance();


//在类或接口上提供有关单一方法的信息和访问权限
//Object invoke(Object obj,Object... args);//在具有指定参数的指定对象上调用此,方法对象表示的基础方法
method.invoke(o);//调用方法 如果有返回值可以对变量赋值


Method method3 = c.getMethod("method3", String.class, int.class);
method3.setAccessible(true);//暴力反射
Object me3 = method3.invoke(o, "林青霞", 30);
System.out.println(me3);

使用反射调用ArrayList原始方法

ArrayList<Integer> array = new ArrayList<Integer>();
//
//        array.add(10);
//        array.add(20);
//        array.add("hello");//无法添加


Class<? extends ArrayList> aClass = array.getClass();
//通过反射调用它的原始方法
Method m = aClass.getMethod("add", Object.class);
m.invoke(array,"hello");
m.invoke(array,"world");
m.invoke(array,"java");
System.out.println(array);

使用反射加载配置文件创建对象

/**
* class.txt
* className=xxx
* methodName=xx
*/

Properties prop = new Properties();
FileReader fileReader = new FileReader("class.txt");
prop.load(fileReader);
fileReader.close();
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");

//通过反射来使用
Class<?> c = Class.forName(className);

Constructor<?> con = c .getConstructor();
Object o = con.newInstance();

Method method = c.getMethod(methodName);

method.invoke(o);