内部类的反射实验

package reflect;

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


public class ReflectTest {
	{
		System.out.println("R this："+this);
	}
	 static class User{
//		public User() {
//			super();
//		}
//		public User(String name){
//			this.name=name;
//		}
		 {
			 System.out.println("user this:"+this);
		 }
		private String name;
		
		public void setName(String name) {
			this.name=name;
		}
		public String getNmae() {
			return this.name;
		}
		public String printUserName() {
			System.out.println(this.name);
			return this.name;
		}
	}
	 
	  class User2{
//		  final ReflectTest this$0;
//			public User2(ReflectTest test) {
//				super();
//				this$0=test;
//			}
//			public User(String name){
//				this.name=name;
//			}
			private String name;
			
			public void setName(String name) {
				this.name=name;
			}
			public String getNmae() {
				return this.name;
			}
			public String printUserName() {
				System.out.println(this.name);
				return this.name;
			}
		}
	 public void setName(String name) {
		 User user=new User();
		 user.name=name;
		 System.out.println("成功调用User私有属性:"+user.name);
	 }
	public static void main(String[] args)throws Exception{
		ReflectTest re=new ReflectTest();
		re.setName("来了");
		//static内部类正常访问
		User user2=new User();
		user2.name="哈哈";//内部类的私有属性竟然变成了在外部类可以随意调用.但是换到其他类去调用的时候只能看到公有方法。也就是说内部类对外部类来说，属性都是公有的
		//为方便记忆 我称之为 暴政机制
		user2.printUserName();
		//static内部类反射执行方法
		User user=User.class.newInstance();
		user.name="张三";
		user.printUserName();
		//static内部类反射执行方法2
		//static
		Class<?> c= Class.forName("reflect.ReflectTest$User");
		Object obj2=c.newInstance();
		Method sm=obj2.getClass().getMethod("setName", String.class);
		sm.invoke(obj2, "反射成功");
		Method m=obj2.getClass().getMethod("printUserName");//
		m.invoke(obj2);
		System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++");
		//非static调用内部类
		ReflectTest r=new ReflectTest();
		User2 u2=r.new User2();//实例之后再初始化User2
		u2.name="滚";
		u2.printUserName();
		//非static使用反射
		Class clazz=ReflectTest.class;
		Class innerClass[]=clazz.getDeclaredClasses();//内部类
		for(Class i:innerClass) {
			System.out.println("内部类"+Modifier.toString(i.getModifiers())+" "+i.getName());
			if(Modifier.toString(i.getModifiers()).equals("static")) {//静态类通过反射的初始化
				Object staticUser=i.newInstance();
				Field f=i.getDeclaredField("name");
				f.setAccessible(true);
				f.set(staticUser, "你好啊,日了狗");
				Method mtd=i.getMethod("printUserName");
				mtd.invoke(staticUser);
			}else {//实例类的初始化
				Constructor cons=i.getDeclaredConstructor(clazz);//从javap的class文件中可以看到 内部类有个默认构造，传了一个外部类
				cons.setAccessible(true);
				ReflectTest rt=(ReflectTest)clazz.newInstance();//实例化外部对象
				Object inner=cons.newInstance(rt);
				Field fe=inner.getClass().getDeclaredField("name");
				fe.setAccessible(true);//禁用检查，就是那些属性不再考虑。
				fe.set(inner, "你不好吧");
				System.out.println(fe.get(inner));
			}
		}
		
//		Object user=obj.getClass().newInstance();
//		user.setName("张三");
//		user.printUserName();
	}

}