java反射

一：类的加载

当类被执行的时候，如果该类的没有被执行的话，该类会被系统通过加载、连接、初始化三个步骤加载到内存中。

1、加载  类加载到内存的时候，将Class文件加载到内存中，并为其创建一个class  file对象。----由类加载器完成。class文件不等于 Class对象，Class对象也叫做字节码对象。

    任何类型被使用的时候都会创建一个Class file对象。

2、连接   ----由类加载器完成

       1)验证类的结构正确性。（成员变量、结构等）.

       2)为静态成员分配内存和初始化默认值。分配到方法区的共享数据区域。

      3）将类的二进制数据引用转换成直接引用（就是比如：a=1  实际类加载到内存之后，a不存在只存在1的引用变为直接引用。）

3、初始化

     创建对象，在使用new的时候，会调用类的构造方法和以及成员变量。

二：类被加载到内存和初始化时机（如下情景：）

1、创建类的实例

2、类的静态变量、或者静态变量赋值

3、类的静态方法

4、使用反射方式来强制创建某个类的或者接口的对象的java.lang.Class对象

5、初始化某个类的子类，在初始化子类的时候，优先执行父类的，并将父类加载到内存中

6、直接使用java命令执行某个主类。

三：类加载器

1、作用：负责将类的class文件加载到内存中，并为之生成Class对象。

2、分类

    1）根加载器（bootstarp  Classloader）：

         也被称为引导加载器，负责java核心类的加载，比如说：String、int等，加载jre中lib的rt.jar.

   2）扩展加载器（extension Classloader）

        负责加载JRE加载lib目录的etx目录。

   3)系统加载器（System Classloader）

       负责加载JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径（也就是自定义的类的class文件。）

四：反射

   java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够使用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能叫做java的

反射机制。

   场景：

         我们在写日常工程的时候，经验会遇到一个问题，原有的class因为功能的不完整问题，需要我们重新写一些方法，在不改动原先的class的代码结构的情况下，使用java的反射技术

来解剖新的类，通过Class对象（字节码对象）来调用新的类的是一个不错的新的方法！

 五：获取class文件对象。

1、通过对象获取

通过Object的getclass获取执行类对象。

Class<?> getClass()

Returns the runtime class of this Object.

2、通过类的属性获取

所有类都有一个属性.class

3、通过Class文件的ForName获取。

通过Class的静态方法forName("类的全路径")

package com.jd.refect;

public class Get_Class {
    public  static void  main(String ... args)throws  ClassNotFoundException{
        //通过父类Object.getClass 获取Class对象。
        Person person=new Person();
        Class  c=person.getClass();
        System.out.println(c);
        //通过类的.class属性获取当前Class对象。
        Class c1=Person.class;
        System.out.println(c1);
        //通过Class类的静态方法ForNmame获取Class对象。（注意参数是类的全路径）
        Class c2= Class.forName("com.jd.refect.Person");
        System.out.println(c2);
        //c  c1 c2三个对象是一个，类加载到内存只有一次。
        if(c==c1 && c==c2){
           System.out.println("equal");//内存地址比较
        }
        if(c.equals(c2)&& c.equals(c1)){
            System.out.println("equal");
        }
    }
}

 六：获取constructor对象

package com.jd.refect;


import java.lang.reflect.Constructor;

public class Get_Class {
    public  static void  main(String ... args)throws  Exception{
        //通过父类Object.getClass 获取Class对象。
        Person person=new Person();
        Class  c=person.getClass();
        System.out.println(c);
        //通过类的.class属性获取当前Class对象。
        Class c1=Person.class;
        System.out.println(c1);
        //通过Class类的静态方法ForNmame获取Class对象。（注意参数是类的全路径）
        Class c2= Class.forName("com.jd.refect.Person");
        System.out.println(c2);
        //c  c1 c2三个对象是一个，类加载到内存只有一次。
        if(c==c1 && c==c2){
           System.out.println("equal");//内存地址比较
        }
        if(c.equals(c2)&& c.equals(c1)){
            System.out.println("equal");
        }
        /*
        获取Person类的构造方法。
        通过Class方法Constructor<?>[]     getConstructors()
                        Returns an array containing Constructor objects reflecting all the public constructors of the class represented by this Class object.
                        返回Constructor[]
                        只返回有公共权限的constructor。（只有public修饰权限的构造方法）
         */
        Class  c3=Class.forName("com.jd.refect.Person");
        Constructor[] cons=c3.getConstructors();//返回Constructor[]
        for(Constructor con:cons){
            System.out.println(con);
        }
        /*
         上面方法获取的constructor的数组。
         获取指定constructor
         获取无参constructor
         */
        Constructor con1=c3.getConstructor();
        System.out.println(con1);
        /*获取有参数的构造方法
        Constructor<T>     getConstructor(Class<?>... parameterTypes)
        参数是构造方法需要的参数列表类型。
        参数需要传入类名.class
        通过constructor的方法构造对象
        T     newInstance(Object... initargs)
        参数是动态的参数。
        Uses the constructor represented by this Constructor object to create and
        initialize a new instance of the constructor's declaring class, with the specified
         */
        Constructor con2=c3.getConstructor(int.class,String.class);
        Object  obj=con2.newInstance(2,"小红");
        System.out.println(con2);
        System.out.println(obj);
    }
}

 快捷创建实例化对象：

     类需要具备如下特性：

　　1、无参构造方法

　　2、public 修饰的构造方法。

        /*
          快捷方式
          上述方法是需要创建constructor对象然后调用newstance方法。
          使用快捷方法需要该类具备如下条件：
          1、必须要有空参构造方法。
          2、该构造方法需要public权限。
          直接调用Class.newstance() 无参
          T     newInstance()
                Creates a new instance of the class represented by this Class object.
         */
          Object obj1=c3.newInstance();
          System.out.println(obj1);

 获取私有构造方法（不推荐使用，这样获取，破坏了类的封装性。）

          /*
          对于私有构造方法如何获取？
          暴力反射（不推荐使用）
          getdeclaredconstructors（）返回所有的构造方法，无论是public还是private。
          返回是constructor[]
           */
          Constructor[]  con3=c1.getDeclaredConstructors();
          for(Constructor con:con3){
              System.out.println(con);
          }
          /*
          获取私有的构造方法
          getDeclaredConstructor()方法获取
          public void  setAccessible(Boolean flag)解锁该私有方法的权限限制。即会直接越过私有权限。
           */
          Constructor con4=c3.getDeclaredConstructor(String.class,int.class);
          con4.setAccessible(true);
          Object obj4=con4.newInstance("xxx",2);
          System.out.println(obj4);

 获取字段和方法并执行方法

          /*
           获取类的字段。
           使用Class类的
           Field[] getFields()只能获取公共权限的成员 private字段无法获取。
           */
        Field[] filed=c3.getFields();
        for(Field f:filed){System.out.println(f);};
        /*
        获取指定成员变量
        Field     getField(String name)  只能获取公共权限的成员 private字段无法获取。String name 字段名称
        设置字段值。调用Field的set方法。
        void     set(Object obj, Object value) 第一个参数需要传入该类的对象 因为person类有空参。

        第二个参数需要传入设置的值 类型需要和person类的类型一致。
        Object     get(Object obj) 获取值的方法。
        参数为Person类的对象。
         */
        Field f=c3.getField("age");
        System.out.println(f);
        Object per=c3.newInstance();
        f.set(per,2);
        System.out.println(f.get(per));
        /*
        获取私有变量。
       使用
       Field     getDeclaredField(String name)
       String name 为获取参数的字符串值。
       需要设置：setAccessible(true);
       获取数组使用Field[]     getDeclaredFields()
         */
        Field f1=c3.getDeclaredField("addr");
        f1.setAccessible(true);
        Object obj3=c3.newInstance();//空参构建实例对象。
        f1.set(obj3,"北京");
        System.out.println(f1.get(obj3));
        /*
        获取成员方法。
        Method[]     getMethods()
        获取person类的所有公共成员方法。也包含继承的方法。
         */
        Method[] method=c3.getMethods();
        for(Method me:method) {
            System.out.println(me);
        }
        /*
        获取指定方法。
        Method     getMethod(String name, Class<?>... parameterTypes)
        第一个参数方法名字，第二个是参数列表，因为一个方法可能重载。
        方法执行：
        Object     invoke(Object obj, Object... args)
        第一个参数person类对象  第二参数为动态的参数。
        获取私有方法同样：
        Method     getDeclaredMethod(String name, Class<?>... parameterTypes)
         */
        Method me1=c3.getMethod("eat",String.class);
        Object obj5=c3.newInstance();
        me1.invoke(obj5,"打炮！");

 六：通过配置文件的配置 经过反射的查找对应的类和方法。

package ref_con.config;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class config_ref {
    /*
    通过配置文件灵活的配置。使用反射来进行获取和执行类的对象。
     */
    public  static  void  main(String ... args)throws  Exception{
        InputStream inp=config_ref.class.getClassLoader().getResourceAsStream("config.properites");
        Properties pro=new Properties();
        pro.load(inp);
        inp.close();
        String classname=pro.getProperty("ClassNmame");
        String method=pro.getProperty("Method");
        Class person=Class.forName(classname);
        Method  method1=person.getMethod(method);
        Object obj=person.newInstance();
        method1.invoke(obj);

    }

}

配置文件：

ClassNmame=ref_con.config.Person
Method=playGames

person类：

package ref_con.config;



public class Person {
    public int age;
    public  String name;
    private  String addr;
    public  Person(){}
    public  Person(int age,String name){
        this.name=name;
        this.age=age;
    }
    private Person( String name,int age){
        this.age=age;
        this.name=name;
        this.addr=addr;
    }
    public String getName() {
        return this.name;
    }
    public int  getAge(){
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name+" "+this.age+' ';
    }

    public String getAddr() {
        this.addr=addr;
        return this.addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }
    public  void  eat(){
        System.out.println("吃饭");
    }
    public  void  eat(String a){
        System.out.println("吃饭"+a);
    }
    public  void  playGames(){
        System.out.println(" we are playing baskball!");
    }
}