java基础之反射

最新推荐文章于 2021-09-23 10:36:42 发布

豆腐单

最新推荐文章于 2021-09-23 10:36:42 发布

阅读量416

点赞数

分类专栏： java 基础

本文链接：https://blog.csdn.net/xu511739113/article/details/52399344

版权

java 基础专栏收录该内容

13 篇文章 1 订阅

订阅专栏

反射是java中一个非常重要的特性。说起反射我们就要理解“类对象”这个概念。

在java中有一个类，java.lang.Class ，这个类的对象我们就称为“类对象”。这个对象里保存着一些类的信息，例如，类的属性.方法.构造.接口.父类等。也就说，我们只要拿到这个类对象，就可以根据API进行进行一系列操作。

那么为什么这个类对象就能保存这些类的信息呢。我们都知道 java文件是先编译成字节码文件 .class 之后再解释执行的。编译的时候是在本地编译成.class文件，之后由.class文件向JVM加载，这个过程称之为类加载，当JVM进行类加载时，会将这个类的一些信息也加载到JVM，封装到类对象中，存放在方法区。所有当我们使用的时候，只要拿到类对象就可以根据API 拿到类的相关信息进行操作。

获取类对象的三种方式

1）类名.class

2）getClass();//object中的方法

3）Class.forName(ClassName);//

当我们拿到类对象之后就可以调用它的方法获取一些信息

public static void main(String[] args) throws Exception {
		Class<?> c = Class.forName("java.util.ArrayList");
		//获取类名  包括包名
		System.out.println(c.getName());
		//获取类名  不包括包名
		System.out.println(c.getSimpleName());
		//获取父类的 类对象
		System.out.println(c.getSuperclass().getName());
		//获取所实现所有接口的类对象
		System.out.println("=====+_+======");
		for (Class<?> class1 : c.getInterfaces()) {
			System.out.println(class1.getName());
		}
}

我们看一下运行结果

java.util.ArrayList
ArrayList
java.util.AbstractList
=====+_+======
java.util.List
java.util.RandomAccess
java.lang.Cloneable
java.io.Serializable

除了获取一些信息之后，我们还可以操作类的属性和方法，我们先了解一下java反射包下面的两个类

java.lang.reflect.field 和 java.lang.reflect.Method 一个是用来操作属性的一个是用来操作方法的

1.属性

我们看一下Field这个类

<pre name="code" class="java">Class<?> c = Student.class;

Field field = c.getField("name");//获取属性名为name的对象
Field[] fields = c.getFields();//获取本类全部对象
Field declaredField = c.getDeclaredField("name");//获取属性名为name的对象
Field[] declaredFields = c.getDeclaredFields();//获取本类全部对象

获取field有4种方法，getField 和getDeclareField 的区别是范围，getField可以获得本类的公开属性和父类的公开属性，getDeclareFields只能获取本类的属性，但是包括私有属性。这就意味着，可以破坏封装

现在我们有一个学生的类，年龄和姓名都是私有的

public class Student implements Serializable{
	/**  */
	private static final long serialVersionUID = -1971133649684678002L;

	/** 年龄 */
	private Integer age;
	
	/** 反序列化 */
	private transient String name;

我们现在直接用反射来修改私有的属性

public static void main(String[] args) throws Exception {
<span style="white-space:pre">		</span>//拿到类对象
<span style="white-space:pre">		</span>Class<?> c = Student.class;
<span style="white-space:pre">		</span>Student student = new Student();
<span style="white-space:pre">		</span>//拿到 name属性对象
<span style="white-space:pre">		</span>Field declaredField = c.getDeclaredField("name");
<span style="white-space:pre">		</span>//设置允许破快封装
<span style="white-space:pre">		</span>declaredField.setAccessible(true);
<span style="white-space:pre">		</span>declaredField.set(student, "张三");
<span style="white-space:pre">		</span>System.out.println(student.getName());
}

运行结果：

张三

注：declaredField.setAccessible(true); 必须加上，如果不加会抛异常

Exception in thread "main" java.lang.IllegalAccessException: Class demo.com.cn.think.reflect.TestField can not access a member of class demo.com.cn.think.beans.Student with modifiers "private transient"
	at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:109)
	at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:261)
	at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:253)
	at java.lang.reflect.Field.set(Field.java:738)
	at demo.com.cn.think.reflect.TestField.main(TestField.java:17)

2.方法

我们在看一下Method 这个类，拿取它的方式跟Field 类似

Class<Student> c = Student.class;
Method[] methods = c.getMethods();//获取本类和父类所有方法对象
Method method = c.getMethod("test1", new Class[]{});//获取方法名为 test1 ，参数为 <span style="font-family: Arial, Helvetica, sans-serif;">new Class[]{} 的方法对象</span>
Method declaredMethod = c.getDeclaredMethod("test2", new Class[]{});//<span style="font-family: Arial, Helvetica, sans-serif;">获取方法名为 test1 ，参数为 </span><span style="font-family: Arial, Helvetica, sans-serif;">new Class[]{} 的方法对象</span>
Method[] declaredMethods = c.getDeclaredMethods();//获取本类所有方法对象

getMethods和getDeclaredMethods的区别类似于Field ，getMethods可以获取本类和父类所有公开方法，getDeclaredMethods只能获取本类方法，但是不限为public的
主要说一下c.getMethod("test1", new Class[]{}); 获取指定方法，

 @CallerSensitive
    public Method getMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        // be very careful not to change the stack depth of this
        // checkMemberAccess call for security reasons
        // see java.lang.SecurityManager.checkMemberAccess
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        Method method = getMethod0(name, parameterTypes);
        if (method == null) {
            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
        }
        return method;
    }

它的第一个参数是方法名，第二个参数为类对象数组，这个数组元素存放的是参数类型的类对象。主要为了区分重载。

拿到方法对象之后，我们就开始直接执行方法，我们在student增加两个方法

<span style="white-space:pre">	</span>private Date test1(){
		System.out.println("test1~~~~~");
		return new Date();
	}
	private Date test1(String t1,String t2){
		System.out.println("test1~~~~~"+t1+"+_+"+t2);
		return new Date();
	}

public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
		Class<Student> c = Student.class;
		Student student = c.newInstance();
		Method declaredMethod = c.getDeclaredMethod("test1", new Class[]{});
		declaredMethod.setAccessible(true);
		Object invoke = declaredMethod.invoke(student, new Object[]{});
		System.out.println(invoke);
		Method declaredMethod2 = c.getDeclaredMethod("test1",new Class[]{String.class,String.class});
		declaredMethod2.setAccessible(true);
		Object invoke2 = declaredMethod2.invoke(student, new Object[]{"hehe","lala"});
		System.out.println(invoke2);
	}

执行结果

test1~~~~~
Thu Sep 01 17:47:06 CST 2016
test1~~~~~hehe+_+lala
Thu Sep 01 17:47:06 CST 2016

3.构造

最后如果我们拿到了类对象，怎样创建一个实例呢，我们先看一下java.lang.reflect.Constructor 这个类。我们给student增加一个有参构造

public Student(Integer age, String name) {
		super();
		this.age = age;
		this.name = name;
}

public static void main(String[] args) throws Exception{
		//拿取 Student的类对象
		Class<Student> c = Student.class;
		//拿取构造方法对象
		Constructor<Student> constructor = c.getDeclaredConstructor(new Class[]{Integer.class,String.class});
		//创建对象
		Student student = constructor.newInstance(new Object[]{17,"zhan3"});
		System.out.println(student.getAge()+"____+_+_____"+student.getName());
}

运行结果

17____+_+_____zhan3

我发现拿取构造方法对象也是有两种方法

c.getDeclaredConstructor(parameterTypes);
c.getConstructor(parameterTypes);

看注释理解应该是跟上面的类似，但当我试着将student的无参构造改为private 的时候，用getDeclaredConstructor 并不能创建对象，抛异常

Exception in thread "main" java.lang.IllegalAccessException: Class demo.com.cn.think.reflect.TestConstructor can not access a member of class demo.com.cn.think.beans.Student with modifiers "private"
	at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:109)
	at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:261)
	at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:253)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:517)
	at demo.com.cn.think.reflect.TestConstructor.main(TestConstructor.java:15)

希望有了解的能交流一下。