java反射学习笔记

一，重点：

1.  理解class类并获取class实例
2.  类的加载与classloader的理解
3. 创建运行时的类对象
4. 调用运行时类的指定结构
5. 反射的应用：动态代理

二，通过反射我们能干啥：

1. 在运行时判断任意一个对象所属的类
2. 在运行时构造任意一个类的对象
3. 在运行时判断任意一个类所具有的成员变量和方法
4. 在运行时获取泛型信息
5. 在运行时调用任意一个对象的成员变量和方法
6. 在运行时处理注解
7. 生成动态代理

---

三，反射代码演示：

package shangguigu;


/**
* @author hpc
* @create 2021/1/4 12:22
*/
public class Person {


    public Person() {
    }


    private String name;
    public int age;


    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    private Person(String name) {
        this.name = name;
    }


    public String getName() {
        return name;
    }


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


    public int getAge() {
        return age;
    }


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


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    public void show(){
        System.out.println("你好，我是一个人");
    }


    private String showNation(String nation){
        System.out.println("我的国籍是"+nation);
        return nation;
    }
}

package shangguigu;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;


/**
* @author hpc
* @create 2021/1/4 13:03
*/
public class ReflectionTest {


    //反射之前对person类的操作
    @Test
    public void test1(){


        //1.创建person类的对象
        Person p1 = new Person("tom",12);


        //调用其内部属性和方法
        p1.age = 10;
        System.out.println(p1.toString());


        p1.show();
        //在person类的外部不可以通过person类对象调用其内部私有的结构
        //比如私有内部属性，私有方法，私有构造器
    }


   //调用反射之后
   @Test
    public void test2() throws Exception{
        Class clazz = Person.class;
        //1.通过反射，创建Person类的对象
        Constructor cons = clazz.getConstructor(String.class,int.class);
        Object obj = cons.newInstance("tom",12);
        Person p = (Person)obj;
        System.out.println(p.toString());
        //通过反射调用对象指定的属性
       Field age = clazz.getDeclaredField("age");
       age.set(p,9);
       System.out.println(p.toString());
       //通过反射调用对象指定的方法
       Method show = clazz.getDeclaredMethod("show");
       show.invoke(p);
       /*
       通过反射可以调用类的私有结构
        */
       //调用私有构造器
       Constructor cons1 = clazz.getDeclaredConstructor(String.class);
       cons1.setAccessible(true);
       Person p1 = (Person)cons1.newInstance("hpc");
       System.out.println(p1);
       //调用私有属性
       Field name = clazz.getDeclaredField("name");
       name.setAccessible(true);
       name.set(p1,"hhh");
       System.out.println(p1);
       //调用私有方法
       Method showNation = clazz.getDeclaredMethod("showNation", String.class);
       showNation.setAccessible(true);
       String nation = (String) showNation.invoke(p1,"中国");//相当于p1.showNation("中国")
       System.out.println(nation);
   }
}

 

 

---

四，关于java.lang.Class类的理解：

    java程序经过javac.exe编译成.class字节码文件，然后使用java.exe运行。我们把字节码文件加载到内存中的过程称为类的加载，加载到内存中的类称之为运行时类，此运行时类就作为Class类的一个实例。

 

五，获取Class实例的三种方式：

public void test3()throws Exception{
     /*
     获取Class类的实例的方法
      */
     //通过.class属性获得
    Class<Person> clazz1 = Person.class;
    System.out.println(clazz1);


    //通过getclass()方法
    Person p = new Person();
    Class clazz2 = p.getClass();
    System.out.println(clazz2);


    //通过Class.forName()方法
    Class clazz3 = Class.forName("shangguigu.Person");
    System.out.println(clazz3);
    System.out.println(clazz1 == clazz2);//true
    System.out.println(clazz1 == clazz3);//true
    
    //通过classLoader
    ClassLoader classloader = ReflectionTest.class.getClassLoader();
    Class clazz4 = classloader.loadClass("shangguigu.Person");
    System.out.println(clazz4);
}

 

六，使用类加载器读取properties文件

package shangguigu;


import org.junit.Test;


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;


/**
* @author hpc
* @create 2021/1/4 16:20
*/
public class ClassLoaderTest {


    @Test
    public void test1() throws IOException {
        /*
        传统读取配置文件
         */
        //a.properties默认在当前module下
        Properties pro = new Properties();
        FileInputStream fis = new FileInputStream("a.properties");
        pro.load(fis);


        String user = pro.getProperty("user");
        String password = pro.getProperty("password");
        System.out.println("user:"+user+","+"password:"+ password);


        /*
        使用类加载器方式读取配置文件
         */
        //a1.properties默认在src下找
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("a1.properties");
        pro.load(is);
        String user1 = pro.getProperty("user");
        String password1 = pro.getProperty("password");
        System.out.println("user:"+user1+","+"password:"+ password1);


    }


}

 

七，创建运行时类对象

package shangguigu;


import org.junit.Test;


/**
* @author hpc
* @create 2021/1/4 17:17
*/
public class NewInstanceTest {


    @Test
    public void test1() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        /*
        创建运行时类对象
        */
        /*
        要想此方法正常创建运行时的类对象要求：
        1.运行时类必须提供空参构造器
        2.空参构造器的访问权限必须足够，通常为public


        在javabean中要求要提供一个public的空参构造器，原因：
        1、便于通过反射创建运行时类对象
        2.便于子类super()时，父类有此构造器
         */
        Class clazz = Class.forName("shangguigu.Person");
        Person p1 = (Person)clazz.newInstance();//相当于调用Person中无参数的构造器，所以Person中必须要提供无参数的构造器
        System.out.println(p1);

    }
}

 

 

 

八，

clazz.getField()//获取当前运行时类以及其父类中public的属性

clazz.getDeclaredField()//获取当前运行时类的所有熟悉，没有父类，不考虑限定

clazz.getMethods()//获取当前运行时类以及其父类中public的所有方法

clazz.getDeclaredMethods()//获取当前运行时类的所有方法（不包含父类）