反射

1、反射的定义
反向探知，在程序运行中动态的获取或操作类中的属性就是反射。
1.1、初探反射：
 

获取Class对象的四种方式
Class clazz1 = User.class;
 Class<?> clazz2 = Class.forName("com.tledu.pojo.User");
 Class<? extends User> clazz3 = new User().getClass();
 Class<?> clazz4 = UserTest.class.getClassLoader().loadClass("com.tledu.p
ojo.User");
1.2、获取类的基本信息
 System.out.println(clazz1.getPackage());//获取的包名
 System.out.println(Modifier.toString(clazz1.getModifiers()));//获取类的修饰符
 System.out.println(clazz1.getSimpleName());//获取的类名
 System.out.println(clazz1.getClassLoader());//获取的类加载器
 System.out.println(clazz1.getInterfaces().length);//获取的是这个类实现的接口 
 System.out.println(clazz1.getAnnotations().length);//获取类的注解
 System.out.println(clazz1.getName()); //获取全类名

优缺点
优点：
增加程序的灵活性，避免固有逻辑写死到程序中
代码相对简洁，可以提高程序的复用性
缺点：
相比于直接调用反射有比较大的性能销毁
内部暴露和安全隐患

通过反射获取对象为什么性能销毁较大？
1、native //调用底层
2、checkMemberAccess //安全校验

2、反射的属性操作

public static void main(String[] args) throws Exception {
//获取User的Class对象
 Class clazz = User.class;
 //通过反射的newInstance()方法创建对象
 User user = (User) clazz.newInstance();

//getFields()获取本类及父类中的公共的属性
 Field[] fields = clazz.getFields();
 for (Field field : fields) {
 System.out.println(Modifier.toString(field.getModifiers())+" "+field.ge
tName());
 }

 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
 //getDeclaredFields()获取本类中的所有属性包括私有的
 Field[] fields2 = clazz.getDeclaredFields();
 for (Field field : fields2) {
 System.out.println(Modifier.toString(field.getModifiers())+" "+field.ge
tName());
 }
 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
 //
 Field field = clazz.getDeclaredField("name");
 //对于私有的属性在操作时要开放权限
 field.setAccessible(true);
 field.set(user, "钱枫");

 System.out.println(field.get(user));

 //关于静态属性的赋值
 Field field2 = clazz.getDeclaredField("address");
 field2.set(null, "湖南");
 System.out.println(field2.get(null));

 }

3、反射的方法操作

public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		//获得类对象
		Class<User> clazz=User.class;
		//通过反射创建类对象
		User user=clazz.newInstance();
		
		//getMethods()获取本类及父类的公共方法
		Method[] methods=clazz.getMethods();
		for (Method method : methods) {
		//获取 修饰符  并且将修饰符tostring
			System.out.println(Modifier.toString(method.getModifiers())+""+method.getName());
		}
		
		//getDeclaredMethods();获取本类中所有的方法
		Method[] methods1=clazz.getDeclaredMethods();
		for (Method method : methods1) {
		//获取 修饰符  并且将修饰符tostring
			System.out.println(Modifier.toString(method.getModifiers())+""+method.getName());
		}
		System.out.println("-----------------");
		//普通方法的执行调用
		Method method=clazz.getDeclaredMethod("eat");
		method.setAccessible(true);
		
		method.invoke(user);
		System.out.println("-----------------------------------");
		//静态方法的调用
		Method method2=clazz.getDeclaredMethod("say", String.class );
		method2.invoke(null, "上海话");
		
	}

3、反射的构造器操作

public static void main(String[] args) throws Exception {
		//获取类对象
		Class<User> clazz=User.class;
		//创建类
		User user=(User)clazz.newInstance();
		//获取类中的构造器
		Constructor<?>[] constructors=clazz.getDeclaredConstructors();
		for (Constructor<?> constructor : constructors) {
			System.out.println(constructor.getName());
		}
		System.out.println("-----------------");
		//构造器的调用
		Constructor<User>constructor=clazz.getDeclaredConstructor(String.class,String.class);
		User user2=constructor.newInstance("田园","男");
		System.out.println(user2.getName()+" "+user2.getSex());
	}

4、单例破局

//创建一个私有的静态变量
	private static Singleton singleton;
	//私有化构造函数
	private Singleton(){
		if (singleton!=null) {
			throw new  RuntimeException();
		}
	}
	//创建一个公共的方法并在里面new一个对象 让其只能创建一次
	public static Singleton getlnstance(){
		if (singleton==null) {
			singleton=new Singleton();
		}
		return singleton;
	}

public static void main(String[] args) throws Exception {
		//单例:只能初始化一次,也就只能创建一个实例
	Singleton s1=Singleton.getlnstance();
	Singleton s2=Singleton.getlnstance();
	
	System.out.println(s1);
	System.out.println(s2);
	System.out.println("-----------");
	//获取类对象
	Class<Singleton> clazz=Singleton.class;
	//获取类的加载器
	Constructor<Singleton> constructor=clazz.getDeclaredConstructor();
	constructor.setAccessible(true);
	//通过反射的方法创建类对象
	Singleton s3 = constructor.newInstance();
	Singleton s4 = constructor.newInstance();
	System.out.println(s3);
	System.out.println(s4);
	}