关于Java反射的知识总结

最新推荐文章于 2024-04-20 21:34:05 发布

IT技术站

最新推荐文章于 2024-04-20 21:34:05 发布

阅读量117

点赞数

分类专栏： java 文章标签：反射 java class 类

本文链接：https://blog.csdn.net/weixin_42174239/article/details/104562107

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

反射

1.获取Class对象的方法

public class Test {
	public static void main(String[] args) {
		//通过类获取Class对象
		Class clazz1 = Student.class;
		//通过对象获取Class对象
		Student s = new Student(18, 0);
		Class clazz2 = s.getClass();
		//通过forName静态方法
		try {
			Class clazz3 = Class.forName("cn.itlaobing.ref.Student");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

2.获取构造器

方法	描述
Connstructor getConstructor(Class<?>…paramterTypes)	获取Class对象对应类的带指定参数列表的public构造器
Connstructor<?> getContructors()	获取Class对象对应类的所有public构造器
Connstructor getDeclaredConstructor (Class<?>…paramterTypes)	获取Class对象对应类的带指定参数列表的构造器，与访问修饰符无关
Connstructor<?> getDeclaredConstructors()	获取Class对象对应类的所有构造器，与访问修饰符无关

2.1示例

public class Test2 {
	
	public static void main(String[] args) throws NoSuchMethodException, SecurityException {
		
		Class<Student> clazz = Student.class;
		
		//获取public修饰的构造方法
		Constructor[] c1 = clazz.getConstructors();
		
//		for (Constructor constructor : c1) {
//			System.out.println(constructor);
//		}
		//获取所有构造方法,与访问修饰符无关
		Constructor[] c2 = clazz.getDeclaredConstructors();
//		for (Constructor constructor : c2) {
//			System.out.println(constructor);
//		}
		//获取指定的public修饰的构造方法
		Constructor c = clazz.getConstructor(int.class,double.class);
		System.out.println(c);
		
//		Constructor tempc = clazz.getConstructor(double.class);
		
		//获取指定参数的构造器，与访问修饰符无关
		Constructor construct1 = clazz.getDeclaredConstructor(double.class);
		System.out.println(construct1);
		
		Constructor construct2 = clazz.getDeclaredConstructor();
		
		System.out.println(construct2);
 	}
	
}

3.获取成员方法

方法	描述
Method getMethod(String name,Class<?>…paramterTypes)	获取指定名称和参数类型class对象的public修饰方法
Method[] getMethods()	获取所有public修饰的成员方法以及继承的方法，包括静态方法
Method getDeclaredMethod(String name,Class<?>…paramterTypes)	获取指定名称和参数类型class对象的方法，与访问修饰符无关
Method[] getDeclaredMethods()	获取自身声明的所有成员方法，与访问修饰符无关

3.1示例

public class MethodTest {
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//获取Class对象
		Student s = new Student(0);
		Class clazz = s.getClass();
		//获取public修饰的方法包含父类public修饰的方法
		Method[] methods = clazz.getMethods();
		
//		for (Method method : methods) {
//			System.out.println(method);
//		}
		//获取自身声明的所有方法，与访问修饰符无关
		Method[] methods2 = clazz.getDeclaredMethods();
		
//		for (Method method : methods2) {
//			System.out.println(method);
//		}
		//获取指定参数的public修饰的成员方法
//		Method method = clazz.getMethod("newObject");
//		System.out.println(method);
		//获取指定参数的自身声明的方法，与访问修饰符无关
		Method method2 = clazz.getDeclaredMethod("newObject", int.class);
//		System.out.println(method2);
//		method2.setAccessible(true);
//		method2.invoke(s,2);
		Method method3 = clazz.getDeclaredMethod("makeMoney");
		method3.invoke(s);
		Method method4 = clazz.getDeclaredMethod("sleep",String.class);
		method4.invoke(null,"蔡老师");
	}
}

4.获取成员变量

方法	描述
Field getField(String name)	获取指定名称的public修饰的成员变量
Field[] getFields()	获取所有的public修饰的成员变量,包括从父类继承的成员变量
Field getDeclaredField(String name)	获取指定名称的成员变量，与访问权限无关
Field[] getDeclaredFields()	获取所有的成员变量，与访问修饰符无关

public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
		Son s = new Son();
		Class clazz = s.getClass();
		//获取自身和父类public修饰的成员变量
		Field[] fields = clazz.getFields();
//		for (Field field : fields) {
//			System.out.println(field);
//		}
		//获取自身声明的成员变量，与访问修饰符无关
		Field[] fields2 = clazz.getDeclaredFields();
//		for (Field field : fields2) {
//			System.out.println(field);
//		}
		//根据指定名称获取自身和父类public修饰的成员变量属性
		Field f1 = clazz.getField("age");
		f1.setInt(s, 10);
		System.out.println(s.age);
		
		Field f3 = clazz.getField("name");
		f3.set(s, "张三");
		System.out.println(s.name);
		//根据指定名称获取属性，与访问修饰符无关
		Field f2 = clazz.getDeclaredField("width");
		System.out.println(f2);
		f2.setAccessible(true);
		f2.setInt(s, 100);
		System.out.println(s.getWidth());
		
	}

5.获取注解

6.Method对象方法

方法	描述
invoke(Object obj,Object…obj)	调用对象方法
setAccessible(boolean flag)	设置私有方法可访问

7.实例化对象

方法	描述
clazz.newInstance()	只能调用默认无参构造方法
Constructor.newInstance(Object…obj)	调用对应的构造方法

7.1示例

public class NewInstance {
	
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		
		Class clazz = Class.forName("cn.itlaobing.ref2.Student");
		Constructor c = clazz.getDeclaredConstructor(int.class);
		c.setAccessible(true);
		//利用构造方法newInstanc方法
		Student s = (Student)c.newInstance(18);
		
		System.out.println(s.getAge());
		//利用class对象newInstance,调用默认无参构造
//		Student s2 = (Student) clazz.newInstance();
//		System.out.println(s2.getAge());
	}
}

8.作业实例

1.使用反射创建FileInputStream以及BufferedInputStream读取某个文件，并利用反射创建
FileOutputStream和BufferedOutputStream对象，将文件写入到E://File（如果使用File对象）
也必须使用反射创建对象

package com.itlaobing.z0830;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

@SuppressWarnings("all")
public class ReflectFileTest {

	public static void main(String[] args) {
		// 获取FileInputStream类信息
		Class clazz1 = FileInputStream.class;
		// 获取BufferedInputStream类信息
		Class clazz2 = BufferedInputStream.class;
		// 获取FileOutputStream类信息
		Class clazz3 = FileOutputStream.class;
		// 获取BufferedOutputStream类信息
		Class clazz4 = BufferedOutputStream.class;

		FileInputStream fis = null;
		BufferedInputStream bis = null;
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		Method bisClose = null;
		Method bosClose = null;
		try {
			// 获取FileInputStream类构造方法
			Constructor constructor = clazz1.getDeclaredConstructor(String.class);

			// 通过构造器.newInstance创建对象
			fis = (FileInputStream) constructor.newInstance("D:/1/Menu.java");

			// 获取BufferedInputStream类构造方法
			Constructor constructor2 = clazz2.getDeclaredConstructor(InputStream.class);

			// 通过构造器.newInstance创建对象
			bis = (BufferedInputStream) constructor2.newInstance(fis);

			// 获取BufferedInputStream的read()方法
			// Method read = clazz2.getMethod("read");

			// 获取BufferedInputStream的read(byte[] b)方法(调用的FileinputStream的read(byte[] b))
			Method read = clazz2.getMethod("read", byte[].class);

			// 获取BufferedInputStream的close()方法
			bisClose = clazz2.getDeclaredMethod("close");

			// 获取FileOutputStream类构造方法
			Constructor constructor3 = clazz3.getDeclaredConstructor(String.class);

			// 通过构造器.newInstance创建对象
			fos = (FileOutputStream) constructor3.newInstance("D:/1/File/Menu.java");

			// 获取BufferedOutputStream类构造方法
			Constructor constructor4 = clazz4.getDeclaredConstructor(OutputStream.class);

			// 通过构造器.newInstance创建对象
			bos = (BufferedOutputStream) constructor4.newInstance(fos);

			// 获取BufferedOutputStream的write()方法
			// Method write = clazz4.getMethod("write", int.class);

			// 获取BufferedOutputStream的write(byte[] b)方法(调用的FileOutputStream的write(byte[] b))
			Method write = clazz4.getMethod("write", byte[].class);

			// 获取BufferedOutputStream的close()方法(其实获得的是父类FilterOutputStream的close()方法)
			bosClose = clazz4.getMethod("close");

			// 读写文件
			int i = 0;
			// 利用read.invoke获得read()方法,利用write.invoke获得write(int i)方法
			// while ((i = (int) read.invoke(bis)) > -1) {
			// write.invoke(bos, i);
			// }

			byte[] b = new byte[1024];
			// 利用read.invoke获得read(byte[] b )方法,利用write.invoke获得write(byte[] b)方法
			while ((i = (int) read.invoke(bis, b)) > -1) {
				write.invoke(bos, b);
			}
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		} finally {
			try {
				bisClose.invoke(bis);
				bosClose.invoke(bos);
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
		}
	}
}

IT技术站

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于Java反射的知识总结

反射1.获取Class对象的方法public class Test { public static void main(String[] args) { //通过类获取Class对象 Class clazz1 = Student.class; //通过对象获取Class对象 Student s = new Student(18, 0); Class clazz2 = s....
复制链接

扫一扫