java反射机制

最新推荐文章于 2024-07-09 16:46:46 发布

！？？？？？

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量64

点赞数

文章标签：反射 java

本文链接：https://blog.csdn.net/qq_41628667/article/details/109739103

版权

1.反射的概述

是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

2.获取Class类对象的三种方式

1.类名.class属性
2.对象名.getClass()方法
3.Class.forName(全类名)方法

public class ReflectDemo {
	public static void main(String[] args) throws ClassNotFoundException {
		//使用类的class属性来获取该类对应的Class对象
		Class<Student> c1 = Student.class;
		System.out.println(c1);
		Class<Student> c2 = Student.class;
		System.out.println(c1 == c2);
		System.out.println("--------");
		//调用对象的getClass()方法，返回该对象所属类对应的Class对象
		Student s = new Student();
		Class<? extends Student> c3 = s.getClass();
		System.out.println(c1 == c3);
		System.out.println("--------");
		//使用Class类中的静态方法forName(String className)
		Class<?> c4 = Class.forName("com.itheima_02.Student");
		System.out.println(c1 == c4);
	}
}

3.反射获取构造方法并使用

3.1Class类获取构造方法对象的方法
Constructor<?>[] getConstructors()-----返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()----- 返回所有构造方法对象的数组
Constructor getConstructor(Class<?>… parameterTypes) -----返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class<?>…parameterTypes)----返回单个构造方法对象

public class ReflectDemo01 {
	public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, IllegalAccessException, InvocationTargetException,
InstantiationException {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//Constructor<?>[] getConstructors() 返回一个包含 Constructor对象的数组，
		//Constructor对象反映了由该 Class对象表示的类的所有公共构造函数
		// Constructor<?>[] cons = c.getConstructors();
		//Constructor<?>[] getDeclaredConstructors() 返回反映由该 Class对象表示的类
		//声明的所有构造函数的 Constructor对象的数组
		Constructor<?>[] cons = c.getDeclaredConstructors();
		for(Constructor con : cons) {
		System.out.println(con);
		}
		System.out.println("--------");
		//Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个
		//Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
		//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回
		//一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
		//参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
		Constructor<?> con = c.getConstructor();
		//Constructor提供了一个类的单个构造函数的信息和访问权限
		//T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，
		//使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
		Object obj = con.newInstance();
		System.out.println(obj);
		// Student s = new Student();
		// System.out.println(s);
	}
}

3.2Constructor类用于创建对象的方法
T newInstance(Object…initargs) -----------根据指定的构造方法创建对象

4.反射获取构造方法并使用练习1

案例需求:
通过反射获取公共的构造方法并创建对象

代码实现
学生类:

public class Student {
	//成员变量：一个私有，一个默认，一个公共
	private String name;
	int age;
	public String address;
	
	//构造方法：一个私有，一个默认，两个公共
	public Student() {
	}
	private Student(String name) {
	this.name = name;
	}
	Student(String name, int age) {
	this.name = name;
	this.age = age;
	}
	public Student(String name, int age, String address) {
	this.name = name;
		this.age = age;
	this.address = address;
	}
	
	//成员方法：一个私有，四个公共
	private void function() {
	System.out.println("function");
	}
	public void method1() {
	System.out.println("method");
	}
	public void method2(String s) {
	System.out.println("method:" + s);
	}
	public String method3(String s, int i) {
	return s + "," + i;
	}
	@Override
	public String toString() {
	return "Student{" +
	"name='" + name + '\'' +
	", age=" + age +
	", address='" + address + '\'' +
	'}';
	}
}

测试类:

public class ReflectDemo02 {
	public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, IllegalAccessException, InvocationTargetException,
InstantiationException {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//public Student(String name, int age, String address)
		//Constructor<T> getConstructor(Class<?>... parameterTypes)
		Constructor<?> con = c.getConstructor(String.class, int.class,
		String.class);
		//基本数据类型也可以通过.class得到对应的Class类型
		//T newInstance(Object... initargs)
		Object obj = con.newInstance("林青霞", 30, "西安");
		System.out.println(obj);
	}
}

5.反射获取构造方法并使用练习2

案例需求
通过反射获取私有构造方法并创建对象
学生类：参见上方学生类
测试类

public class ReflectDemo03 {
	public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, IllegalAccessException, InvocationTargetException,
InstantiationException {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//private Student(String name)
		//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
		Constructor<?> con = c.getDeclaredConstructor(String.class);
		//暴力反射
		//public void setAccessible(boolean flag):值为true，取消访问检查
		con.setAccessible(true);
		Object obj = con.newInstance("林青霞");
		System.out.println(obj);
	}
}

6.反射获取成员变量并使用

6.1Class类获取成员变量对象的方法

方法名说明
Field[] getFields() -----返回所有公共成员变量对象的数组
Field[] getDeclaredFields()------ 返回所有成员变量对象的数组
Field getField(String name) ------返回单个公共成员变量对象
Field getDeclaredField(String name) ------返回单个成员变量对象
示例代码

public class ReflectDemo01 {
	public static void main(String[] args) throws ClassNotFoundException,
NoSuchFieldException, NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//Field[] getFields() 返回一个包含 Field对象的数组， Field对象反映由该 Class对
		//象表示的类或接口的所有可访问的公共字段
		//Field[] getDeclaredFields() 返回一个 Field对象的数组，反映了由该 Class对象
		//表示的类或接口声明的所有字段
		// Field[] fields = c.getFields();
		Field[] fields = c.getDeclaredFields();
		for(Field field : fields) {
		System.out.println(field);
		}
		System.out.println("--------");
		//Field getField(String name) 返回一个 Field对象，该对象反映由该 Class对象表
		//示的类或接口的指定公共成员字段
		//Field getDeclaredField(String name) 返回一个 Field对象，该对象反映由该
		//Class对象表示的类或接口的指定声明字段
		Field addressField = c.getField("address");
		//获取无参构造方法创建对象
		Constructor<?> con = c.getConstructor();
		Object obj = con.newInstance();
		// obj.addressField = "西安";
		//Field提供有关类或接口的单个字段的信息和动态访问
		//void set(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字
		//段设置为指定的新值
		addressField.set(obj,"西安"); //给obj的成员变量addressField赋值为西安
		System.out.println(obj);
		// Student s = new Student();
		// s.address = "西安";
		// System.out.println(s);
	}
}

6.2Field类用于给成员变量赋值的方法
voidset(Object obj,Object value) ------给obj对象的成员变量赋值为value

7.反射获取成员变量并使用练习

案例需求
通过反射获取成员变量并赋值
代码实现
学生类：参见上方学生类
测试类:

public class ReflectDemo02 {
	public static void main(String[] args) throws Exception {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//Student s = new Student();
		Constructor<?> con = c.getConstructor();
		Object obj = con.newInstance();
		System.out.println(obj);
		//s.name = "林青霞";
		// Field nameField = c.getField("name"); //NoSuchFieldException:name
		Field nameField = c.getDeclaredField("name");
		nameField.setAccessible(true);
		nameField.set(obj, "林青霞");
		System.out.println(obj);
		//s.age = 30;
		Field ageField = c.getDeclaredField("age");
		ageField.setAccessible(true);
		ageField.set(obj,30);
		System.out.println(obj);
		//s.address = "西安";
		Field addressField = c.getDeclaredField("address");
		addressField.setAccessible(true);
		addressField.set(obj,"西安");
		System.out.println(obj);
	}
}

8.反射获取成员方法并使用

8.1Class类获取成员方法对象的方法
方法名说明
Method[] getMethods() -----返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods() ----返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>…parameterTypes)------返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>…parameterTypes)----返回单个成员方法对象
示例代码

public class ReflectDemo01 {
	public static void main(String[] args) throws Exception {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//Method[] getMethods() 返回一个包含 方法对象的数组， 方法对象反映由该 Class对
		//象表示的类或接口的所有公共方法，包括由类或接口声明的对象以及从超类和超级接口继承的类
		//Method[] getDeclaredMethods() 返回一个包含 方法对象的数组， 方法对象反映由
		//Class对象表示的类或接口的所有声明方法，包括public，protected，default（package）访问和私
		//有方法，但不包括继承方法
		// Method[] methods = c.getMethods();
		Method[] methods = c.getDeclaredMethods();
		for(Method method : methods) {
		System.out.println(method);
		}
		System.out.println("--------");
		//Method getMethod(String name, Class<?>... parameterTypes) 返回一个 方法
		//对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法
		//Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回
		//一个 方法对象，它反映此表示的类或接口的指定声明的方法 Class对象
		//public void method1()
		Method m = c.getMethod("method1");
		//获取无参构造方法创建对象
		Constructor<?> con = c.getConstructor();
		Object obj = con.newInstance();
		// obj.m();
		//在类或接口上提供有关单一方法的信息和访问权限
		//Object invoke(Object obj, Object... args) 在具有指定参数的指定对象上调用此
		//方法对象表示的基础方法
		//Object：返回值类型
		//obj：调用方法的对象
		//args：方法需要的参数
		m.invoke(obj);
		// Student s = new Student();
		// s.method1();
	}
}

8.2Method类用于执行方法的方法
Objectinvoke(Object obj,Object… args)------ 调用obj对象的成员方法，参数是args,返回值是Object类型

9.反射获取成员方法并使用练习

案例需求
通过反射获取成员方法并调用
代码实现
学生类：参见上方学生类
测试类:

public class ReflectDemo02 {
	public static void main(String[] args) throws Exception {
		//获取Class对象
		Class<?> c = Class.forName("com.itheima_02.Student");
		//Student s = new Student();
		Constructor<?> con = c.getConstructor();
		Object obj = con.newInstance();
		//s.method1();
		Method m1 = c.getMethod("method1");
		m1.invoke(obj);
		//s.method2("林青霞");
		Method m2 = c.getMethod("method2", String.class);
		m2.invoke(obj,"林青霞");
		// String ss = s.method3("林青霞",30);
		// System.out.println(ss);
		Method m3 = c.getMethod("method3", String.class, int.class);
		Object o = m3.invoke(obj, "林青霞", 30);
		System.out.println(o);
		//s.function();
		// Method m4 = c.getMethod("function"); //NoSuchMethodException:
		com.itheima_02.Student.function()
		Method m4 = c.getDeclaredMethod("function");
		m4.setAccessible(true);
		m4.invoke(obj);
	}
}

10.反射的案例

10.1反射练习之越过泛型检查
案例需求
通过反射技术，向一个泛型为Integer的集合中添加一些字符串数据
代码实现

public class ReflectTest01 {
	public static void main(String[] args) throws Exception {
		//创建集合
		ArrayList<Integer> array = new ArrayList<Integer>();
		// array.add(10);
		// array.add(20);
		// array.add("hello");
		Class<? extends ArrayList> c = array.getClass();
		Method m = c.getMethod("add", Object.class);
		m.invoke(array,"hello");
		m.invoke(array,"world");
		m.invoke(array,"java");
		System.out.println(array);
	}
}

10.2运行配置文件中指定类的指定方法
案例需求
通过反射运行配置文件中指定类的指定方法
代码实现:

public class ReflectTest02 {
	public static void main(String[] args) throws Exception {
		//加载数据
		Properties prop = new Properties();
		FileReader fr = new FileReader("myReflect\\class.txt");
		prop.load(fr);
		fr.close();
		/*
		className=com.itheima_06.Student
		methodName=study
		*/
		String className = prop.getProperty("className");
		String methodName = prop.getProperty("methodName");
		//通过反射来使用
		Class<?> c = Class.forName(className);//com.itheima_06.Student
		Constructor<?> con = c.getConstructor();
		Object obj = con.newInstance();
		Method m = c.getMethod(methodName);//study
		m.invoke(obj);
	}
}

！？？？？？

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java反射机制

1.反射的概述是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展2.获取Class类对象的三种方式1.类名.class属性2.对象名.getClass()方法3.Class.forName(全类名)方法public class ReflectDemo { public static void main(String[] args) throws ClassNo
复制链接

扫一扫