反射基本用法和实践

反射是我们之后学习Spring框架的前置基础

为了更好的讲解反射，我们首先创建一个Person类

package com.reflect;

public class Person extends Father {
    public String test1;
    protected  String test2;
    String test3;
    private String test4;
    public void eat(){
        System.out.println("eat...");
    }
    public void eat(String str){
        System.out.println("eat..."+str);
    }
    public String getString(String str){
        return str;
    }
    private String priGetString(String str){
        return str;
    }
    public String getTest1() {
        return test1;
    }

    public void setTest1(String test1) {
        this.test1 = test1;
    }

    public String getTest2() {
        return test2;
    }

    public void setTest2(String test2) {
        this.test2 = test2;
    }

    public String getTest3() {
        return test3;
    }

    public void setTest3(String test3) {
        this.test3 = test3;
    }



    public Person(){

    }
    public Person(String test1, String test2, String test3, String test4) {
        this.test1 = test1;
        this.test2 = test2;
        this.test3 = test3;
        this.test4 = test4;
    }

    @Override
    public String toString() {
        return "Person{" +
                "test1='" + test1 + '\'' +
                ", test2='" + test2 + '\'' +
                ", test3='" + test3 + '\'' +
                ", test4='" + test4 + '\'' +
                '}';
    }
}

然后我们就可以对person类进行操作了

package com.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.stream.Stream;

public class Feflect {
    public static void main(String[] args) throws Exception {
        //1.反射获取对象的三种方法

        //(1)
        Class cls1=Class.forName("com.reflect.Person");
        Object obj1=cls1.newInstance();
        //(2)
        Class cls2=Person.class;
        Object obj2=cls2.newInstance();
        //(3)
        Person p=new Person();
        Class cls3=p.getClass();
        Object obj3=cls3.newInstance();

        //获取公有构造器的方法，并创建实例
        Class clscon=Person.class;
        Constructor[]constructors=clscon.getConstructors();
        Constructor constructor=clscon.getConstructor();
        Constructor constructorarg=clscon.getConstructor(String.class,String.class,String.class,String.class);
        Object objcon1=constructorarg.newInstance("test1","test2","test3","test4");
        Object objcon2=constructor.newInstance();
        //获取方法并执行
        Method method1=clscon.getMethod("eat");//获得无参方法
        method1.invoke(clscon.newInstance());//无参方法执行
        Method method2=clscon.getMethod("eat",String.class);
        method2.invoke(clscon.newInstance(),"apple");
        Method methosre=clscon.getMethod("getString", String.class);
        Object objstr=methosre.invoke(clscon.newInstance(),"hello");
        System.out.println(objstr);
        Method[]methods=clscon.getMethods();//获取所有公有方法(包括从父类继承的)
        Stream.of(methods).forEach(System.out::println);
        System.out.println("----------------------");
        //获取公有私有方法（不包括父类的）
        Method[] primethod=clscon.getDeclaredMethods();
        Stream.of(primethod).forEach(System.out::println);
        //获取私有方法
        Method privatemethod=clscon.getDeclaredMethod("priGetString", String.class);
        privatemethod.setAccessible(true);//使用私有方法时需要设置为true
        Object objrestr=privatemethod.invoke(clscon.newInstance(),"hello,world");
        System.out.println(objrestr);
        //获取公有成员变量(包括父类)
        Field[] fields=clscon.getFields();
        Stream.of(fields).forEach(System.out::println);
        //获取所有的成员变量(不包括父类)
        System.out.println("-----------------");
        Field[] prifields=clscon.getDeclaredFields();
        Stream.of(prifields).forEach(System.out::println);
        //按照成员名称获取变量名
        Field field=clscon.getField("test1");
        System.out.println(field);
        System.out.println("-----------");
        //按照成员名获取私有变量名
        Field prifield=clscon.getDeclaredField("test4");
        System.out.println(prifield);
        System.out.println("----------------------");
        //获取变量值
        Object objfield=field.get(p);
        System.out.println(objfield);
        //获取私有变量值
        System.out.println("------------");
        prifield.setAccessible(true);
        Object objfipri=prifield.get(p);
        System.out.println(objfipri);
        //设置变量值
        System.out.println("-----------");
        field.set(p,"123");
        System.out.println(field.get(p));
        //设置私有变量值
        System.out.println("--------------");
        prifield.setAccessible(true);
        prifield.set(p,"456");
        System.out.println(prifield.get(p));



    }
}

了解反射的基本操作之后，我们来进行实践：

首先在src文件夹之下创建一个pro.properties文件

 文件中包含两个属性：
{

ClassName：

MethodName：

}

然后创建两个类，一个teacher类一个coder类

package com.kuangjia;

public class Teacher {
    public String name;
    public Teacher(){

    }
    public void teach(){
        System.out.println("teach student");
    }
}

package com.kuangjia;

public class Coder {

    public String name;

    public Coder(){

    }
    public void code(){
        System.out.println("coding....");
    }
}

 然后对pro.properties文件进行操作

package com.kuangjia;

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

public class Resource {
    public static void main(String[] args) throws Exception {
        Properties pro=new Properties();//创建Properties对象
        ClassLoader loader=Resource.class.getClassLoader();//获取类加载器
        InputStream inputStream=loader.getResourceAsStream("pro.properties");//获取该文件的字节流文件
        pro.load(inputStream);//加载该字节流文件
        String classname=pro.getProperty("ClassName");//从pro对象中获取以ClassName为key的值
        String methodname=pro.getProperty("MethodName");//从pro对象中获取以MethodName为key的值
        Class cls =Class.forName(classname);//通过反射获得classname的Class对象
        Object objinstance=cls.newInstance();//创建classname对应的对象
        Method method=cls.getMethod(methodname);//获取以method为名的函数
        method.invoke(objinstance);//执行method函数
    }
}

使用反射实现解耦就完成了