简单理解java反射机制

什么是反射？

1，反编译：.class-->.java

2．通过反射机制访问java对象的属性，方法，构造方法等；

反射应用场景：

Jdbc 加载驱动-----

Spring ioc

框架

获取类的三种方法

//第一种方式： 

        Classc1 = Class.forName("Employee"); 

//第二种方式： 

        //java中每个类型都有class 属性. 

        Classc2 = Employee.class; 

 //第三种方式： 

        //java语言中任何一个java对象都有getClass 方法 

        Employee e = new Employee(); 

        Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) 

代码实现

创建User类

public class User {
    private Integer id;
    private String password;
    public User(){
        System.out.println("无参构造");
    }

    public User(Integer id, String password) {
        this.id = id;
        this.password = password;
        System.out.println("有参构造");
    }

　　public String show(String s){
　　　　return s;
　　}
　　
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", password='" + password + '\'' +
                '}';
    }
}

 

 

1.创建无参构造函数

public class Demo1 {
    //通过反射创建无参构造函数
    public static void main(String[] args) throws Exception {
        //通过反射机制获取类
        Class<?> clazz = Class.forName("org.lzh.xxx.User");
        //通过反射机制创建User对象
        User user = (User) clazz.getDeclaredConstructor().newInstance();
        user.setId(20);
        System.out.println(user.getId());
    }
}

输出：
无参构造
20

 

2.创建有参构造函数

public class Demo2 {
    //通过反射创建有参构造函数
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("org.lzh.xxx.User");
        //参数为成员类型.class
        Constructor<?> constructor = clazz.getConstructor(Integer.class, String.class);
        //赋值并强转
        User user = (User) constructor.newInstance(20, "abc");
        System.out.println(user);
    }
}

输出：
有参构造
User{id=20, password='abc'}

 

3.通过反射给私有成员变量赋值

public class Demo3 {
    //通过反射给私有成员变量赋值
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("org.lzh.xxx.User");
        //创建无参构造函数，强转成User类，得到User对象
        Object o = clazz.getDeclaredConstructor().newInstance();
        User user = (User) o;
        //参数与User中成员变量相同
        Field id = clazz.getDeclaredField("id");
        Field password = clazz.getDeclaredField("password");
        //通过反射操作私有属性，因为属性是私有的，所以必须添加方法被允许访问
        id.setAccessible(true);
        //通过set方法给User对象的id赋值为20，下面同理
        id.set(user, 20);
        password.setAccessible(true);
        password.set(user, "abc");
        System.out.println(user);
    }
}

输出：
无参构造
User{id=20, password='abc'}

 4.通过反射获取带参带返回值成员方法并使用

public class Demo4 {
    public static void main(String[] args) throws Exception{
        Class<?> clazz = Class.forName("org.lzh.xxx.User");
        Object o = clazz.getDeclaredConstructor().newInstance();      //第一个参数是方法的名字，第二个参数是成员类型.class
        Method method = clazz.getMethod("show",String.class);
        //有返回值，object可以接收所有类型
        Object invoke = method.invoke(o, "abc");
        System.out.println(invoke);
    }
}

输出：
无参构造
abc