javaSE-反射

最新推荐文章于 2022-03-23 15:11:42 发布
最新推荐文章于 2022-03-23 15:11:42 发布
阅读量192 收藏
点赞数
分类专栏： javaSE笔记 文章标签： java 反射 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40668912/article/details/109903400
版权

关联知识

在存在的编程语言中，大致分为动态语言与静态语言这两种。其中静态语言的代表是c，c++等，动态语言的代表则是js，python等。这两种语言的区别有很多，其中最重要的几点如下：

  • 静态语言的运行速度要比动态语言更快。
  • 动态语言的学习成本低于静态语言。
  • 动态语言的开发效率要高于静态语言。
  • …
    java是介于静态语言与动态语言之间的一门编程语言。它在书写后，需要先进行编译，这是静态语言的特性，编译后生成字节码文件，运行时jvm会将字节码文件加载到内存中，jvm会对字节码文件进行解释执行，这是动态语言的特性。其实，在真实的java环境，要比这些更加复杂。

反射简介

java的反射其实就是java程序在运行时动态的操作java代码的一门技术。通过这门技术，我们可以在运行时分析类的信息与结构，也可以在运行时检查对象等。java反射是功能十分强大的一门技术，虽然我们平时开发时并不会经常用到它，但反射却是框架最基层的一门技术。学习好反射，利于后期学习各种框架。

Class类的简介与获取

  1. Class类是java十分重要的一个类，我们想要使用反射，那就离不开这个类。
  2. 当jvm加载一个class文件后，就会在内存中生成一个与之相对应的Class对象，这个对象保存着该class文件的全部信息。
  3. 同一类型的多个实例对象，它们的Class对象都是同一个，即在内存中，每一个Class对象都是独一无二的。
  4. Class对象的获取方式
  • 使用Class类的静态发放forName。如 Class c1 = Class.forName("java.lang.String");
  • 使用完整类名.class获取，如 Class c2 = String.class;
  • 使用实例对象的getClass()方法获取，如Class c3 = "sssss".getClass();
  • 基本数据类型可是使用类型名.TYPE获取。
    示例代码如下：
/**
 * @Classname Demo1
 * @Date 2020/11/21 12:13
 * @author hzq
 */
package com.hzq.reflection;

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("java.lang.String");
        Class c2 = String.class;
        Class c3 = "sssss".getClass();
        Class c4 = "wwwww".getClass();
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c3.equals(c4));
        //输出结果
//        class java.lang.String
//        class java.lang.String
//        class java.lang.String
//        class java.lang.String
//        true
    }
}

Class对象的使用

当我们获取了Class对象后，就可以通过调用Class对象的各种发放来对这个java类进行各种操作了。常见的操作有通过Class对象新建一个java类实例对象，操作字段，操作方法，获取各种信息等。

1. 新建对象

通过反射新建对象的方式有两种，方式1是通过Class对象调用newInstance()方法，该方法要求类必须有公共级别的无参构造器。方式2是通过Class对象调用getConstructor()方法获取该类的构造器，通过传入不同的参数来获取指定的构造器对象，然后通过构造器对象调用newInstance()方法来新建对象。
demo如下：

/**
 * @Classname Demo2
 * @Date 2020/11/21 12:58
 * @author hzq
 */
package com.hzq.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> c1 = Class.forName("com.hzq.reflection.User");
        //方式1
        User o1 = (User) c1.newInstance();
        //方式2
        Constructor<?> constructor = c1.getConstructor();
        User o2 = (User) constructor.newInstance(null);
        System.out.println(o1);
        System.out.println(o2);
        //输出结果
//        User{name='null', age=null, sex='null'}
//        User{name='null', age=null, sex='null'}
    }
}

class User{
    private String name;
    private Integer age;
    private String sex;

    public User() {
    }

    public User(String name, Integer age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

2. 操作类的字段

demo示例：

/**
 * @Classname Demo3
 * @Date 2020/11/21 13:14
 * @author hzq
 */
package com.hzq.reflection;

import java.lang.reflect.Field;

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class<?> c1 = Class.forName("com.hzq.reflection.User");
        System.out.println("获取全部public字段,包括继承来的");
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
        System.out.println("获取全部字段(不包括继承来的)");
        fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
        System.out.println("获取指定字段");
        Field name = c1.getDeclaredField("name");
        System.out.println(name.getName());
        System.out.println("给通过反射创建的对象设置字段值");
        Field age = c1.getDeclaredField("age");
        Field sex = c1.getDeclaredField("sex");
        User o = (User) c1.newInstance();
        //因为字段都为private级别,不可以直接访问,所以我们需要关闭访问检查
        name.setAccessible(true);
        age.setAccessible(true);
        sex.setAccessible(true);
        name.set(o,"小明");
        sex.set(o,"男");
        age.set(o,18);
        System.out.println(o);
        System.out.println("获取字段name与age的类型");
        Class<?> c2 = name.getType();
        Class<?> c3 = age.getType();
        System.out.println(c2);
        System.out.println(c3);
    }
    //输出结果
//    获取全部public字段,包括继承来的
//    获取全部字段(不包括继承来的)
//    name
//    age
//    sex
//    获取指定字段
//    name 
//    给通过反射创建的对象设置字段值
//    User{name='小明', age=18, sex='男'}
//    获取字段name与age的类型
//    class java.lang.String
//    class java.lang.Integer

}

3.操作类的方法（包含构造方法）

demo示例：

/**
 * @Classname Demo4
 * @Date 2020/11/21 15:58
 * @author hzq
 */
package com.hzq.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Demo4 {
    public static void main(String[] args) throws Exception{
        Class<?> c1 = Class.forName("com.hzq.reflection.User");
        //获取构造方法
        Constructor<?> constructor = c1.getConstructor(String.class, Integer.class, String.class);
        System.out.println("通过反射获取构造方法来创建对象");
        User o = (User) constructor.newInstance("小红", 18, "女");
        System.out.println(o);
        System.out.println("获取类的全部方法对象,然后全部调用");
        Method[] methods = c1.getDeclaredMethods();
        //对方法对象的集合进行排序,是的set方法先被调用,然后再调用get方法
        List<Method> collect = Arrays.stream(methods).filter(e -> {
            if (e.getName().contains("set") || e.getName().contains("get")) {
                if (e.getName().contains("getClass")) {
                    return false;
                }
                return true;
            } else {
                return false;
            }
        }).sorted((x,y)->{
            if (x.getName().contains("set")){
                return -1;
            }else {
                return 1;
            }
        }).collect(Collectors.toList());
        //对方法集合进行遍历调用
        for (Method method : collect) {
            String name = method.getName();
            if (name.contains("set")){
                if (name.contains("Name")){
                    method.invoke(o,"小白");
                }else if (name.contains("Age")){
                    method.invoke(o,22);
                }else {
                    method.invoke(o,"男");
                }
            }else if (name.contains("get")){
                Object value = method.invoke(o);
                System.out.println(value);
            }
        }
        //输出结果
//        通过反射获取构造方法来创建对象
//        User{name='小红', age=18, sex='女'}
//        获取类的全部方法对象,然后全部调用
//        小白
//        22
//        男

    }
}

4. 与注解配合使用

demo示例：

/**
 * @Classname Demo5
 * @Date 2020/11/21 16:27
 * @author hzq
 */
package com.hzq.reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Demo5 {
    public static void main(String[] args) throws Exception{
        Class<?> c1 = Class.forName("com.hzq.reflection.Person");
        //获取全部类注解
        Annotation[] annotations = c1.getDeclaredAnnotations();
        for (Annotation annotation : annotations) {
            //找出我们自定义的注解
            if (annotation instanceof MyAnnotationType){
                MyAnnotationType annotationType = (MyAnnotationType) annotation;
                //输出注解的属性
                System.out.println(annotationType.tableName());
            }
        }
        //获取全部字段
        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            //获取字段上的注解
            MyAnnotationField annotation = field.getAnnotation(MyAnnotationField.class);
            //输出注解属性
            System.out.println(annotation.fieldName());
        }
    }
    //输出结果
//    db_person
//    db_name
//    db_age
//    db_sex

}

/**
 * @author admin
 * 标注在字段上的注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotationField {
    String fieldName();
}

/**
 * @author admin
 * 标注在类上的注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotationType {
    String tableName();
}

@MyAnnotationType(tableName = "db_person")
class Person{
    @MyAnnotationField(fieldName = "db_name")
    private String name;
    @MyAnnotationField(fieldName = "db_age")
    private Integer age;
    @MyAnnotationField(fieldName = "db_sex")
    private String sex;

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

ps：特别注意

  1. getDeclaredxxx方法获取的是只属于该类的全部方法或字段，getxxx方法获取的是该类全部公共访问权限的方法或字段，不包含私有的。
  2. 如果获取的字段或方法对象是私有的，无法直接进行访问，应该先关闭权限检查机制，调用setAccessible(true)方法并传入true进行关闭。
潇湘夜雨灬奇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java中的反射
weixin_30399797的博客
01-18 118
主要介绍以下几方面内容 理解 Class 类 理解 Java 的类加载机制 学会使用 ClassLoader 进行类加载 理解反射的机制 掌握 Constructor、Method、Field 类的用法 理解并掌握动态代理 1.理解Class类 　　–对象照镜子后可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其...
JavaSE-反射
Destiny的博客
01-14 169
反射 获得Class的方式 （1）通过对象调用getClass()方法（使用少） Student student = new Student; Class class = student.getClass(); （2）直接通过类名.class Class class = Student.class; （3）通过Class对象的forName()静态方法（使用多） Class class = C...
JavaSE之反射
金鳞踏雨
01-29 685
反射 反射机制概述 是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意属性和方法； 这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。 获取Class类对象的三种方式 类名.class属性 对象名.getClass()方法 Class.forName(全类名)方法 ...
JavaSE-注解与反射(框架底层实现机制)
12-21
注解（Annotation）JDK5.0引入 内置注解： @Override：重写方法 @Deprecated：废弃 @SuppressWarnings：镇压警告 元注解(meta-annotation)： 可自定义注解 @Target：描述注解的使用范围，传入value...反射（框架设计的
JavaSE进阶-08-反射机制1
08-03
1.1 反射的基本概念 1.2 Java 中的类反射 2.2.1 2.2.2
一、JavaSE-（Java基础）
03-01
1. Java基础语法阶段：包、注释、编码规范、if语句、循环、函数、数组 2. 面向对象编程阶段：面向对象编程思想、封装、继承、多态...3. API(Application Programing Interface)：集合、I/O、线程、异常、反射、设计模式
JavaSE 高级反射-JVM篇.xmind
09-12
JavaSE 高级反射-JVM篇
JavaSE反射详解.ppt
06-08
JavaSE反射详解
JavaSE——反射
weixin_43816266的博客
03-18 141
Java反射的概念是Java框架的灵魂，在Spring，SpringBoot的框架中就用到了大量的反射概念。
JavaSE 第十八章 反射
技术小白
03-23 612
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任 何类的内部信息，并能直接操作任意对象的内部属性及方法。 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这 个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子， 透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 动态语言 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被
Java之反射
qq_45834459的博客
01-26 172
一、反射的概述 1. 反射的简介 1.Reflection（反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 2.加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 通常的方式：引入需要的“包类”名称---->
JavaSE基础之反射
邢宇超的博客
04-17 929
->理解 Class 类 ->理解 Java 的类加载机制 ->学会使用 ClassLoader 进行类加载 ->理解反射的机制 ->掌握 Constructor、Method、Field 类的用法 ->理解并掌握动态代理  Class 类 对象照镜子后可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的
JavaSE——反射机制
weixin_34384681的博客
09-26 116
2019独角兽企业重金招聘Python工程师标准>>> ...
java se反射
lemon_cai
06-16 396
1 在java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于java语言的反射(Reflection)机制。 2 java反射机制主要提供了一下功能     -在运行时判断任意一个对象所属的类。     - 在运行时构造任意一个类的对象。     -在运行时判断任
JavaSE 反射
ReverieZH的博客
09-22 138
Java反射说的是在运行状态中，对于任何一个类，我们都能够知道这个类有哪些方法和属性。对于任何一个对象，我们都能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 通过反射机制，程序员可以更深入地控制程序的运行过程 Class类 所有类均继承Object类，在Object类中定义了一个getClass()方法，该方法返回一个类型为Class的对象。 Clas...
javase 面试题
最新发布
09-01
10. 什么是Java中的反射（Reflection）？它有什么作用？ 这只是一小部分可能的JavaSE面试题，具体问题还会根据面试官和职位要求而有所变化。在准备面试时，建议你对JavaSE的基本概念、语法、常用类库和常见问题有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值