重拾Java(8)-反射

Java 在需要使用到某个类时会载入 .class 文档,在 JVM 产生 Java.lang.Class 实例代表该文档,从 Class 实例开始,就可以获得类的许多类型。 .class 文档反映了类基本信息,因而从 Class 等API取得类信息的方法就称为反射

一、Class与.class文档

Java 在真正需要某个类时才会加载对应的 .class 文档,而非在程序启动时就加载所有类,因为大部分时候我们只需要用到应用程序部分资源,有选择地加载可以节省系统资源 java.lang.Class 的实例代表 Java 应用程序运行时加载的 .class 文档,类、接口、Enum等编译过后,都会生成 .class 文档,所以 Class可以用来包含类、接口、Enum等信息 Class 类没有公开的构造函数,实例是由 JVM 自动产生,每个 .class 文档加载时, JVM 会自动生成对应的 Class 对象 可以通过 Object 的 getClass() 方法或者通过 .class 常量取得每个对象对应的 Class 对象。如果是基本类型,可以使用对象的包装类加载 .TYPE 取得 Class 对象 例如,使用 Integer.TYPE 可取得代表 int 基本类型的 Class,通过 Integer.class 取得代表 Integer.class 文档的 Class

在取得 Class 对象后,就可以操作 Class 对象的公开方法取得类基本信息 例如

package com.czy.demo;

public class Student {
    
    public static void main(String[] args) {
        Class cl=Student.class;
        System.out.println("类名称:"+cl.getName());
        System.out.println("简单类名称:"+cl.getSimpleName());
        System.out.println("包名:"+cl.getPackage());
        System.out.println("是否为接口:"+cl.isInterface());
        System.out.println("是否为基本类型:"+cl.isPrimitive());
        System.out.println("是否为数组对象:"+cl.isArray());
        System.out.println("父类名称:"+cl.getSuperclass().getName());
    }

}

输出结果为

类名称:com.czy.demo.Student
简单类名称:Student
包名:package com.czy.demo
是否为接口:false
是否为基本类型:false
是否为数组对象:false
父类名称:java.lang.Object

Java 在真正需要类时才会加载 .class 文档,即在生成对象时才会加载 .class 文档。如果只是使用类声明了一个变量,此时并不会加载.class文档,而只是让编译程序检查对应的 .class 文档是否存在

例如,在 Stduent 类中定义了 static 静态区域块,在首次加载 .class 文档时会被执行(这是默认情况下,也可以指定不执行)

public class Student {
    
    static {
        System.out.println("载入了 Student.class 文档");
    }
    
}

再来测试加载顺序

package com.czy.demo;

public class Main {
    
    public static void main(String[] args) {
        Student student;
        System.out.println("声明了 Student 变量");
        student=new Student();
        System.out.println("生成了 Student 实例");
    }
    
}

输出结果为

声明了 Student 变量
载入了 Student.class 文档
生成了 Student 实例

二、使用Class.forName()

在某些情况下,会存在事先不知道类名称,需要事后指定类名称来动态加载类的情况 可以使用 Class.forName() 方法实现动态加载类,用字符串指定类名称来获得类相关信息

package com.czy.demo;

public class Main {
    
    public static void main(String[] args) {
        try{
            Class cl=Class.forName("java.lang.String");
            System.out.println("类名称:"+cl.getName());
            System.out.println("简单类名称:"+cl.getSimpleName());
            System.out.println("包名:"+cl.getPackage());
            System.out.println("是否为接口:"+cl.isInterface());
            System.out.println("是否为基本类型:"+cl.isPrimitive());
            System.out.println("是否为数组对象:"+cl.isArray());
            System.out.println("父类名称:"+cl.getSuperclass().getName());
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
    }
    
}

输出结果

类名称:java.lang.String
简单类名称:String
包名:package java.lang, Java Platform API Specification, version 1.8
是否为接口:false
是否为基本类型:false
是否为数组对象:false
父类名称:java.lang.Object

Class.forName() 另一重载版本可以指定类名称、加载类时是否执行静态区域块、类加载器

    public static Class<?> forName(String name, boolean initialize, ClassLoader loader)

例如 还是使用 Student 类

package com.czy.demo;

public class Student {
    
    static {
        System.out.println("执行静态区域块");
    }
    
}

测试调用顺序

public class Main {
    
    public static void main(String[] args) {
        try{
            Class cl=Class.forName("com.czy.demo.Student",false,Main.class.getClassLoader());
            System.out.println("已载入class文档");
            Student student;
            System.out.println("声明了Student变量");
            student=new Student();
            System.out.println("生成Student实例");
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
    }
    
}

输出结果

已载入class文档
声明了Student变量
执行静态区域块
生成Student实例

由于指定了加载类时不执行静态区域块,所以在建立了 Stduent 实例后,静态区域块才被执行。类加载器则是使用 Main.class 文档的类加载器

因此,只有一个参数的 Class.forName(String name) 方法,等同于

   Class.forName(className,  true,  currentLoader)

即默认加载静态区域块,使用当前类的类加载器来载入类

三、从Class获得信息

Class对象代表加载的.class文档,取得Class对象后,就可以取得.class文档中记载的信息,如包、构造函数、数据成员、方法成员等 每一种信息都对有对应的类型,如包对应的类型是 java.lang.Package,构造函数对应的类型是 java.lang.reflect.Constructor

例如,先来为Student类增添多种类型的不同信息

package com.czy.demo;

public final class Student {
    
    enum Gender{
        male,female
    }
    
    private String name;
    
    public int age;
    
    protected Gender gender;
    
    public Student(String name,int age){
        
    }
    
    public Student(String name,int age,Gender gender){
        
    }
    
    private Student(){
        
    }
    
    public String getName() {
        return name;
    }
    
    private int getAge(){
        return age;
    }
    
    protected Gender getGender(){
        return gender;
    }
    
}

再来获取各种信息

public class Main {

    public static void main(String[] args) {
        try {
            Class cl = Class.forName("com.czy.demo.Student");
            
            // 取得包对象
            Package p = cl.getPackage();
            System.out.println("包名:" + p.getName());
            // 访问修饰符
            int modifier = cl.getModifiers();
            System.out.println("类访问修饰符:" + Modifier.toString(modifier));

            System.out.println();
            
            //取得构造函数信息
            Constructor[] constructors=cl.getConstructors();
            for(Constructor constructor:constructors){
                System.out.print("访问修饰符:" + Modifier.toString(constructor.getModifiers()));
                System.out.print("   构造函数名:"+constructor.getName());
                System.out.println();
            }
            
            System.out.println();
            
            //取得声明的数据成员
            Field[] fields = cl.getDeclaredFields();
            for (Field field : fields) {
                System.out.print("访问修饰符:" + Modifier.toString(field.getModifiers()));
                System.out.print("   类型:"+field.getType().getName());
                System.out.print("   成员名:"+field.getName());
                System.out.println();
            }
            
            System.out.println();
            
            //取得成员方法息
            Method[] methods=cl.getDeclaredMethods();
            for(Method method:methods){
                System.out.print("访问修饰符:" + Modifier.toString(method.getModifiers()));
                System.out.print("   返回值类型:"+method.getReturnType().getName());
                System.out.print("   方法名:"+method.getName());
                System.out.println();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

运行结果

包名:com.czy.demo
类访问修饰符:public final

访问修饰符:public   构造函数名:com.czy.demo.Student
访问修饰符:public   构造函数名:com.czy.demo.Student

访问修饰符:private   类型:java.lang.String   成员名:name
访问修饰符:public   类型:int   成员名:age
访问修饰符:protected   类型:com.czy.demo.Student$Gender   成员名:gender

访问修饰符:public   返回值类型:java.lang.String   方法名:getName
访问修饰符:private   返回值类型:int   方法名:getAge
访问修饰符:protected   返回值类型:com.czy.demo.Student$Gender   方法名:getGender

四、利用Class建立对象

如果已有确切的类,那么就可以使用new关键字建立实例。如果不知道类名称,那么可以利用Class.forName() 动态加载.class文档,取得Class对象之后,利用其newInstance()方法建立实例

        Class cl=Class.forName("ClassName");
        Object object=cl.newInstance();

这种事先不知道类名称,又需要建立类实例的需求,一般情况下都是由于开发者需要得到某个类对象并对其行为进行操纵,可是该类又是由他人开发且还未完工,因此就需要来动态加载.class文档

例如,你需要来控制学生、老师或者家长的唱歌行为,可是学生、老师和家长这些类又是由其他人来设计的,你只是对开始与暂停操作进行控制 那么,你可以规定学生类必须实现Sing接口

public interface Sing {
    
    void start();
    
}

那么,就可以来进行自己的开发了,将动态加载的对象强转为Sing

public class Main {

    public static void main(String[] args) {
        try {
            Sing palyer = (Sing) Class.forName("className").newInstance();
            palyer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

}

然后规定他人设计的学生类必须实现Sing接口

package com.czy.demo;

public class Student implements Sing {

    @Override
    public void start() {
        System.out.println("学生唱歌");
    }

}

这样,等到得到确切的类名称后,修改main方法的className即可

public static void main(String[] args) {
        try {
            Sing palyer = (Sing) Class.forName("com.czy.demo.Student").newInstance();
            palyer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

五、操作成员方法

java.lang.reflect.Method 实例是方法的代表对象,可以使用 invoke() 方法来动态调用指定的方法

例如,修改Student类,将get方法都指定为公有的,将set方法指定为私有的

package com.czy.demo;

public class Student {

    private String name;

    private int age;

    public Student() {

    }

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

    public String getName() {
        System.out.println("调用了getName方法,Name:" + name);
        return name;
    }

    public int getAge() {
        System.out.println("调用了getAge方法,Age:" + age);
        return age;
    }

    private void setName(String name) {
        this.name = name;
        System.out.println("调用了setName方法,name:" + name);
    }

    private void setAge(int age) {
        this.age = age;
        System.out.println("调用了setAge方法,age:" + age);
    }

}

一般情况下,类的私有方法只有在其内部才可以被调用,通过反射我们可以来突破这一限制

首先来调用公有方法

public class Main {

    public static void main(String[] args) throws Exception {
        Class cl = Class.forName("com.czy.demo.Student");
        // 指定构造函数
        Constructor constructor = cl.getConstructor(String.class, Integer.TYPE);
        // 根据指定的构造函数来获取对象
        Object object = constructor.newInstance("叶", 22);

        // 指定方法名称来获取对应的公开的Method实例
        Method getName = cl.getMethod("getName");
        // 调用对象object的方法
        getName.invoke(object);

        // 指定方法名称来获取对应的公开的Method实例
        Method getAge = cl.getMethod("getAge");
        // 调用对象object的方法
        getAge.invoke(object);

    }

}

输出结果如下所示,可以知道Student对象的两个get方法成功被调用了

调用了getName方法,Name:叶
调用了getAge方法,Age:22

受保护或私有方法的调用步骤略有不同

public class Main {

    public static void main(String[] args) throws Exception {
        Class cl = Class.forName("com.czy.demo.Student");
        // 指定构造函数
        Constructor constructor = cl.getConstructor(String.class, Integer.TYPE);
        // 根据指定的构造函数来获取对象
        Object object = constructor.newInstance("叶", 22);

        // 指定方法名称来获取对应的私有的Method实例
        Method setName = cl.getDeclaredMethod("setName", String.class);
        setName.setAccessible(true);
        setName.invoke(object, "新的名字");
        
        // 指定方法名称来获取对应的私有的Method实例
        Method setAge = cl.getDeclaredMethod("setAge", Integer.TYPE);
        setAge.setAccessible(true);
        setAge.invoke(object, 23);
    }

}

输出结果如下所示,可以看到私有方法一样在外部被调用了

调用了setName方法,name:新的名字
调用了setAge方法,age:23

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏好好学java的技术栈

Java提升篇:对象克隆(复制)

1133
来自专栏用户2442861的专栏

Java反射探索-----从类加载说起

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

391
来自专栏云霄雨霁

Java虚拟机--方法调用

1685
来自专栏java工会

java反射机制

1728
来自专栏LIN_ZONE

java反射机制的简单使用

通过上面的代码可以获得 运行时类的对象,然后下面使用运行时类的对象来构造一个反射工具类,通过下面这个类 可以利用反射机制实例化该类的对象,设置对象的属性并调用对...

712
来自专栏微信公众号:Java团长

Java提高篇——对象克隆(复制)

不仅仅是int类型,其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。

1083
来自专栏架构说

c 语言基础知识之一

Q1 : 今天看redis代码 普通的函数都添加static 修改 static int aeApiCreate(aeEventLoop *eventLoop...

26211
来自专栏平凡文摘

深入理解Java类型信息(Class对象)与反射机制

1013
来自专栏wblearn

java反射技术

想必开发过接口的童鞋们,应该或多或少写过一些接口说明文档。那么,有没有可能把现有的接口做成一个界面在页面展现出来而不用去写什么接口文档,在页面展示的信息包括接口...

772
来自专栏闻道于事

问题整理

  相关子查询,无关子查询 所谓相关子查询,是指求解相关子查询不能像求解普通子查询那样,一次将子查询求解出来,然后求解父查询。相关子查询的内层查询由于与外层查询...

2744

扫码关注云+社区