今天学习反射

应用场景

1  jdbc封装

2 SpringIOC

3 jdbcTemplate

4 Mybaties等

个人知识点

两个==和三个===的区别
不同类型间比较，==之比较“转化成同一类型后的值”看“值”是否相等，===如果类型不同，其结果就是不等

2）同类型比较，直接进行“值”比较，两者结果一样

 getPackage()  //获取的包名  package com.pojo
getModifiers()//获取User类前的修饰  1即代表public
Modifier.toString(clazz1.getModifiers())// 这样可以将1转化为对应的修饰符 public
getSimpleName()// 获取的类名 User
getAnnotations()//获取类的注解
getName()//获取全类名  com.pojo.User

//getFields()获取本类及父类中的公共的属性 
        Field[] fields = clazz.getFields();

//getDeclaredFields()获取本类中的所有属性包括私有的

field.setAccessible(true);//对于私有的属性在操作时要开放权限

getMethods()获取本类及父类的公共的方法

//getDeclaredMethods()获取本类中所有的方法

Method[] methods2 = clazz.getDeclaredMethods();

//获取类中的构造器
                Constructor<?>[] constructors = clazz.getDeclaredConstructors();
                for (Constructor<?> constructor : constructors) {
                    System.out.println(constructor.getName());

//构造器的调用
                Constructor<User> constructor = clazz.getDeclaredConstructor(String.class,String.class);
                User user2 = constructor.newInstance("田源","男");//这里可以输入多个
                System.out.println(user2.getName()+" "+user2.getSex());    //    田源 男
                

反射

定义

反向探知，在程序运行中动态的获取或操作类中的属性就是反射

1获取Class对象的四种方式

//获取Class对象的四种方式
		Class clazz1=User.class;
		Class<?> class2=Class.forName("com.pojo.User");
		Class<?extends User>clazz3=new User().getClass();
		Class<?>clazz4=UserTest.class.getClassLoader().loadClass("com.pojo.User");

2获取类的基本信息

System.out.println(clazz1.getPackage());//获取的包名  package com.pojo
		System.out.println(clazz1.getModifiers());//获取User类前的修饰  1即代表public
		System.out.println(Modifier.toString(clazz1.getModifiers()));//  这样可以将1转化为对应的修饰符 public
		
		System.out.println(clazz1.getSimpleName());// 获取的类名 User
		System.out.println(clazz1.getInterfaces().length);//获取的是这个类实现的接口
		System.out.println(clazz1.getAnnotations().length);//获取类的注解
		System.out.println(clazz1.getName()); //获取全类名  com.pojo.User

优缺点

优点：

增加程序的灵活性，避免固有逻辑写死到程序中

代码相对简洁，提高代码的复用性

缺点：

相比于直接调用，反射有较大的性能销毁，就是比较占用性能 

原因；1  native//调用底层

           2  checkMemberAccess //安全校验

内部暴露和安全隐患

反射的属性操作

package com.pojo;

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

public class Demo03 {

	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.getName());
			/*
			  public static address
              public idCard
			 */
		}
		//getDeclaredFields()获取本类中的所有属性包括私有的
		Field[] fields2 = clazz.getDeclaredFields();
			for (Field field : fields2) {
					System.out.println(Modifier.toString(field.getModifiers())+" "+field.getName());
				/*
				    private name
					private sex
                    public static address
				 */
			}
			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));
		

	}

}

反射的方法操作

package com.pojo;

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

public class Demo04 {

	public static void main(String[] args) throws Exception {
		Class<User> clazz = User.class;
		User user = (User)clazz.newInstance();
		
		//getMethods()获取本类及父类的公共的方法   一大堆，因为包含object里的方法
//		Method[] methods = clazz.getMethods();
//			for (Method method : methods) {
//					System.out.println(Modifier.toString(method.getModifiers())+" "+method.getName());
//				}
			
		//getDeclaredMethods()获取本类中所有的方法
		Method[] methods2 = clazz.getDeclaredMethods();
		for (Method method : methods2) {
				System.out.println(Modifier.toString(method.getModifiers())+" "+method.getName());
			/*
			 * public static setAddress
			 * public static getAddress
			 * public setName
			 * public getName
			 * public setSex
			 * public getSex
			 * private eat
			 * public static say
			 * 
			 * */
		}
		System.out.println("-----------------");
		//普通方法的调用执行
		Method method = clazz.getDeclaredMethod("eat");
		method.setAccessible(true);
		method.invoke(user);//-----eat--
		
		//静态方法的调用执行
		Method method2 = clazz.getDeclaredMethod("say", String.class);
		method2.invoke(null, "上海话"); //上海话
		
	}

}

反射的构造器操作

package com.pojo;

import java.lang.reflect.Constructor;

public class Demo05 {

	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());
				/*
				 com.pojo.User
                 com.pojo.User
                 com.pojo.User
				 * */
				}
		//构造器的调用
				Constructor<User> constructor = clazz.getDeclaredConstructor(String.class,String.class);
				User user2 = constructor.newInstance("田源","男");//这里可以输入多个
				System.out.println(user2.getName()+" "+user2.getSex());	//	田源 男
				

	}

}

单例破局

package com.pojo2;

public class Singleton {
    private static Singleton s;
	
	private Singleton() {
		if(s != null) {
			throw new RuntimeException("创建过了");
		}
	}
	
	
	public static Singleton getInstance() {
		if(s == null) {
			s = new Singleton();
		}
		return s;
	}

}

package com.pojo2;

import java.lang.reflect.Constructor;

public class SingletonTest {

	public static void main(String[] args) throws Exception {
		//单例：只能初始化一次，也就是只能创建一个实例
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		System.out.println(s1);
		System.out.println(s2);    
		/*
		 com.pojo2.Singleton@15db9742
         com.pojo2.Singleton@15db9742
		 * */
		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);

	}
}