简单原理介绍java反射（2）

public class Person {

	private String name;
	private int age;

	public Person(String name,int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public   Person(){}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	public void show()
	{
		System.out.println("show");
	}

	public void fun(String str)
	{
		System.out.println(str);
	}

	public static void function()
	{
		System.out.println("static");
	}

}

public class Demo1 {

	/**
	 * 反射：动态获取字节码文件对象(Person.class)，并对其成员进行运行
	 *
	 * 动态获取字节码文件对象的方式：
	 * 1：任何一个对象都是由字节码文件对象创建的，所以任何一个对象都可以得到自己的字节码文件对象
	 *   那么这个功能应该定义在Object中，所以使用 getClass()
	 *   需要先new对象
	 *
	 * 2:每种数据类型都有一个 静态的class 属性,通过该属性可以得到字节码文件对象
	 *   不需要new对象，但是需要Person类存在
	 *
	 * 3:Class类提供了一个静态的forName(String str)方法
	 *   只需要提供字符串形式的包名+类名
	 * @throws ClassNotFoundException
	 */
	public static void main(String[] args) throws ClassNotFoundException {

          getClaz();
          getClaz2();
          getClaz3();
	}
	//Class类提供了一个静态的forName
	public static void getClaz3() throws ClassNotFoundException
	{
		Class<?> claz1 = Class.forName("com.qianfeng.reflect.Person");

		Class<?> claz2 = Class.forName("com.qianfeng.reflect.Person");

		System.out.println(claz1==claz2);
	}

	//通过静态属性class获取字节码文件对象
	public static void getClaz2()
	{
		Class<Person> claz1 = Person.class;

		Class<Person> claz2 = Person.class;

		System.out.println(claz1==claz2);
	}

	//1:使用Object中的 getClass()获取字节码文件对象
	public static void getClaz()
	{
//		Person person1 = new Person();//先加载Person.class到方法区
//		Class<? extends Person> claz1 = person1.getClass();//得到了 Person.class
//
//		Person person2 = new Person();
//		Class<? extends Person> claz2 = person2.getClass();//得到了 Person.class
//
//		System.out.println(claz1==claz2);//true

	}

}

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {

	/**
	 * 动态获取字节码文件对象，并创建对象
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 * @throws ClassNotFoundException
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 */
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {

		createObj1();
		createObj2();
	}

	//使用带参数的构造方法创建对象
	public static void createObj2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{   //Person person = new Person("小红",20);
		//获取字节码文件对象---Person.class
		Class<?> claz = Class.forName("com.qianfeng.reflect.Person");

		//得到构造方法所属的Constructor类型的对象
		Constructor<?> constructor = claz.getConstructor(String.class,int.class);

		//使用构造方法创建对象--使用Constructor提供的创建对象的功能
		Person person =(Person)constructor.newInstance("小红",20);

		System.out.println(person);

	}

	//当空参的构造方法不存在时，会发生InstantiationException
	//当构造方法的权限过低时，会发生IllegalAccessException
	public static void createObj1() throws ClassNotFoundException, InstantiationException, IllegalAccessException
	{
		//Person person = new Person();
		//获取字节码文件对象---Person.class
		Class<?> claz = Class.forName("com.qianfeng.reflect.Person");

		//使用Class提供的newInstance()方法创建Person类型的对象
		Object obj = claz.newInstance();//使用空参的构造方法创建对象

		Person person = (Person)obj;

		System.out.println(person);
	}

}

import java.lang.reflect.Field;

public class Demo3 {

	/**
	 * 动态创建对象并给属性赋值
	 * @throws ClassNotFoundException
	 * @throws SecurityException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {

		//Person person = new Person();
		//person.setName("小红");

		//获取字节码文件对象---Person.class
	     Class<?> claz = Class.forName("com.qianfeng.reflect.Person");

	     //得到属性name所属的 Field类型的对象
	     //Field field = claz.getField("name");//只能获取权限是public 的属性
	     //System.out.println(field);//NoSuchFieldException

	     Field field = claz.getDeclaredField("name");

	     //因为name是非静态属性，所以必须通过对象访问，所以先创建对象
	     Object obj = claz.newInstance();

	     //设置name属性为可访问的
	     field.setAccessible(true);// 该方法是从父类中继承的

	     //使用Field类提供的赋值功能，给属性赋值
	     field.set(obj, "小红");

	     System.out.println(obj);

	}

}

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {

	/**
	 * 动态创建对象，并调用方法
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 * @throws ClassNotFoundException
	 */
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

		method1();
		method2();
		method3();
	}
	//调用静态方法
	public static void method3() throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
		//获取字节码文件对象---Person.class
	     Class<?> claz = Class.forName("com.qianfeng.reflect.Person");

	     ///获取被调用的方法所属的 Method类型的对象
	     Method method = claz.getMethod("function", null);

	     //执行方法
	     method.invoke(null, null);

	}

	//调用带参的构造方法
	public static void method2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
		//获取字节码文件对象---Person.class
	     Class<?> claz = Class.forName("com.qianfeng.reflect.Person");

	   //获取被调用的方法所属的 Method类型的对象
	     Method method = claz.getMethod("fun", String.class);

	     //fun()属于非静态方式，需要对象去调用
	     Object obj = claz.newInstance();

	     //执行方法
	     method.invoke(obj, "hello");
	}

	//调用无参的构造方法
	public static void method1() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
		// Person person = new Person();person.show();
		//获取字节码文件对象---Person.class
	     Class<?> claz = Class.forName("com.qianfeng.reflect.Person");

	     //获取被调用的方法所属的 Method类型的对象
	     Method method = claz.getMethod("show", null);

	     //show()属于非静态方式，需要对象去调用
	     Object obj = claz.newInstance();

	     //执行方法
	     method.invoke(obj, null);

	}

}

版权声明：本文为博主原创文章，未经博主允许不得转载。