反射Reflection

1:获取Class实例的三种方式

Class clazz=Person.class;

Class clazz=new person().getClass;

Class clazz=Class.forName("包名+类名");//用的最多

2:Class的实例对应加载到内存中的一个运行时类

3:创建运行时类的对象

Class clazz=Person.class;

Person p=(Person)clazz.newInstance();//必须有空参构造器,不低于private

/**
 * 1:Reflection:反射:反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息,
 * 并能直接操作任意对象的内部属性与方法
 * 2:加载完类以后,在堆空间的方法区中就产生了一个Class类型的对象(一个类只有一个class对象)
 * 这个对象包含了完整的类的内部信息,我们可以通过这个对象看到类的结构,称之为反射!
 * 3:************实例化对象的区别
 * 正常方式:导入相应的类的名称----new实例化------取得实例化对象
 * 反射方式:实例化对象----getClass方法----得到完整的包类名称
 * 4:反射机制提供的功能:
 *    1在运行时判断任一对象所属的类
 *    2在运行时改造任意一个类的对象
 *    3在运行时判断任意一个类所具有的成员变量与方法
 *    4在运行时获取泛型信息
 *    5在运行时调用任意一个对象的成员变量与方法
 *    6在运行时处理注解
 *    7生成动态代理
 *
 * 5:反射相关的主要API
 * java.lang.Class:代表一个类
 * java.lang.reflect.Method:代表类的方法
 * java.lang.reflect.Field:代表类的成员变量
 * java.lang.reflect.Constructor:代表类的构造器
 *
 * **************************疑问?*******************
 *1:通过直接new的方式或者反射的方式都可以创建对象,那么开发中具体用哪个:建议直接用new创建对象
 *2:什么时候会使用反射的方式:动态性
 *3:反射机制与封装性是否矛盾,怎么看待?  :不矛盾,封装时私有化不建议你直接调用,
 * 如果真想用使用反射调用也是可以的,只是一个建议
 *
 * ***********Class类的理解**************
 * 1:类的加载过程:程序在经过javac.exe命令后,会生成一个或者多个字节码文件(.class结尾)
 * 接着我们使用java.exe命令对某个字节码文件进行解释运行相当于将字节码文件加载到内存中,
 * 此过程称为类的加载.加载到内存中的类称为运行时类,此运行时类就作为Class的一个实例
 * 2:换句话说,Class的实例就对应着一个运行时类
 * 3:加载到内存中的运行时类会缓存一定时间,在此时间之内,我们可以通过不同方式来获取此运行时类
 * *****哪些类型可以有Class对象******
 * 1：class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
 * 2：interface：接口 3：数组 4：枚举enum 5：注解annotation  6：primitive tape；基本数据类型
 * 7：void
 *
// */
public class ReflectionTest {
   @Test
    public void test(){
       //*******不使用反射
       //1创建Person类对象:
       Person person=new Person("hpp",23);
       System.out.println(person);
       person.setAge(50);
       System.out.println(person.age);
       //在Person类外部不可以通过对象调用私有的结构,属性,方法,构造器等等
   }
   @Test
    public void test2()throws NoSuchMethodException {
       //***********使用反射
       Class clazz=Person.class;
       Constructor constructor=clazz.getConstructor(String.class,int.class);

   }

   /**
    * 获取Class实例的4种方式:前3种需要掌握,第三种方式使用最多
    *
    */
   @Test
   public void test3()throws ClassNotFoundException{
      //方式1:调用运行时类的属性.class
      Class clazz1=Person.class;
      System.out.println(clazz1);
      //方式2:通过运行时类的对象,调用getClass方法
      Person person=new Person();
      Class clazz2=person.getClass();
      System.out.println(clazz2);
      //方式3:通过调用Class的静态方法forName(String classPath)包名+类名
      Class clazz3=Class.forName("Reflection.Person");
      System.out.println(clazz3);
      //方式4:使用类的加载器,classLoader了解即可
   }
   @Test
   public void test4(){
      //Class
      Class c1=Object.class;
      Class c2=int[].class;
      Class c6=int[][].class;
      Class c3=void.class;
      Class c4=int.class;
      Class c5=String.class;
      System.out.println(c2==c6);//元素类型与维度一致就是同一个Class，对于数组里面的长度没关系
   }
   /**
    * 二:创建运行时类的对象
    *
    */
   @Test
   public void test5()throws Exception{
      Class<Person> clazz=Person.class;//首先创建Class的实例
      Object obj=clazz.newInstance();//其次创建运行时类的对象,通过调用newInstance方法会返回一个实例,
      //newInstance方法调用了运行时类的空参构造器,
      //换句话说,要想使用此方法,1:必须要有空参构造器,2:构造器访问权限不能低于等于private,通常设置为public
      Person person=(Person) obj;//记得进行强转
      Person per=(Person)clazz.newInstance();//缩成一行
      System.out.println(per);
   }
   @Test
   public void test6(){
      for (int i = 0; i < 100; i++) {
         String classpath="";
         int num= new Random().nextInt(3);
         switch (num){
            case 0:
               classpath="java.util.Date";
               break;
            case 1:
               classpath="java.lang.Object";
               break;
            case 2:
               classpath="Reflection.Person";
               break;
         }
         try {
            Object obj=getInstance(classpath);
            System.out.println(obj);
            System.out.println("************");
         } catch (Exception e) {
            e.printStackTrace();
         }
      }
   }
   public Object getInstance(String str)throws Exception{
      //对于输入的字符串创建相应的对象
      Class clazz=Class.forName(str);
      return clazz.newInstance();
   }
   /**
    * 获取当前运行时类的属性结构
    *
    *
    */
   @Test
public void test7()throws Exception {
      //Class clazz=Class.forName("包名");
      Class clazz1=Person.class;
      Class clazz2=new Person().getClass();
      System.out.println(clazz2);


   }
   /**
    * 获取当前运行时类中的方法结构
    */
@Test
   public void test8(){
   Class clazz=Person.class;
   System.out.println(clazz.getPackage());//获取包名
   System.out.println(clazz.getConstructors());//获取构造器
   //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
   Method[] methods=clazz.getMethods();
   //getDeclareMethods():获取当前运行时类里声明的所有方法(不包含父类)
   Method[] demethods=clazz.getDeclaredMethods();
   for (Method m:methods){
      System.out.println(m);
   }
   for (Method m1:demethods){
      System.out.println("*****");
      System.out.println(m1);
   }
}
/**
 * 获取运行时类的方法的内部结构:了解就行
 * 权限修饰符 返回值类型 方法名(参数类型 参数名){}
 */
/**
 * 调用运行时类的指定的结构:属性,方法,构造器:方法最重要
 *
 */
@Test
//如何调用运行时类里的指定属性,需要掌握
   public void test9()throws Exception{
   Class<Person> clazz=Person.class;
   //创建运行时类对象
   Person p=clazz.newInstance();
   Person p1=clazz.newInstance();
   //getDeclareFiled(String fieldName):获取运行时类中指定变量名的属性
   Field name=clazz.getDeclaredField("name");
   name.setAccessible(true);//保证当前属性可以访问,否则在private条件下无法访问修改
   name.set(p,"Tom");
   p.setName("hello");
   System.out.println(p.getName());
}
/**
 * 如何调用运行时类的指定方法:掌握
 */
@Test
   public void test10()throws Exception{
    //创建class实例
   Class<Person> clazz=Person.class;
   //创建运行时类对象
   Person p=clazz.newInstance();
    //1:获取指定的某个方法getDeclaredMethod(),参数1:指明获取的方法名称,参数2:指明获取的方法的形参列表
    Method method=clazz.getDeclaredMethod("showNation", String.class);
    //2:setAccessible可访问修改调用
    method.setAccessible(true);
    //3:invoke():参数1:方法调用者,参数2:给方法形参赋值的实参
    method.invoke(p,"CHN");
}


}