创建运行时类的对象

• 通过反射获取运行时类的完整结构

  Field、Method、Constructor、Superclass、Interface、Annotation

  • 实现的全部接口
  • 所继承的父类
  • 全部的构造器
  • 全部的方法
  • 全部的Field
  • 注解

  public class Test {
  	public static void main(String[] args) throws Exception {
  		//通过反射获取类的Class对象
  		Class c1 = Class.forName("com.java.test.User");
          
          //获得类的名字
          System.out.println(c1.getName()); //获得包名 + 类名
          System.out.println(c1.getSimpleName()); //获得类名
          
          //获得类的属性
          Field[] fields = c1.getFields(); //只能找到public属性
          
          fields = c1.getDeclaredFields(); //能找到所有的属性
          for(Field field : fields){
              System.out.println(field);
          }
          
          //获得指定属性的值
          Field name = c1.getDeclaredField("name");
          System.out.println(name);
          
          //获得类的方法
          Method[] methods = c1.getMethods(); //获得本类及其父类的全部public方法
          for(Method method : methods){
              System.out.println("正常的："+method);
          }
          methods = c1.getDeclaredMethods(); //获得本类的所有方法
          for(Method method : methods){
              System.out.println("全部的："+method);
          }
          
          //获得指定方法
          Method getName = c1.getMethod("getName",null);
          Method setName = c1.getMethod("setName",String.class);
          System.out.println(getName);
          System.out.println(setName);
          
          //获得构造器
          Constructor[] constructors = c1.getConstructors();
          for (Constructor constructor : constructors) {
  			System.out.println(constructor);
  		}
          constructors = c1.getDeclaredConstructors();
          for (Constructor constructor : constructors) {
  			System.out.println("#"+constructor);
  		}
          
          //获得指定的构造器
          Constructor constructor = c1.getDeclaredConstructor(String.class);
          System.out.println(constructor);
  	}
  }
  
  class User{	
      private String name;
  
  	public User(String name) {
  		this.name = name;
  	}
  
  	public User() {
  	}
  
  	public String getName() {
  		return name;
  	}
  
  	public void setName(String name) {
  		this.name = name;
  	}
  
  	@Override
  	public String toString() {
  		return "User [name=" + name + "]";
  	}
  }
  

• 创建类的对象：调用Class对象的newInstance()方法

  • 类必须有一个无参数的构造器
  • 类的构造器的访问权限需要足够

• 只有在操作的时候明确的调用类中的构造器，并将参数传递进去之后才可以进行实例化操作

  • 通过Class类的getDeprecatedConstructor(Class… parameterTypes)取得本类的指定参数类型的构造器
  • 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
  • 通过Constructor实例化对象

  //动态的创建对象，通过反射
  public class Test {
  	public static void main(String[] args) throws Exception {
  		//通过反射获取类的Class对象
  		Class c1 = Class.forName("com.java.test.User");
  		//构造一个对象
          User user = (User)c1.newInstance(); //本质上是调用类的无参构造器
          System.out.println(user); //User [name=null]
          
          //通过构造器创建对象
          Constructor constructor = c1.getDeclaredConstructor(String.class);
          User user2 = (User)constructor.newInstance("小明");
          System.out.println(user2); //User [name=小明]
          
          //通过反射调用普通方法
          Method setName = c1.getMethod("setName",String.class);
          //invoke：激活，(对象,"方法的值")
          setName.invoke(user,"小红");
          System.out.println(user.getName()); //小红
          
          //通过反射操作属性
        	Field name = c1.getDeclaredField("name");
        
        	//不能直接操作私有属性，需要关闭程序的安全检测
        	name.setAccessible(true); //关闭程序的安全检测
        	name.set(user, "小花");
        	System.out.println(user.getName()); //小花
  	}
  }
  
  class User{	
      //同上
  }
  

• 分析性能问题

  public class Test{
      public static void main(String[] args) throws Exception {
          test01(); //普通方法执行10亿次：3ms
          test02(); //反射方式执行10亿次：2056ms
          test03(); //关闭检测执行10亿次：726ms
      }
      
      //普通方式调用
      public static void test01(){
          User user = new User();
          long startTime = System.currentTimeMillis();
          for(int i = 0; i < 1000000000; i++){
              user.getName();
          }
          long endTime = System.currentTimeMillis();
          System.out.println("普通方法执行10亿次："+(endTime-startTime)+"ms");
      }
      
      //反射方式调用
      public static void test02() throws Exception {
          User user = new User();
          Class c1 = user.getClass();
          Method getName = c1.getDeclaredMethod("getName",null);
          long startTime = System.currentTimeMillis();
          for(int i = 0; i < 1000000000; i++){
              getName.invoke(user,null);
          }
          long endTime = System.currentTimeMillis();
          System.out.println("反射方式执行10亿次："+(endTime-startTime)+"ms");
      }
      
      //反射方式调用，关闭检测
      public static void test03() throws Exception {
          User user = new User();
          Class c1 = user.getClass();
          Method getName = c1.getDeclaredMethod("getName",null);
          getName.setAccessible(true);
          long startTime = System.currentTimeMillis();
          for(int i = 0; i < 1000000000; i++){
              getName.invoke(user,null);
          }
          long endTime = System.currentTimeMillis();
          System.out.println("关闭检测执行10亿次："+(endTime-startTime)+"ms");
      }
  }
  

• 反射操作泛型

  • Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是一旦编译完成，所有和泛型有关的类型全部擦除
  • 为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
    • ParameterizedType：表示一种参数化类型，比如Collection< String >
    • GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
    • TypeVariable：是各种类型变量的公共父接口
    • WildcardType：代表一种通配符类型表达式

  //通过反射获取泛型
  public class Test{
      public void test01(Map<String, User>map,List<User> list){
          System.out.println("test01");
      }
      public Map<String, User> test02(){
          System.out.println("test02");
          return null;
      }
      public static void main(String[] args) throws Exception {
          Method method = Test.class.getMethod("test01",Map.class,List.class);
          //获得泛型的参数类型
          Type[] genericParameterTypes = method.getGenericParameterTypes();
          for(Type genericParameterType : genericParameterTypes){
              System.out.println("#" + genericParameterType);
              if(genericParameterType instanceof ParameterizedType){
                  Type[] actualTypeArguments = ((ParameterizedType)genericParameterType).getActualTypeArguments();
                  for(Type actualTypeArgument :actualTypeArguments){
                      System.out.println(actualTypeArgument);
                  }
              }
          }
          System.out.println("---------");
  		method = Test.class.getMethod("test02", null);
          //获得返回值泛型参数
  		Type genericReturnType = method.getGenericReturnType();
  		if (genericReturnType instanceof ParameterizedType) {
  			Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
  			for (Type actualTypeArgument : actualTypeArguments) {
  				System.out.println(actualTypeArgument);
  			}
  		}
      }
  }
  
  class User{	
      //同上
  }
  /*
  #java.util.Map<java.lang.String, com.java.test.User>
  class java.lang.String
  class com.java.test.User
  #java.util.List<com.java.test.User>
  class com.java.test.User
  ---------
  class java.lang.String
  class com.java.test.User
  */
  

• 反射操作注解

  //通过反射操作注解
  public class Test {
  	public static void main(String[] args) throws Exception {
  		Class c1 = Class.forName("com.java.test.Student");
  		
  		//通过反射获得注解
  		Annotation[] annotations = c1.getAnnotations();
  		for (Annotation annotation : annotations) {
  			System.out.println(annotation); //@com.java.test.TableStudent(value=db_student)
  		}
  		//获得注解的value的值
  		TableStudent tableStudent = (TableStudent) c1.getAnnotation(TableStudent.class);
  		String value = tableStudent.value();
  		System.out.println(value); //db_student
  		//获得类指定的注解
  		Field f = c1.getDeclaredField("name");
  		FieldStudent fieldStudent = f.getAnnotation(FieldStudent.class);
  		System.out.println(fieldStudent.columnName()); //db_name
  		System.out.println(fieldStudent.type()); //varchar
  		System.out.println(fieldStudent.length()); //3
  	}
  }
  
  @TableStudent("db_student")
  class Student {
  	
  	@FieldStudent(columnName = "db_id",type = "int",length = 10)
  	private int id;
  	@FieldStudent(columnName = "db_age",type = "int",length = 10)
  	private int age;
  	@FieldStudent(columnName = "db_name",type = "varchar",length = 3)
  	private String name;
  	
  	public Student() {
  
  	}
  
  	public Student(int id, int age, String name) {
  		this.id = id;
  		this.age = age;
  		this.name = name;
  	}
  
  	public int getId() {
  		return id;
  	}
  
  	public void setId(int id) {
  		this.id = id;
  	}
  
  	public int getAge() {
  		return age;
  	}
  
  	public void setAge(int age) {
  		this.age = age;
  	}
  
  	public String getName() {
  		return name;
  	}
  
  	public void setName(String name) {
  		this.name = name;
  	}
  
  	@Override
  	public String toString() {
  		return "Student [id=" + id + ", age=" + age + ", name=" + name + "]";
  	}
  	
  }
  
  //类名的注解
  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @interface TableStudent{
  	String value();
  }
  
  //属性的注解
  @Target(ElementType.FIELD)
  @Retention(RetentionPolicy.RUNTIME)
  @interface FieldStudent{
  	String columnName();
  	String type();
  	int length();
  }