什么是Java反射呢？

最新推荐文章于 2024-09-06 18:09:12 发布

.-残念-.

最新推荐文章于 2024-09-06 18:09:12 发布

阅读量224

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_52617676/article/details/131733325

版权

本文介绍了Java反射机制的基本概念和用途，包括在运行时获取类信息、构造对象、访问字段和调用方法的能力。详细讲解了Class类、Constructor类和Method类的使用，以及如何通过反射进行动态代理实现。

摘要由CSDN通过智能技术生成

一.反射的定义，用途

1.反射的定义

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

2.反射的用途

（1）在运行时判断任意一个对象所属的类；

（2）在运行时构造任意一个类的对象；

（3）在运行时判断任意一个类所具有的成员变量和方法；

（4）在运行时调用任意一个对象的方法

（5）在生成动态代理。

二.反射的常用类和方法

1.Class类

想要知道一个类的属性和方法，必须先获取到该类的字节码文件对象。获取类的信息时，使用的就是Class类中的方法。所有先要获取到每一个字节码文件对应的Class类型的对象。

由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名，包名，父类，实现的接口，所有方法，字段（成员变量）等。因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class所有信息。这种通过Class实例获取class信息的方法成为反射。

public class Doem1 {
    public static void main(String[] args) {
        //父类
        Class superClass = FileInputStream.class.getSuperclass();
        System.out.println("父类："+superClass.getName());
        System.out.println("爷类："+superClass.getSuperclass().getName());

        System.out.println("实现接口");
        //接口
        Class[] interfaceClassArray = MyStringComparator.class.getInterfaces();
        for (Class inf : interfaceClassArray){
            System.out.println(inf.getName());
        }
    }
}
abstract class MyStringComparator implements Comparable{

}

 public static void main(String[] args) {
        //instanceof 运算符：判断”引用“和”类型“之间关系
        Object obj = Double.valueOf(9527);
        System.out.println("是否为Integer:"+(obj instanceof Integer));
        System.out.println("是否为Double:"+(obj instanceof Double));
        System.out.println("是否为Number:"+(obj instanceof Number));
        System.out.println("是否为Comparable:"+(obj instanceof Comparable));

        //  A.class.isAssignableFrom(B.class)    B能否赋值于A
        System.out.println("Integer=>Integer:"+Integer.class.isAssignableFrom(Integer.class));
        System.out.println("Number=>Integer:"+Integer.class.isAssignableFrom(Number.class));
        System.out.println("Integer=>Number:"+Number.class.isAssignableFrom(Integer.class));
        System.out.println("Integer=>Double:"+Double.class.isAssignableFrom(Integer.class));
        System.out.println("Integer=>Comparable:"+Comparable.class.isAssignableFrom(Integer.class));
    }

2.访问字段

Class类提供了以下几个方法来获取字段：

（1）Fied getField(name):根据字段名获取当前类中的某个public的field（包括父类）；

（2）Field getDeclared(name):根据字段名获取当前类中定义的某个field（不包括父类）；

（3）Field getFields():获取所有public的field（包括父类）；

（4）Field[ ] getDeclaredFields():获取当前类中定义的所有field（不包括父类）。

//访问操作：访问字段(成员变量)
//每个字段都会被封装成一个Field对象
public class Doem3 {
    public static void main(String[] args) {
        Class cls = Book.class;

        //所有public访问修饰符定义的字段
        //Field[] fields = cls.getFields();

        //所有定义的字段
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields){
            System.out.println("成员变量访问修饰符(int):"+field.getModifiers());
            System.out.println("成员变量访问修饰符:"+ Modifier.toString(field.getModifiers()));
            System.out.println("成员变量类型:"+field.getType());
            System.out.println("成员变量名称:"+field.getName());
            System.out.println();
        }
    }
}
class Book{
    public String BookName;
    private double Price;

    @Override
    public String toString() {
        return "BookNnae:"+BookName+",Price:"+Price;
    }

    public String getBookName() {
        return BookName;
    }

    public void setBookName(String bookName) {
        BookName = bookName;
    }

    public double getPrice() {
        return Price;
    }

    public void setPrice(double price) {
        Price = price;
    }

    public String dosth(int a,double b,String c){
        return "返回值";
    }

    public void dosthing(){

    }
}

public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchFieldException {
        //编译器完成对象类型和成员变量访问
        //Book book = new Book();
        //book.bookName = "葫芦娃大战金刚";

        //运行期
        //使用发射的方式，完成成员变量保存值
        Class cls = Book.class;//获取Class类型对象
        Object obj = cls.newInstance();//通过反射创建Book对象
        //按照字段名称，获取指定字段
        Field field1 = cls.getDeclaredField("BookName");

        //参数1：目标Book对象
        //参数2：存入成员变量中的值
        field1.set(obj,"复仇者联盟");
        System.out.println(obj);
    }

public static void main(String[] args) throws IllegalAccessException {
        Book book = new Book();
        book.setBookName("魔剑生死棋");
        book.setPrice(12.3);
        printInfo(book);
    }

    public static void printInfo(Object obj) throws IllegalAccessException {
        //输出参数对象的所有成员变量和值
        Class cls = obj.getClass();
        //获取本类中定义的所有成员变量
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields){
            System.out.println("成员变量名称:"+field.getName());
            //判断是否可以访问
            if (!field.isAccessible()){
                field.setAccessible(true);//设置私有成员变量允许访问
            }
            System.out.println("成员变量内容:"+field.get(obj));
        }
    }

3.Constructor类

为了调用任意构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例。Constructor对象是一个构造方法，调用结果总是返回实例：

（1）getConstructor(Class...):获取某个public的Constructor；

（2）getDeclaredConstructor(Class...):获取某个定义的Constructor；

（3）getConstructors():获取public的Constructor；

（4）getDeclaredConstructors(Class...):获取所有定义的Constructor；

public class Main {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取构造方法Integer(int)
        Constructor<Integer> cons1 = Integer.class.getConstructor(int.class);

        //调用有构造方法
        Integer n1 = (Integer) cons1.newInstance(123);
        System.out.println(n1);

        //获取构造方法Integer(String)
        Constructor cons2 = Integer.class.getConstructor(int.class);
        Integer n2 = (Integer) cons2.newInstance("456");
        System.out.println(n2);
    }

4.Method类

 //反射操作：获取方法
    //每一个方法都会被封庄成一个Method对象
    public static void main(String[] args) {
        Class cls = Book.class;

        //获取所有public方法(包括父类)
        //Method[] methods = cls.getMethods();

        //获取所有定义的方法(仅包括当前类)
        Method[] methods = cls.getDeclaredMethods();
        for (Method method : methods){
            System.out.println("方法的访问修饰符"+ 
            Modifier.toString(method.getModifiers()));
            System.out.println("方法的返回值类型:"+method.getReturnType());
            System.out.println("方法的名称:"+method.getName());

            //获取所有的参数类型
            //Class[] paramTypes = method.getParameterTypes();

            //获取所有的参数对象
            Parameter[] params = method.getParameters();
            for (Parameter p : params){
                System.out.println(p.getName());
                System.out.println(p.getType());
                System.out.println("-------------------------------------------------");
            }
        }
    }

//反射操作:调用方法
public class Doem7 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        //获取Class对象
        Class cls = Base.class;
        Object obj = cls.newInstance();

        //按照方法名称和”参数类型“获取Method方法对象
        //ceate()
        //Method method = cls.getMethod("create");

        //create(int x)
        Method method = cls.getMethod("create",int.class);

        //Methon对象的invoke()作用：
        //以反射的方式执行create()方法
        int r = (int)method.invoke(obj,1000);
        System.out.println(r);
    }
}
class Base{
    public int invod(){
        return create(100);
    }
    public int create(int a){
        int b = (int)(Math.random()*(a+1));
        return b;
    }

三.动态代理

public class Doem10 {
    public static void main(String[] args) {
        //接口的引用==>代理对象
        Subject subject = new SubjectProxy();
        subject.request();
    }
}
interface Subject{
    void request();
}
//真是主题
class RealSubject implements Subject{

    @Override
    public void request() {
        System.out.println("业务逻辑1");
        System.out.println("业务逻辑2");
        System.out.println("业务逻辑3");
    }
}
//代理类
 class SubjectProxy implements Subject{
    //目标对象
    private Subject target;
    public SubjectProxy(){
        target = new RealSubject();
    }

     @Override
     public void request() {
        //通过代理模式，扩展逻辑
         System.out.println("begin-------------------");
         target.request();
         System.out.println("end---------------------");
     }
 }