java基础-反射

Posted 2023-04-09 zz-coding

1.反射定义

反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法，并且对于任意一个对象，都能够调用它的任意一个方法，这种动态获取信息以及动态调用对象方法的功能称为Java反射机制

动态语言定义：动态语言是指程序在运行时可以改变其结构，新的函数可以引进，已有的函数可以被删除。比如常见的JavaScript，Python属于动态语言，而C、C++则不属于动态语言，从反射角度说JAVA属于半动态语言

反射之所以被称为框架的灵魂，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。为什么你使⽤Spring的时候，⼀个@Component注解就声明了⼀个类为Spring Bean呢？为什么你通过⼀个@Value注解就读取到配置⽂件中的值呢？这些都是因为你可以基于反射分析类，然后获取到类/属性/⽅法/⽅法的参数上的注解，你获取到注解之后，就可以做进⼀步的处理

为什么引入反射呢

在Java程序中，分为编译时类型和运行时类型。编译时的类型由声明对象时的类型来决定，运行时的类型由实际赋值给对象的类型决定。编译时根本无法预知该对象和类属于哪些类，程序需要在运行时发现对象和类的真实信息，此时就必须使用到反射了，另外反射可以让我们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利

不过反射让我们在运行时有了分析操作类的能力的同时，也增加了安全问题，比如可以略过安全检查(泛型参数的安全检查发生在编译时)；反射相比于new性能也较低，因为通过反射时，先找查找类资源，使用类加载器创建，过程比较繁琐

2.使用反射

2.1.反射api

反射API用来生成JVM中的类、接口或则对象的信息

Class类：反射的核心类，可以获取类的属性，方法等信息

Field类：Java.lang.reflec包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值

Method类：Java.lang.reflec包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法

Constructor类：Java.lang.reflec包中的类，表示类的构造方法

2.2.反射使用步骤

获取想要操作的类的Class对象，它是反射的核心，通过Class对象我们可以任意调用类的方法

调用Class类中的方法，就是反射的使用阶段

使用反射API来操作这些信息

获取class对象的三种方法

调用某个对象的getClass()方法

Person p = new Person();
Class clazz=p.getClass();

调用某个类的class属性来获取该类对应的Class对象

Class clazz=Person.class;

使用Class类中的forName()静态方法(最安全/性能最好/最常用)

Class clazz=Class.forName("类的全路径");

创建对象的两种方法

Class对象的newlnstance()：使用Class对象的newIlnstance()方法来创建该Class对象对应类的实例，但是这种方法要求该Class对象对应的类有默认的空构造器

调用Constructor对象的newlnstance()：先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建Class对象对应类的实例，通过这种方法可以选定构造方法创建实例

Class clazz=Class.forName("reflection.Person");
//使用.newInstane方法创建对象
Person p=(Person) clazz.newlnstance();
//获取构造方法并创建对象
Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class);//创建对象并设置属性
Person p1=(Person)c.newInstance("李四","男",20);

通过反射获取和设置对象私有字段的值

可以通过类对象的.getDeclaredField()方法获取字段(Field)对象，然后再通过字段对象的setAccessible(true)将其设置为可以访问，接下来就可以通过get/set方法来获取/设置字段的值了

通过反射调用对象的方法

通过类对象的.getMethod()来获取方法对象，然后调用方法对象的.invoke方法

Class userServiceClass=Class.forName("com.xin.bean.UserService");
//创建对象
Object obj=userServiceClass.newInstance();
//获取Method
Method loginMethod=userServiceClass.getDeclaredMethod("login",String.class,String.class);
Object value=loginMethod.invoke(obj,"user","1232");
System.out.println(value);

获取反射对象的注解

Class.getAnnotations()：获取所有的注解，包括自己声明的以及继承的

Class.getAnnotation(Class< A > annotationClass)：获取指定的注解，该注解可以是自己声明的，也可以是继承的

Class.getDeclaredAnnotations()：获取自己声明的注解

获取反射对象的方法

getMethods()：获取自身能用的所有的公共方法，获取当前类或父类或父接口的public修饰的字段，包含父接口中default修饰的方法

getDeclaredMethods()：获取当前类的所有方法，包括protected/默认/private修饰的方法，不包括父类 、接口public修饰的方法

java反射-基础语法

一、java反射的定义

 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的以及动态调用对象的方法的功能称为Java的反射机制。

二、java反射的应用场景

1、反编译

2、框架

三、基础代码

1、获取class的三种方式

    // 通过class属性
    String.class.getName();
    String s = "Hello Word!";
    // 通过getClass方法
    System.out.println(s.getClass().getName());
    String sClass = "java.lang.String";
    try {
        // 通过Class的forName的静态方法
        System.out.println(Class.forName(sClass).getName());
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
        

2、获取class的构造器，来新建实例

实体类如下：

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

        public Person() {

        }

        private Person(String name) {
            this.name = name;
        }

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        private Person(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }

    }

 

（1）获取所有的构造器

        // 获取所有构造器
        Person p = new Person();
        Class pClass = p.getClass();
        Constructor[] Constructors = pClass.getDeclaredConstructors();
        for (int i = 0; i < Constructors.length; i++) {
            System.out.println(Modifier.toString(Constructors[i].getModifiers()));
            System.out.println(Constructors[i].getParameterTypes().getClass().getName());
        }

（2）获取无参构造

        Person p = new Person();
        Class pClass = p.getClass();

        try {
            Constructor constructors = pClass.getDeclaredConstructor();
            System.out.println(Modifier.toString(constructors.getModifiers()));
            System.out.println(constructors.getParameterTypes().getClass().getName());
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

（3）根据构造器中不同的参数，获取不同的构造器

        Person p = new Person();
        Class pClass = p.getClass();
        Class[] classArray = new Class[] { String.class, int.class };
        try {
            Constructor constructor = pClass.getDeclaredConstructor(classArray);
            constructor.setAccessible(true);
            Person person = (Person) constructor.newInstance("wsq", 12);
            System.out.println(person.toString());
            System.out.println(Modifier.toString(constructor.getModifiers()));
            System.out.println(constructor.getParameterTypes().getClass().getName());
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

3、通过构造器获取实例对象，并获取私有方法和属性

 // 内部类
static class Person{
    private String name;
    private int age;
    private Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    private void getName() {
        System.out.println(this.name);
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
}

// 获取私有方法
public static void main(String[] args) throws Exception{
    // 获取构造器之后获取私有方法
    Class pClass = Person.class;
    // 参数
    Class[] paramType = {String.class, int.class};
    Constructor constructor = pClass.getDeclaredConstructor(paramType);
    constructor.setAccessible(true);
    Person p = (Person) constructor.newInstance("wsq",18);
    // 获取私有方法
    Method method = pClass.getDeclaredMethod("getName", null);
    method.setAccessible(true);
    method.invoke(p, null);
    // 获取私有属性
    Field field = pClass.getDeclaredField("name");
    field.setAccessible(true);
    field.set(p, "wsq2");
    System.out.println(p.toString());
    
}