对反射的一些理解笔记

反射的知识点

1：什么是反射

反射是框架完成的核心。那什么又是框架呢？框架是一个半完成品的程序，在开发项目的时候可以直接拿来用。用于提高效率

反射就是把java类中的各个成分映射成一个个的java对象。

 

2：获取反射的Class

注意：java中，无论生成每个类的多少个对象，这些对象都会对应于同一个Class对象。(一个类的字节码指挥被加载一次)

从上述分析可知，任意一个字码节都会通过ClassLoader类加载器，加载到JVM内存中，以Class对象的形式存在。

常见的获取Class对象的方式有三种：

第一种	Class.forName("类路径")
第二种	类名.class
第三种	对象.getClass();

 

 

 

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//        第一种：根据user类路径获取user的反射对象
        Class<?> aClass = Class.forName("demo4.User");
        System.out.println(aClass);
//        第二种：根据类名获取user类的反射对象
        Class<User> userClass =User.class;
        System.out.println(userClass);
//        通过类对象获取类的反射对象
        User user = new User();
        Class<? extends User> aClass1 = user.getClass();
        System.out.println(aClass1);
//判断是否为同一个Class对象
        System.out.println(aClass==userClass);
        System.out.println(userClass==aClass1);
    }
}
class User{
    private String users;
    private Integer pwd;
    public String getUsers(){
        return  users;
    }
    public void setUsers(String users){
        this.users=users;
    }

    public Integer getPwd() {
        return pwd;
    }

    public void setPwd(Integer pwd) {
        this.pwd = pwd;
    }
}

结果展示：

3：通过反射获取反射类对象

通过Class类对象，调用newiInstance()

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class<User> aClass2 =(Class<User>)Class.forName("demo4.User");
//        通过反射类的到对应的类对象---之前的方式：new USer 来获取User类的对象
        User user1 = aClass2.newInstance();
        User user2 = aClass2.newInstance();
        System.out.println(user2==user1);
        System.out.println(user1);

    }
}
class User{
    private String users;
    private Integer pwd;
    public String getUsers(){
        return  users;
    }
    public void setUsers(String users){
        this.users=users;
    }

    public Integer getPwd() {
        return pwd;
    }

    public void setPwd(Integer pwd) {
        this.pwd = pwd;
    }
}

spring根据你传递的类路径--得到该类的反射类---并通过newInstance（）创建类对象

4：获取反射类中的属性成员对象

字节码中的属性成员被加载到内存中后会以Field类对象的形式存在。如何获取Field属性对象，可通过以下几种方式：

1.获取本类中指定的属性对象
反射类.getDeclaredField("属性名")
2.获取本类以及父类中指定的public修饰的属性
反射类.getField("属性名")
3.获取本类中所有的属性对象
反射类.getDeclaredFields("属性名")
4.获取本类以及父类中所有public修饰的属性
反射类.getFields("属性名")

public class Test2 {
    public static void main(String[] args) throws NoSuchFieldException {
//        获取docter反射类
        Class<Docter> docterClass = Docter.class;
//        获取反射类中的成员对象
        Field[] declaredFields = docterClass.getDeclaredFields();//获取本类中的所有属性对象
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("=================");
        Field[] fields = docterClass.getFields();//获取本类以及父类中的public对象
        for (Field field : fields) {
            System.out.println(field);
        }
        Field x = docterClass.getField("y");
        System.out.println(x);
    }

}
class People{
private String x;
public String y;
}
class Docter extends People{
    private String name;
    public String pwd;
    String sex;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("姓名:"+name);
    }
}

5：Field类中常用的方法

1.获取属性名

属性对象.getName():
2.设置属性可访问（会打破封装）

属性对象.setAccessible(true);
3.为对象的属性赋值

属性对象.set(对象,值)

属性对象为你获取到的属性对象，对象为你要赋值属性所属的对象。
4.获取对象的属性值

属性对象.get(对象)

这里属性对象为你获取到的属性对象，对象为你要获取属性值所属的对象。

 public class Test3 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException {
// 获取反射类对象
Class<Teather> teatherClass = Teather.class;
// 通过了反射对象获取类对象
Teather teather = teatherClass.newInstance();
System.out.println(teather);
// 得到类对象中的属性
Field declaredField = teatherClass.getDeclaredField("age");
declaredField.set(teather,18);//通过set属性对象为Teather对象赋值
System.out.println(teather);
Field name = teatherClass.getDeclaredField("name");

// 允许访问私有属性
name.setAccessible(true);
name.set(teather,"张飞");
System.out.println(teather);
}
}

6. 获取方法类对象

1.获取本类中所有的方法：

反射类.getDeclaredMethods();

得到的是一个存放所有方法的数组
2.获取本类和父类中所有public修饰的方法

反射类..getMethods();

得到的是一个存放所有方法的数组
3.获取本类中指定的方法对象

反射类.getDeclaredMethod("方法名",方法参数);
4.获取本类及父类中指定名称的方法对象

反射类.getMethod("方法名", 方法参数);

public class Test4 {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException {
//        获取反射类对象
        Class<Hello> helloClass = Hello.class;
//        获取hello对象
        Hello hello = helloClass.newInstance();
//        获取本类中所有的Method方法对象
        Method[] declaredMethods = helloClass.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
       Method sun= helloClass.getMethod("sun",int.class);
        System.out.println(sun);
    }
//    得到本类以及父类中的public修饰的方法对象
}

7：Method类中常用方法

invoke（对象，方法参数值）：执行方法体

获取的注解对象.value()

public class Test5 {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//        获取反射类对象
        Class<Word> wordClass = Word.class;
//        获取hello对象
        Word word = wordClass.newInstance();
        Method sun= wordClass.getMethod("sun",int.class,String.class);
        //invoke回调执行该方法 执行方法 word指的调用的方法对象
        Object result = sun.invoke( word,15,"123");
        System.out.println(result);
        MyWord annotation = sun.getAnnotation(MyWord.class);
        System.out.println(annotation.value());
    }
}

8：获取构造对象

只能得到本类中public的构造函数

getConstructor

得到本类中所有的public的构造函数

getConstructors

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        Class<?> aClass = T.class;
//        它只能得到本类中public的构造函数
        Constructor<?>[] constructor = aClass.getConstructors();
        for (Constructor<?> declaredConstructor : constructor) {
            System.out.println(declaredConstructor);
        }
    }
}

8.2：Constructor类中常用的方法

获取类中所有声明的构造器的方法

getDeclaredConstructors

获取类中声明的构造器的方法

getDeclaredConstructor

    public static void main(String[] args) throws Exception {
        Class<?> aClass = S.class;
        //得到无参构造函数
//        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
//        Object o = declaredConstructor.newInstance();
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
        Object world = declaredConstructor.newInstance("hello world");
    }
}