java_反射（通过反射可以调用类的私有结构）

Person类

package com.java.domain;

public class Person {
	private String name;
	public int age;
	
	
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	private Person(String name) {
		this.name = name;
	}
	
	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("老大");
	}	
	
	private String showNation(String nation) {
		System.out.println("我的国籍是："+nation);
		return nation;
	}	
}

1、test类

package com.java.Reflect;

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

import org.junit.Test;

import com.java.domain.Person;


/*
 * java.lang.Class:代表一个类
 * java.lang.reflect.Method：代表类的 方法
 * java.lang.reflect.Filed:代表类的成员变量
 * java.lang.reflect.Constructor:代表类的构造器
 * ....
 */

public class Reflect01 {
	//反射之前，对person的操作
	@Test
	public void test1(){
		//1、创建Person类的对象
			Person person = new Person("tom",12);
		//2、通过对象，调用其内部的属性、方法
			//调属性
			person.age=10;
			System.out.println(person.toString());
			//调方法
			person.show();
			
			//在Person类外部，不可以通过Person类的对象调用其私有的结构
			//比如name、showNation()以及私有的构造器
	}
	
	
	
	//反射之后，对person的操作
	@Test
	public void test2() throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException{
		Class clazz = Person.class;
		//1、通过反射，创建Person类的对象
			Constructor cons = clazz.getConstructor(String.class,int.class);
			//调用obj的方法会发现，此时调用的obj就是Person
			Object obj = cons.newInstance("tom",120);
			System.out.println(obj.toString());
		//2、通过反射，调用对象指定的属性、方法
			//调属性
			Field age = clazz.getDeclaredField("age");
			age.set(obj,10);
			System.out.println(obj.toString());
			//调方法,因为Person里面show方法是空参数，所以这里只需要填写方法名
			Method show = clazz.getDeclaredMethod("show");
			show.invoke(obj);
			System.out.println("*******************************************************************");
			
			
			
		//通过反射，可以调用Person类的私有结构。比如：私有的构造器、方法、属性
			//调用私有构造器
			Constructor cons1 = clazz.getDeclaredConstructor(String.class);
			cons1.setAccessible(true);
			Person p1 = (Person) cons1.newInstance("Jerry");
			System.out.println(p1);
			//调用私有的属性
			Field name = clazz.getDeclaredField("name");
			name.setAccessible(true);
			name.set(p1, "HanMeimei");
			System.out.println(p1);
			//调用私有的方法
			Method showNation = clazz.getDeclaredMethod("showNation", String.class);
			showNation.setAccessible(true);
			String nation = (String) showNation.invoke(p1, "中国"); //相对于String nation=p1.showNation("中国")
			System.out.println(nation);
	}
}

疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
-----------建议直接new的方式。那么什么时候使用反射的方式勒？如果一开始编译的时候就不能确定下来我们要new谁，那么我们就可以使用反射，因为反射有一个特征——动态性（比如说代码运行期间，我不知道到底该造哪个类的对象，因为我不知道你到底是想注册还是想做登录，你发过来是什么我就造相关类的对象去调相关类的方法，这就叫动态性）

疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
-----------不矛盾。当封装中分别写了一个公有与私有的方法，那么就是想告诉你需要的时候可以拿我们这些公共的去用，私有的你正常情况下可能用不着，但是非要使用私有的也可以，只是不太建议。