反射

JAVA反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性。

这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制。

动态获取类中信息，就是JAVA反射。可以理解为对类的解剖。

设有以下类：

public class Person
{
     private int age;
     private String name;
     public Person(int age,String name){
         super();
         this.page=age;
         this.name=name;
         System.out.println("Person param run...");
    }
    public Person(){
         super();
         System.out.println("person run");
    }
    public void show(){
        System.out.priontln(name+"...show run ..."+age);
    }
    private void method(){
       System.out.println("method run ");
   }
    public void paramMethod(String str,int num){
        System.out.println("paramMethod run..."+str+":"+num);
   }
   public static void staticMethod(){
      System.out.println("static method run...");
  }
}

要想对字节码文件进行解剖，必须要用字节码文件对象。

如何获取字节码文件对象呢？

/*
*获取字节码对象的方式：
*1.Object类中的getClass()方法的。
*想要用这种方法，必须要明确具体的类，并创建对象
*比较麻烦。
*/
public static void getClassObjectd_1(){
     Person p=new Person();
     Class clazz =p.getClass();
     Person p1=new Person();
     Class clazz1=p1.getClass();
     System.out.println(clazz==clazz1);
}

/*
*2.任何数据类型都具备一个静态的属性.class来获取其对应的Class对象。
*相对简单，但是还是需要明确用到类中的静态成员，也需要知道类名，还是不够扩展
*/
public static void getCalssObject_2(){
    Class clazz=Person.class;
    Class clazz1=Person.calss;
    System.out.println(clazz==clazz1);
}

/*
*3.只要通过给定的类的字符串名就可以获取该类，更为扩展。
*可以用Class类中的方法完成。
*该方法就是forName()方法
*这种方式只要有名称即可，更为方便，扩展性更强，尽量用此方法。
*/
public static void getCalssObject_3() throws ClassNotFoundException{
    String className="cn.sabc.com.Person"; //此处类名必须包含包名
    Class clazz=Class.forName(className);
    System.out.print(clazz);
}

 用new类方法和forName()有什么区别？

public static void CreateNewObject(){
    //早期：new的时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，并创建该字节码对象，并接着创建该字节文件的对应的Person对象。
   cn.sabc.com.Person p=new cn.sabc.com.Person();
   //现在：
   String name="cn.sabc.com.Person";
   //找寻该名称类文件，并加载进内存，并产生Class对象。
   Class clazz=Class.forName(name);
   //如何产生该类的对象呢？
   Object obj=clazz.newInstance();
}


public static void CreateNewObject_1(){
    //当获取指定名称对应类中的所体现的对象时，而该对象初始化不命名用空参构造函数怎么办呢？
   cn.sabc.com.Person p=new cn.sabc.com.Person(39,"小强”);
   //既然是通过指定的构造随叫随到数进行对象的初始化，所以应该先获取到该构造函数。
   //通过字节码码文件对象即可完成。利用getConStructor(paramterTypes)，可获取所有公有的构造函数
   String name="cn.sabc.com.Person";
   Class clazz=Class.forName(name);
  //获取到了指定的构造函数对象
   Constructor constuctor=clazz.getConstructor(int.class,String.class);
  //通过该构造器对象的newInstance方法进行对象的初始化
 object obj=constructor.newInstance(38,"小明");
}

 获取一个类对象中的字段。

public static void getFieldDemo(){
    Class clazz=Class.forName("cn.sabc.com.Person");
   // Field field=clazz.getField("age");  //不能获取私有字段
    Field field1=clazz.getDeclareField("age");//能获取本类，但包含私有
   System.out.println(field1);
   //对私有字段的访问取消权限检查，暴力访问，不建议使用
   field.setAccessible(true);
   Object obj=clazz.newInstance(); 
   field.set(89,obj);
   Object o=field.get(obj); //
   System.out.println(o);
}

获取一个类对象的方法

public static void getMethodDemo(){
    Class clazz=Class.forName("cn.sabc.com.Person");
   // Method[] methods=clazz.getMethods(); //只获取公有的
    Method[] methods=clazz.getDeclareMethods(); //只获取本类中所有的方法，包含私有
    for(Method method :methods)
   {
        System.out.println(method);

    }
}

//执行无参方法
public static void getMethodDemo_2(){
    Class clazz=Class.forName("cn.sabc.com.Person");
    Method method=clazz.getMethod("show",null);
    //调用方法需要有对象
   // Object obj=clazz.newInstance(); 无参构造函数 
    Constuctor constructor=clazz.getConstructor(String.class,int.class);
    Objet obj=constructor.newInstance(37,"小明");
    method.invoke(obj,null);  //执行该方法
    }
}

//执行有参方法
public static void getMethodDemo_3(){
    Class clazz=Class.forName("cn.sabc.com.Person");
    Method method=clazz.getMethod("paramMethod",int.class,String.class);
    //调用方法需要有对象
   // Object obj=clazz.newInstance(); 无参构造函数 
    method.invoke(obj,37,"小强");  //执行该方法
    }
}