反射简介

1. 什么是反射
   反射java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法

比如：

package com.lww.reflect;

public class Student {
    
    private String sid;

    private String sname;

    public Integer age;
    
    static{
        System.out.println("加载进jvm中！");
    }

    public Student() {
        super();
        System.out.println("调用无参构造方法创建了一个学生对象");
    }

    public Student(String sid) {
        super();
        this.sid = sid;
        System.out.println("调用带一个参数的构造方法创建了一个学生对象");
    }

    public Student(String sid, String sname) {
        super();
        this.sid = sid;
        this.sname = sname;
        System.out.println("调用带二个参数的构造方法创建了一个学生对象");
    }

    @SuppressWarnings("unused")
    private Student(Integer age) {
        System.out.println("调用Student类私有的构造方法创建一个学生对象");
        this.age = age;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public void hello() {
        System.out.println("你好！我是" + this.sname);
    }

    public void hello(String name) {
        System.out.println(name + "你好！我是" + this.sname);
    }

    @SuppressWarnings("unused")
    private Integer add(Integer a, Integer b) {
        return new Integer(a.intValue() + b.intValue());
    }

}

package com.lww.reflect;
/**
 * 获取对象的方式
 * 通过java提供反射机制获取到java.lww.reflect.Student.Class
 * 1.class.forname("文件路径") jdbc/mvc自定义框架要用
 * 2.类名.class 结合泛型做通用分页查询方法会用
 * 3.类java.lang.class实例(student.class)的类实例getClass()获取
 * 通用的增删改结合泛型使用
 * */
public class Demo1 {
    public static void main(String[] args) throws Exception {
        //1.class.forname("文件路径") jdbc/mvc自定义框架要用
//        Class stuClz=Class.forName("com.lww.reflect.Student");

        
        
        //2.class 结合泛型做通用分页查询方法会用
        //Class stuClz=Student.class;
        Student stu=new Student();
        //类java.lang.class实例(student.class)的类实例getClass()获取
        Class stuClz=stu.getClass();
        System.out.println(stuClz);
        
    }

}

package com.lww.reflect;

import java.lang.reflect.Constructor;

/**
 * 利用反射进行对象的实例化
 *    通过java.lang.reflect.construct来实例对象
 * 研发tomcat服务的这个人，他能知道未来的某一天某个程序写了一个xxxservlet
 * web.xml xxxservlet  对xxxservlet实例化,还能调用.servi()
 * 
 * 按照以前得new xxxservlet().service()才能调用这个方法
 * 现在:
 * 对web.xml进行建模,拿到全名路径，class.for("com.lww.xxxservlet")可以替代
 * （new xxxservlet().service()）
 * 然后这个类继承了httpservlet
 * 可以这么写：（xxxservlet ser=class.for("com.lww.xxxservlet.newInstance()"）
 * 
 * 反射的优势：
 * 1.能够对未知的对象进行实例化
 * 2.能够对私有构造器实例化对象
 * 
 * */
public class Demo2 {
    public static void main(String[] args) throws Exception {
//        Student stu=new Student();
//        Class stuClz=stu.getClass();
        Class<Student> stuClz =Student.class;
        //newInstance这个默认是使用无参构造器去实例对象
//        Student stu2 =(Student) stuClz.newInstance();
//        System.out.println(stu2);

        
//    //调用有参构造器去实例对象
//        Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
//        Student stu2= (Student) constructor.newInstance("s001","zs");

调用两个有参的：

        
        //调用私有构造器实例化对象
        //区别
        //getConstructor   (只能获取被public修饰器的构造器)
        //getDeclaredConstructor  （被所有关键字修饰的构造器）
    Constructor<Student> constructor = stuClz.getDeclaredConstructor(Integer.class);
    constructor.setAccessible(true);
    Student stu2= (Student) constructor.newInstance(18);

    }

}

package com.lww.reflect;

import java.lang.reflect.Method;

/**
 * 动态方法调用
 * 
 * 构造方法是不是方法
 * 
 * */

public class Demo3 {
   public static void main(String[] args) throws Exception {
    Student stu =new Student();
    Class<? extends Student> stuClz=stu.getClass();
    //Method m =stuClz.getDeclaredMethod("hello");
    //m.invoke(stu);
    
    //Method m =stuClz.getDeclaredMethod("hello",String.class);
    //m.invoke(stu,"zs");
    //Method.invoke的返回值被动态调用的方法的返回值
    Method m =stuClz.getDeclaredMethod("add",Integer.class,Integer.class);
    m.setAccessible(true);
    Object invoke=m.invoke(stu,20,5);
    System.out.println(invoke);
}
}

 

 

package com.lww.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 * 自定义标签库，通用分页，自定义mvc
 * 
 * 访问修饰符
 * getModifiers()
 * java:
 * private 1
 * protected 2
 * public 4
 * static 8
 * final abstract
 * 怎么判定属性或方法被哪些修饰符所修饰
 * getModifiers
 * 3 private protected
 * 
 * */

//获取私有的
public class Dome4 {
    public static void main(String[] args) throws Exception {
        Student stu=new Student("s001","zs");
        stu.age=22;
        System.out.println(stu.getSid());
        System.out.println(stu.getSname());
        Class<? extends Student> stuClz=stu.getClass();
//        Field f= stuClz.getDeclaredField("sname");
//        f.setAccessible(true);
//        System.out.println(f.get(stu));

        
        Field[] fields=stuClz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            System.out.println(field.getName()+":"+field.get(stu));
        }
    }

}

获取所有：