反射的概念和用法

1 类的加载

1.1 类的加载概述

类的加载

             当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连                      接, 初始化三步来实现对这个类进行初 始化。

加载  

              就是指将class文件读入内存，并为之创建一个Class对象。

              任何类被使用时系统都会建立一个Class对象。

连接

              验证 是否有正确的内部结构，并和其他类协调一

              准备 负责为类的静态成员分配内存，并设置默认初始化值

              解析 将类的二进制数据中的符号引用替换为直接引用

              初始化 就是我们以前讲过的初始化步骤

1.2 类初始化时机

创建类的实例

访问类的静态变量，或者为静态变量赋值

调用类的静态方法

使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

初始化某个类的子类

直接使用java.exe命令来运行某个主类

2.反射

2.1通过反射获取构造方法并使用

//获取构造方法
//getConstructors
//getDeclaredConstructors
//创建对象
//newInstance()
//con.newInstance(“zhangsan", 20);
//2.2 通过反射获取构造方法有参的
package com.demo2;
import java.lang.reflect.Constructor;
import com.demo.Person;
/*
* 通过反射获取构造方法并使用。
*/
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("com.demo.Person");
// 获取构造方法
// public Constructor[] getConstructors():所有公共构造方法
// public Constructor[] getDeclaredConstructors():所有构造方法
// Constructor[] cons = c.getDeclaredConstructors();
// for (Constructor con : cons) {
// System.out.println(con);
// }
// 获取单个构造方法
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
// 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
Constructor con = c.getConstructor();// 返回的是构造方法对象
// Person p = new Person();
// System.out.println(p);
// public T newInstance(Object... initargs)
// 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实
例。
Object obj = con.newInstance();
System.out.println(obj);
// Person p = (Person)obj;
// p.show();
}
}

2.2 通过反射获取构造方法有参的

package com.demo2;
import java.lang.reflect.Constructor;
/*
* 需求：通过反射去获取该构造方法并使用：
* public Person(String name, int age, String address)
*
2.3 通过反射获取私有构造方法并使用
* Person p = new Person("高圆圆",39,"北京");
* System.out.println(p);
*/
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("com.demo.Person");
// 获取带参构造方法对象
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class, int.class,
String.class);
// 通过带参构造方法对象创建对象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("高圆圆", 39, "北京");
System.out.println(obj);
}
}

2.3 通过反射获取私有构造方法并使用

package com.demo2;
import java.lang.reflect.Constructor;
/*
* 需求：通过反射获取私有构造方法并使用
* private Person(String name){}
*
* Person p = new Person("赵又廷");
* System.out.println(p);
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("com.demo.Person");
// 获取私有构造方法对象
// NoSuchMethodException：每个这个方法异常
// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
Constructor con = c.getDeclaredConstructor(String.class);
// 用该私有构造方法创建对象
// IllegalAccessException:非法的访问异常。
// 暴力访问
con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
Object obj = con.newInstance("赵又廷");
System.out.println(obj);
}
}

2.4 通过反射获取成员变量并使用

//获取所有成员
//getFields,getDeclaredFields
//获取单个成员
//getField,getDeclaredField
//修改成员的值
//set(Object obj,Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
package com.demo3;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
/*
* 通过反射获取成员变量并使用
*/
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("com.demo.Person");
// 获取所有的成员变量
// Field[] fields = c.getFields();
// Field[] fields = c.getDeclaredFields();
// for (Field field : fields) {
// System.out.println(field);
// }
/*
* Person p = new Person(); p.address = "北京"; System.out.println(p);
*/
// 通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
// 获取单个的成员变量
// 获取address并对其赋值
Field addressField = c.getField("address");
// public void set(Object obj,Object value)
// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
System.out.println(obj);
// 获取name并对其赋值
// NoSuchFieldException
Field nameField = c.getDeclaredField("name");
// IllegalAccessException
nameField.setAccessible(true);
nameField.set(obj, "高圆圆");
System.out.println(obj);
// 获取age并对其赋值
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 39);
System.out.println(obj);
}
}

2.5 通过反射获取成员方法并使用

//获取所有方法
//getMethods
//getDeclaredMethods
//获取单个方法
//getMethod
//getDeclaredMethod
//暴力访问
//method.setAccessible(true);
package com.demo4;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("com.demo.Person");
// 获取所有的方法
// Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
// Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
// for (Method method : methods) {
// System.out.println(method);
// }
Constructor con = c.getConstructor();
Object obj = con.newInstance();
/*
* Person p = new Person(); p.show();
*/
// 获取单个方法并使用
// public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
Method m1 = c.getMethod("show");
// obj.m1(); // 错误
// public Object invoke(Object obj,Object... args)
// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
m1.invoke(obj); // 调用obj对象的m1方法
System.out.println("----------");
// public void method(String s)
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("----------");
// public String getString(String s, int i)
Method m3 = c.getMethod("getString", String.class, int.class);
Object objString = m3.invoke(obj, "hello", 100);
System.out.println(objString);
// String s = (String)m3.invoke(obj, "hello",100);
// System.out.println(s);
System.out.println("----------");
// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}