Java反射2.反射的使用

最新推荐文章于 2024-09-15 21:40:29 发布

风暴计划

最新推荐文章于 2024-09-15 21:40:29 发布

阅读量248

点赞数

分类专栏： Java设计模式反射动态代理文章标签： Java反射机制反射机制剖析通过反射获取成员变量通过反射获取成员方法通过反射获取构造方法

本文链接：https://blog.csdn.net/cmm0401/article/details/82830624

版权

Java设计模式反射动态代理专栏收录该内容

13 篇文章 0 订阅

订阅专栏

反射的使用

class文件是赤裸裸的暴露在反射面前！

常用方法：

（1）通过反射获取构造方法并使用：

获取构造方法（带参的或者不带参的都可以）：
- getConstructors：获取所有的公共构造方法
- getConstructor：获取单个的公共构造方法
- getDeclaredConstructors：获取所有的构造方法（包括public、private、protected、默认）
- getDeclaredConstructor：获取单个的构造方法（包括public、private、protected、默认）
创建对象：
- newInstance()。举例：con.newInstance(“zhangsan", 20);

（2）通过反射获取成员变量并使用：

获取成员变量：
- getFields：获取所有的公共成员变量
- getField：获取单个的公共成员变量
- getDeclaredFields：获取所有的成员变量（包括public、private、protected、默认）
- getDeclaredField：获取单个的成员变量（包括public、private、protected、默认）
修改成员变量的值：
- set(Object obj,Object value)：将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

（3）通过反射获取成员方法并使用：

获取成员方法（带参的或者不带参的都可以）：
- getMethods：获取所有的公共成员方法
- getMethod：获取单个的公共成员方法
- getDeclaredMethods：获取所有的成员方法（包括public、private、protected、默认）
- getDeclaredMethod：获取单个的成员方法（包括public、private、protected、默认）
暴力访问：
- method.setAccessible(true); ：值为true则指示反射的对象在使用时应该取消Java语言访问检查。对于私有的成员方法和私有的成员变量，均要先设置为true，不然会出错！

1、通过反射机制获取Java类的构造方法并使用

（1）Person类

package cn.itcast_01;
public class Person {
	private String name;
	int age;
	public String address;
 
	public Person() {
	}
	private Person(String name) {
		this.name = name;
	}
	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Person(String name, int age, String address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}
	public void show() {
		System.out.println("show");
	}
	public void method(String s) {
		System.out.println("method " + s);
	}
	public String getString(String s, int i) {
		return s + "---" + i;
	}
	private void function() {
		System.out.println("function");
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", address=" + address
				+ "]";
	}
}

（2）通过反射机制获取Person类的无参构造方法并使用

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

（3）通过反射机制获取Person类的带参构造方法并使用

package cn.itcast_02;
import java.lang.reflect.Constructor;
/*
 * 需求：通过反射去获取该构造方法并使用：public Person(String name, int age, String address)
 * Person p = new Person("林青霞",27,"北京");
 * System.out.println(p);
 */
public class ReflectDemo2 {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_01.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("林青霞", 27, "北京");
		System.out.println(obj);
	}
}

（4）通过反射机制获取Person类的私有构造方法并使用

package cn.itcast_02;
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("cn.itcast_01.Person");
		// 获取私有构造方法对象
		// NoSuchMethodException：没有这个方法异常
		// 原因是一开始我们使用的方法只能获取公共的构造器，下面这种方式就可以了。
		Constructor con = c.getDeclaredConstructor(String.class);
		// 用该私有构造方法对象创建对象
		// IllegalAccessException:非法的访问异常。
		// 设置暴力访问
		con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
		Object obj = con.newInstance("风清扬");
		System.out.println(obj);
	}
}

2、通过反射机制获取Java类的成员变量并使用

（1）获取public修饰符修饰的成员变量-获取private修饰符修饰的成员变量-获取默认修饰符修饰的成员变量。

package cn.itcast_03;
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("cn.itcast_01.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并对其赋值（public修饰的成员变量）
		Field addressField = c.getField("address");
		// public void set(Object obj,Object value)
		// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
		addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
		System.out.println(obj);
		// 获取name并对其赋值（private修饰的成员变量）
		// 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, 27);
		System.out.println(obj);
	}
}

3、通过反射机制获取Java类的成员方法并使用

package cn.itcast_04;
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("cn.itcast_01.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();
		 */
		// 获取单个方法并使用
		// （1）公共的无参无返回值方法：public void show()
		// public Method getMethod(String name,Class<?>... parameterTypes)：第一个参数表示的方法名，第二个参数表示 该方法的参数的class类型
		Method m1 = c.getMethod("show");
		// public Object invoke(Object obj,Object... args)：返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
		m1.invoke(obj); // 调用obj对象的m1方法
		System.out.println("----------");
		// （2）公共的有参无返回值方法：public void method(String s)
		Method m2 = c.getMethod("method", String.class);
		m2.invoke(obj, "hello");
		System.out.println("----------");
		// （3）公共的有参有返回值方法：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);
	}
}