Java基础之—反射

 1，什么是反射（把java类中的各种成分映射成一个个的Java对象）

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

2，类类（所有类的实例）

如何得到类对象（一切反射相关的代码都从获得类对象开始）三种获取方式：

1 Class.forName(完整类名)(最常用)
2 类名.class
3 对象名.getClass()   （代码展示！）

测试文件Student类：

package com.reflect;

public class Student {
	private String sid;

	private String sname;

	public Integer age;
	
	static{
		System.out.println("加载进jvm中！");
	}

	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("调用Student类私有的构造方法创建一个学生对象");
		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 sname) {
		System.out.println(sname + "你好！我是" + this.sname);
	}

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

package com.reflect;

/**
 * 类类的获取对象的三种方式
 *
 */
public class Demo01 {
	public static void main(String[] args) throws Exception {
		// Class.forName
		Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.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());
		
	}
}

测试结果：

3，反射实例化

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

class.getConstrutor()与class.getDeclaredConstrutor() 获取单个构造方法  

区别：class.getDeclaredConstrutor()包括私有、受保护、默认、公有的方法

如果是有参构造，需要在括号里写上参数类型

调用私有的方法，需打开访问权限：setAccessible(true)

（代码展示！）

package com.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化
 *
 */
public class Demo02 {
	public static void main(String[] args) throws Exception {
		// 获取对象
		Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
		Student stu1 = stucls1.newInstance();// 生成一个实例
		
		// 反射调用有参构造
		// getConstructor与getDeclaredConstructor的区别
		// getDeclaredConstructor可以获得私有的
		Constructor<Student> c1 = stucls1.getConstructor(String.class);
		Student s1 = c1.newInstance("一号");
		
		Constructor<Student> c2 = stucls1.getConstructor(String.class,String.class);
		Student s2 = c2.newInstance("001","小明");
		s2.hello(s2.getSname());
		
		Constructor<Student> c3 = stucls1.getDeclaredConstructor(Integer.class);
		c3.setAccessible(true);// 打开访问权限
		Student s3 = c3.newInstance(3);
	}
}

测试结果：

4，反射动态方法调用
class.getMethod() 获取单个公有方法

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

调用方法：invote（对象名，有参传值）

参数1：类实例，在这里指的是Student类实例
参数2：当前被调用的方法，传递的参数值

（代码展示！）

package com.reflect;

import java.lang.reflect.Method;

/**
 * 反射动态方法调用
 *
 */
public class Demo03 {
	public static void main(String[] args) throws Exception {
		// 获取对象
		Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
		// 生成实例
		Student s1 = stucls1.newInstance();
		// 获取方法
		Method m1 = stucls1.getDeclaredMethod("hello");
		//invoke 参数1：类实例，在这里指的是Student类实例
		//		  参数2：当前被调用的方法，传递的参数值
		System.out.println(m1.invoke(s1));
		
		Method m2 = stucls1.getDeclaredMethod("hello",String.class);
		System.out.println(m2.invoke(s1, "小明"));
		
		Method m3 = stucls1.getDeclaredMethod("add",Integer.class,Integer.class);
		m3.setAccessible(true);
		System.out.println(m3.invoke(s1,10, 20));// 加法方法
		
	}
}

测试结果：

5，反射读写属性

getDeclaredField（获取单个对象）

getDeclaredFields（获取所有对象）

（代码展示！）

package com.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 *
 */
public class Demo04 {
	public static void main(String[] args) throws Exception {
		// 获取对象
		Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
		// 生成实例
		Student s1 = stucls1.newInstance();
		// 获取属性对象
		Field f1 = stucls1.getDeclaredField("sname");
		// 设置权限
		f1.setAccessible(true);
		// 反射写属性
		f1.set(s1, "小明");
		System.out.println(s1.getSname());
		
		// 反射读属性
		System.out.println(f1.get(s1));
		
		// 比较oop与反射读取属性值的方式
		Student stu = new Student("001", "大明");
		stu.age=19;
		
		System.out.println("+++OOP获取+++");
		// oop获取属性值的方式
		System.out.println(stu.getSid());
		System.out.println(stu.getSname());
		System.out.println(stu.age);
		
		System.out.println("+++反射获取+++");
		// 反射获取该对象所有属性值
		Field[] fields = stucls1.getDeclaredFields();
		for (Field fie : fields) {
			fie.setAccessible(true);
			System.out.println(fie.getName()+":"+fie.get(stu));
		}
		
	}
}

测试结果：

OK！到这已经结束了，希望能帮到你！！！