JavaSE——反射学习（参照）

反射

学习路径视频

1、含义

反射: 将类的各个组成部分封装为其他对象，这就是反射机制

好处: 可以在程序运行过程中，操作这些对象。可以解耦，提高程序的可扩展性。

2、获取Class对象的方式

1. Class.forName("全类名"): 将字节码文件加载进内存，返回class对象

   • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类

2. 类名.class : 通过类名的属性class获取

   • 多用于参数的传递

3. 对象.getClass() : getClass()方法在Object类中定义着。

   • 多用于对象的获取字节码的方式

测试

1、创建实体类

public class Person {
    private  String name;
    private  int age;

    public String a;
    protected String b;
    String c;
    private String d;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(String name, int age, String a, String b, String c, String d) {
        this.name = name;
        this.age = age;
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    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;
    }

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }

    public String getB() {
        return b;
    }

    public void setB(String b) {
        this.b = b;
    }

    public String getC() {
        return c;
    }

    public void setC(String c) {
        this.c = c;
    }

    public String getD() {
        return d;
    }

    public void setD(String d) {
        this.d = d;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat(){
        System.out.println("eat.....");
    }
    public void eat(String eat){
        System.out.println("我"+eat);
    }
}

2、测试方法

/**
     * 1. Class.forName("全类名"):将字节码文件加载进内存，返回class对象
     * - 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
     * <p>
     * 2. 类名.class :通过类名的属性class获取
     * - 多用于参数的传递
     * <p>
     * 3. 对象.getClass() : getClass()方法在Object类中定义着。
     * - 多用于对象的获取字节码的方式
     */
    public static void main(String[] args) throws Exception {
        //1. Class.forName("全类名")
        Class cls1 = Class.forName("com.zhu.fanshe.dto.Person");
        System.out.println(cls1);
        //2. 类名.class
        Class cls2 = Person.class;
        System.out.println(cls2);
        //3. 对象.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

        //比较三个对象
        System.out.println(cls1 == cls2);//true
        System. out.println(cls1 == cls3); //true

    }

3、结论

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的class对象都是同一个。

4、Class对象功能

获取功能:

4.1、获取成员变量们

Field[] getFields()
Field getField(string name)
    
Field[] getDeclaredFields()
Field getDeclaredField(string name)

例：

  public static void main(String[] args) throws Exception {
        //0.获取Person的class对象
        Class personClass = Person.class;
    /*
          1．获取成员变量们
          *Field[] getFields()
          *Field getField(String name)
          *Field[] getDeclaredFields()
          *Field getDeclaredField(String name)
    */
        //1.Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (
                Field field : fields) {
            System.out.println(field);
        }
        System.out.println("------------");
        Field a = personClass.getField("a");
        //获取成员变量a的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p, "张三");
        System.out.println(p);


        System.out.println("===================");
        //Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(Strng name)
        Field d = personClass.getDeclaredField("d");//忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        d.set(p,"李四");
        Object value2 = d.get(p);
        System.out.println(value2);


    }

4.2、获取构造方法们

constructor<?>[] getconstructors()
constructor<T> getconstructor(类<?>... parameterTypes)
    
constructor<T> getDeclaredconstructor(类<?>... parameterTypes)
constructor<?[] getDeclaredconstructors()

例：

public static void main(String[] args) throws Exception {
        //0.获取Person的class对象
        Class personClass = Person.class;
        //Constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //创建对象
        Object person = constructor.newInstance("张三", 23);
        System.out.println(person);

        System.out.println("----------");
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //创建对象
        Object person1 = constructor1.newInstance();
        System.out.println(person1);
        Object o = personClass.newInstance();
        System.out.println(o);
        constructor1.setAccessible(true);
    }

4.3、获取成员方法们

Method[] getMethods()
Method getMethod( string name，类<?>... parameterTypes)
    
Method[] getDeclaredMethods()
Method getDeclaredMethod(string name，类<?>... parameterTypes)

例：

public static void main(String[] args) throws Exception {
        Class personClass = Person.class;
        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method.invoke(p);
        Method eat_method2 = personClass.getMethod("eat", String.class);//执行方法
        eat_method2.invoke(p, "饭");


        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            String name = method.getName();
            System.out.println(name);
            method.setAccessible(true);
        }
       //获取类名
        String className = personClass.getName();
        System.out.println(className);//com.zhu.反射.dto.Person

    }

4.4、获取类名

string getName()

例：

public static void main(String[] args) throws Exception {
        Class personClass = Person.class;
       //获取类名
        String className = personClass.getName();
        System.out.println(className);//com.zhu.fanshe.dto.Person

    }

5、操作

Field :成员变量
操作:

1.设置值void set( object obj, object value)

2．获取值get(object obj)

3．忽略访问权限修饰符的安全检查setAccessible(true):暴力反射

constructor:构造方法
创建对象︰

T newInstance(object. . . initargs)

如果使用空参数构造方法创建对象，操作可以简化:class对象的newInstance方法

Method :方法对象
执行方法︰

object invoke(object obj，object. . . args)

获取方法名称∶

string getName:获取方法名

6、案例

需求:

1、写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现︰

1、配置文件

#className=com.zhu.fanshe.dto.Student
#methodName=sleep

className=com.zhu.fanshe.dto.Person
methodName=eat

2、反射

步骤∶

1、将需要创建的对象的全类名和需要执行的方法定义在配置文件中

2、在程序中加载读取配置文件

3、便用反射技术来加载类文件进内存

4、创建对象

5、执行方法

 public static void main(String[] args) throws Exception {
        //可以创建任意类的对象,可以执行任意方法
        /*
            前提:不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法*/
        /*Person p = new Person( );p.eat( );*/
         /*
         Student stu = new Student();stu.sleep( );
         */
        //1.加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);
        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");
        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        //5.1不带参方法
        Method method = cls.getMethod(methodName);
        method.invoke(obj);
        //5.2带参方法
        //Method method = cls.getMethod(methodName,String.class);
        //method.invoke(obj,"吃肉");
    }