java反射

下面是思维导图

 

下面是测试Student类

package com.wmy.test;

public class Student {
	private String sid;

	private String sname;

	public Integer age;

	static {
		System.out.println("静态加载");
	}

	public Student() {
		super();
		System.out.println("无参构造方法");
	}

	public Student(String sid) {
		super();
		this.sid = sid;
		System.out.println("有参构造方法");
	}

	public Student(String sid, String sname) {
		super();
		this.sid = sid;
		this.sname = sname;
		System.out.println("多个参数方法");
	}

	@SuppressWarnings("unused")
	private Student(Integer age) {
		System.out.println("私有构造");
		this.age = age;
	}

	public String getSid() {
		return sid;
	}

	public void setSid(String sid) {
		this.sid = sid;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public void hello() {
		System.out.println("无参方法" + this.sname);
	}

	public void hello(String name) {
		System.out.println(name + "有参方法" + this.sname);
	}

	@SuppressWarnings("unused")
	private Integer add(Integer a, Integer b) {
		return new Integer(a.intValue() + b.intValue());
	}
}

 一：什么是反射

 反射是java语言的一种机制,利用反射机制动态的实例化对象(构造函数)、读写属性、调用方法。

 二：获取类类的三种方式

package com.wmy.test;

/**
 * 类类的获取对象的三种方式
 *
 */
public class Demo {
	public static void main(String[] args) throws Exception {
		// Class.forName
		Class<Student> stucls1 = (Class<Student>) Class.forName("com.wmy.test.Student");
		// 通用查询 类名.class
		Class stucls2 = Student.class;
		// 通用增删改 对象名.getClass()
		Class stuclz3 = new Student().getClass();
		// 获取全限定名
		System.out.println(stucls2.getName());
		// 获取包名
		System.out.println(stucls2.getSimpleName());
		// 获取类名
		System.out.println(stucls2.getPackage());

	}
}

 三：反射实例化

class.getDeclaredConstructor（获取单个构造器包括（私有、受保护、默认、公有））

class.getConstructor(获取有参构造器)

class.newInstance(反射实例化对象)

下面是代码

package com.wmy.test;

import java.lang.reflect.Constructor;

/**
 * 反射实例化 *:代表重点
 * 
 * @author T440s
 *
 */

public class Demo1 {
	public static void main(String[] args) throws Exception {
		Class<Student> stuClz1 = (Class<Student>) Class.forName("com.wmy.test.Student");
		// *调用newInstance方法新建一个对象
		Student stu1 = (Student) stuClz1.newInstance();
		// 调用Student中的hello();
		stu1.hello();

		// *反射调用有参构造器
		Constructor<Student> c = stuClz1.getConstructor(String.class);
		Student s1 = c.newInstance("001");
		s1.hello();

		// 调用Student中的private方法
		// getDeclaredConstructor（获取单个构造器包括（私有、受保护、默认、公有））
		Constructor<Student> c1 = stuClz1.getDeclaredConstructor(Integer.class);
		// 提供访问权限
		c1.setAccessible(true);
		Student s2 = c1.newInstance(26);
	}
}

 四：反射动态方法调用

class.getMethod() 获取单个公有方法

class.getDeclaredMethod() 获取单个方法 （包括私有、受保护、默认、公有)

package com.wmy.test;

import java.lang.reflect.Method;

/**
 * 反射动态方法的调用 getMethod（获取单个公有方法） getDeclaredMethod（获取单个方法(包括私有、受保护、默认、公有)）
 * 
 * @author T440s
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		Class<Student> stuClz1 = (Class<Student>) Class.forName("com.wmy.test.Student");
		Student s = stuClz1.newInstance();
		// 调用公有的并且无参的方法getDeclaredMethod(a,b)a代表方法名 b代表传的参
		Method m1 = stuClz1.getDeclaredMethod("hello");
		// invoke参数1：类实例 在这里指的是Student类实例
		// 参数2:当前被调用的方法，传递的参数值
		// invoke的返回值，就是被反射调用的方法的返回值，如果被调用的方法是void，那么返回null
		System.out.println(m1.invoke(s));

		// 调用Student中的有参方法
		Method m2 = stuClz1.getDeclaredMethod("hello", String.class);
		System.out.println(m2.invoke(s, "张三"));

		// 调用Student中的私有的有参方法
		Method m3 = stuClz1.getDeclaredMethod("add", Integer.class, Integer.class);
		m3.setAccessible(true);
		System.out.println(m3.invoke(s, 10, 5));
	}
}

五：反射读写属性

getDeclaredField（获取单个对象）

getDeclaredFields（获取所有对象）

package com.wmy.test;

import java.lang.reflect.Field;

/**
 * 反射读取属性
 * 
 * @author T440s
 *
 */
public class Demo3 {
	public static void main(String[] args) throws Exception {
		Class<Student> stuClz1 = (Class<Student>) Class.forName("com.wmy.test.Student");
		Student s = stuClz1.newInstance();
		// 获取Student类中的属性
		Field f = stuClz1.getDeclaredField("sname");
		f.setAccessible(true);
		// 反射写属性
		f.set(s, "张三");
		System.out.println(s.getSname());
		// 反射读属性
		System.out.println(f.get(s));

		// 比较OP与反射读取属性值的方式
		// OP
		Student stu = new Student("s002", "张三");
		stu.age = 22;
		System.out.println(stu.getSid());
		System.out.println(stu.getSname());
		System.out.println(stu.age);
		// 反射
		Field[] f1 = stuClz1.getDeclaredFields();
		for (Field field : f1) {
			field.setAccessible(true);
			System.out.println(field.getName() + ":" + field.get(stu));
		}
	}

}