【大数据】学习笔记 1 Java SE 第16章反射 16.4 反射的基本应用

「爱情、让人受尽委屈。」 2024-03-22 14:32 128阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第16章 反射
             *   *  16.4 反射的基本应用
                 *   *  16.4.1 获取类型的详细信息
                     *  16.4.2 创建任意引用类型的对象
                     *  16.4.3 操作任意类型的属性
                     *  16.4.4 调用任意类型的方法

![在这里插入图片描述][fd4099a691a742198992aa37e013728d.png_pic_center]

#### 1 Java SE ####

##### 第16章 反射 #####

###### 16.4 反射的基本应用 ######

###### 16.4.1 获取类型的详细信息 ######

可以获取：包、修饰符、类型名、父类（包括泛型父类）、父接口（包括泛型父接口）、成员（属性、构造器、方法）、注解（类上的、方法上的、属性上的）

示例代码获取常规信息：

package com.dingjiaxiong.reflect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestClassInfo
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:41
     */
    
    public class TestClassInfo {
        
        public static void main(String[] args) throws Exception {
        
            //1、先得到某个类型的Class对象
            Class clazz = String.class;
            //比喻clazz好比是镜子中的影子
    
            //2、获取类信息
            //（1）获取包对象，即所有java的包，都是Package的对象
            Package pkg = clazz.getPackage();
            System.out.println("包名：" + pkg.getName());
    
            //（2）获取修饰符
            //其实修饰符是Modifier，里面有很多常量值
            /*
             * 0x是十六进制
             * PUBLIC           = 0x00000001;  1    1
             * PRIVATE          = 0x00000002;  2	10
             * PROTECTED        = 0x00000004;  4	100
             * STATIC           = 0x00000008;  8	1000
             * FINAL            = 0x00000010;  16	10000
             * ...
             *
             * 设计的理念，就是用二进制的某一位是1，来代表一种修饰符，整个二进制中只有一位是1，其余都是0
             *
             * mod = 17          0x00000011
             * if ((mod & PUBLIC) != 0)  说明修饰符中有public
             * if ((mod & FINAL) != 0)   说明修饰符中有final
             */
            int mod = clazz.getModifiers();
            System.out.println("类的修饰符有：" + Modifier.toString(mod));
    
            //（3）类型名
            String name = clazz.getName();
            System.out.println("类名：" + name);
    
            //（4）父类，父类也有父类对应的Class对象
            Class superclass = clazz.getSuperclass();
            System.out.println("父类：" + superclass);
    
            //（5）父接口们
            System.out.println("父接口们：");
            Class[] interfaces = clazz.getInterfaces();
            for (Class iter : interfaces) {
        
                System.out.println(iter);
            }
    
            //（6）类的属性，  你声明的一个属性，它是Field的对象
    /*		Field clazz.getField(name)  根据属性名获取一个属性对象，但是只能得到公共的
            Field[] clazz.getFields();  获取所有公共的属性
            Field clazz.getDeclaredField(name)  根据属性名获取一个属性对象，可以获取已声明的
            Field[] clazz.getDeclaredFields()	获取所有已声明的属性
            */
    //        Field valueField = clazz.getDeclaredField("value");
    //		System.out.println("valueField = " +valueField);
    
            System.out.println("------------------------------");
            System.out.println("成员如下：");
            System.out.println("属性有：");
            Field[] declaredFields = clazz.getDeclaredFields();
            for (Field field : declaredFields) {
        
                //修饰符、数据类型、属性名
                int modifiers = field.getModifiers();
                System.out.println("属性的修饰符：" + Modifier.toString(modifiers));
    
                String name2 = field.getName();
                System.out.println("属性名：" + name2);
    
                Class<?> type = field.getType();
                System.out.println("属性的数据类型：" + type);
            }
            System.out.println("-------------------------");
            //（7）构造器们
            System.out.println("构造器列表：");
            Constructor[] constructors = clazz.getDeclaredConstructors();
            for (int i = 0; i < constructors.length; i++) {
        
                Constructor constructor = constructors[i];
                System.out.println("第" + (i + 1) + "个构造器：");
                //修饰符、构造器名称、构造器形参列表  、抛出异常列表
                int modifiers = constructor.getModifiers();
                System.out.println("构造器的修饰符：" + Modifier.toString(modifiers));
    
                String name2 = constructor.getName();
                System.out.println("构造器名：" + name2);
    
                //形参列表
                System.out.println("形参列表：");
                Class[] parameterTypes = constructor.getParameterTypes();
                for (Class parameterType : parameterTypes) {
        
                    System.out.println(parameterType);
                }
    
                //异常列表
                System.out.println("异常列表：");
                Class<?>[] exceptionTypes = constructor.getExceptionTypes();
                for (Class<?> exceptionType : exceptionTypes) {
        
                    System.out.println(exceptionType);
                }
                System.out.println();
            }
            System.out.println("---------------------------------");
            //(8)方法们
            System.out.println("方法列表：");
            Method[] declaredMethods = clazz.getDeclaredMethods();
            for (int i = 0; i < declaredMethods.length; i++) {
        
                Method method = declaredMethods[i];
                System.out.println("第" + (i + 1) + "个方法：");
                //修饰符、返回值类型、方法名、形参列表 、异常列表
                int modifiers = method.getModifiers();
                System.out.println("方法的修饰符：" + Modifier.toString(modifiers));
    
                Class<?> returnType = method.getReturnType();
                System.out.println("返回值类型:" + returnType);
    
                String name2 = method.getName();
                System.out.println("方法名：" + name2);
    
                //形参列表
                System.out.println("形参列表：");
                Class[] parameterTypes = method.getParameterTypes();
                for (Class parameterType : parameterTypes) {
        
                    System.out.println(parameterType);
                }
    
                //异常列表
                System.out.println("异常列表：");
                Class<?>[] exceptionTypes = method.getExceptionTypes();
                for (Class<?> exceptionType : exceptionTypes) {
        
                    System.out.println(exceptionType);
                }
                System.out.println();
            }
    
        }
    }

![在这里插入图片描述][4db3059302be4440a41da8b58ffce1c8.png_pic_center]

###### 16.4.2 创建任意引用类型的对象 ######

两种方式：

1、直接通过Class对象来实例化（要求必须有公共的无参构造）

2、通过获取构造器对象来进行实例化

方式一的步骤：

（1）获取该类型的Class对象（2）创建对象

方式二的步骤：

（1）获取该类型的Class对象（2）获取构造器对象（3）创建对象

> 如果构造器的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)

示例代码：

package com.dingjiaxiong.reflect;
    
    import org.junit.Test;
    
    import java.lang.reflect.Constructor;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestCreateObject
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:43
     */
    
    public class TestCreateObject {
        
        @Test
        public void test1() throws Exception {
        
    //        AtGuiguClass obj = new AtGuiguClass();//编译期间无法创建
    
            Class<?> clazz = Class.forName("com.atguigu.ext.demo.AtGuiguClass");
            //clazz代表com.atguigu.ext.demo.AtGuiguClass类型
            //clazz.newInstance()创建的就是AtGuiguClass的对象
            Object obj = clazz.newInstance();
            System.out.println(obj);
        }
    
        @Test
        public void test2() throws Exception {
        
            Class<?> clazz = Class.forName("com.atguigu.ext.demo.AtGuiguDemo");
            //java.lang.InstantiationException: com.atguigu.ext.demo.AtGuiguDemo
            //Caused by: java.lang.NoSuchMethodException: com.atguigu.ext.demo.AtGuiguDemo.<init>()
            //即说明AtGuiguDemo没有无参构造，就没有无参实例初始化方法<init>
            Object stu = clazz.newInstance();
            System.out.println(stu);
        }
    
        @Test
        public void test3() throws Exception {
        
            //(1)获取Class对象
            Class<?> clazz = Class.forName("com.atguigu.ext.demo.AtGuiguDemo");
            /*
             * 获取AtGuiguDemo类型中的有参构造
             * 如果构造器有多个，我们通常是根据形参【类型】列表来获取指定的一个构造器的
             * 例如：public AtGuiguDemo(String title, int num)
             */
            //(2)获取构造器对象
            Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);
    
            //(3)创建实例对象
            // T newInstance(Object... initargs)  这个Object...是在创建对象时，给有参构造的实参列表
            Object obj = constructor.newInstance("尚硅谷", 2022);
            System.out.println(obj);
        }
    }

###### 16.4.3 操作任意类型的属性 ######

（1）获取该类型的Class对象

Class clazz = Class.forName(“包.类名”);

（2）获取属性对象

Field field = clazz.getDeclaredField(“属性名”);

（3）如果属性的权限修饰符不是public，那么需要设置属性可访问

field.setAccessible(true);

（4）创建实例对象：如果操作的是非静态属性，需要创建实例对象

Object obj = clazz.newInstance(); //有公共的无参构造

Object obj = 构造器对象.newInstance(实参…);//通过特定构造器对象创建实例对象

（4）设置属性值

field.set(obj,“属性值”);

> 如果操作静态变量，那么实例对象可以省略，用null表示

（5）获取属性值

Object value = field.get(obj);

> 如果操作静态变量，那么实例对象可以省略，用null表示

示例代码：

package com.dingjiaxiong.reflect;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Student
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:44
     */
    
    public class Student {
        
        private int id;
        private String name;
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

package com.dingjiaxiong.reflect;
    
    import java.lang.reflect.Field;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestField
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:44
     */
    
    public class TestField {
        
        public static void main(String[] args) throws Exception {
        
            //1、获取Student的Class对象
            Class clazz = Class.forName("com.dingjiaxiong.reflect.Student");
    
            //2、获取属性对象，例如：id属性
            Field idField = clazz.getDeclaredField("id");
    
            //3、如果id是私有的等在当前类中不可访问access的，我们需要做如下操作
            idField.setAccessible(true);
    
            //4、创建实例对象，即，创建Student对象
            Object stu = clazz.newInstance();
    
            //5、获取属性值
            /*
             * 以前：int 变量= 学生对象.getId()
             * 现在：Object id属性对象.get(学生对象)
             */
            Object value = idField.get(stu);
            System.out.println("id = " + value);
    
            //6、设置属性值
            /*
             * 以前：学生对象.setId(值)
             * 现在：id属性对象.set(学生对象,值)
             */
            idField.set(stu, 2);
    
            value = idField.get(stu);
            System.out.println("id = " + value);
        }
    }

![在这里插入图片描述][81a9565eb0c8497facf088b0112641df.png_pic_center]

###### 16.4.4 调用任意类型的方法 ######

（1）获取该类型的Class对象

Class clazz = Class.forName(“包.类名”);

（2）获取方法对象

Method method = clazz.getDeclaredMethod(“方法名”,方法的形参类型列表);

（3）创建实例对象

Object obj = clazz.newInstance();

（4）调用方法

Object result = method.invoke(obj, 方法的实参值列表);

> 如果方法的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)
> 
> 如果方法是静态方法，实例对象也可以省略，用null代替

示例代码：

package com.dingjiaxiong.reflect;
    
    import org.junit.Test;
    
    import java.lang.reflect.Method;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestMethod
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 14:45
     */
    
    public class TestMethod {
        
        @Test
        public void test() throws Exception {
        
            // 1、获取Student的Class对象
            Class<?> clazz = Class.forName("com.dingjiaxiong.reflect.Student");
    
            //2、获取方法对象
            /*
             * 在一个类中，唯一定位到一个方法，需要：（1）方法名（2）形参列表，因为方法可能重载
             *
             * 例如：void setName(String name)
             */
            Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);
    
            //3、创建实例对象
            Object stu = clazz.newInstance();
    
            //4、调用方法
            /*
             * 以前：学生对象.setName(值)
             * 现在：方法对象.invoke(学生对象，值)
             */
            Object setNameMethodReturnValue = setNameMethod.invoke(stu, "张三");
    
            System.out.println("stu = " + stu);
            //setName方法返回值类型void，没有返回值，所以setNameMethodReturnValue为null
            System.out.println("setNameMethodReturnValue = " + setNameMethodReturnValue);
    
            Method getNameMethod = clazz.getDeclaredMethod("getName");
            Object getNameMethodReturnValue = getNameMethod.invoke(stu);
            //getName方法返回值类型String，有返回值，getNameMethod.invoke的返回值就是getName方法的返回值
            System.out.println("getNameMethodReturnValue = " + getNameMethodReturnValue);//张三
        }
    
        @Test
        public void test02() throws Exception {
        
            Class<?> clazz = Class.forName("com.atguigu.ext.demo.AtGuiguClass");
            Method printInfoMethod = clazz.getMethod("printInfo", String.class);
            //printInfo方法是静态方法
            printInfoMethod.invoke(null, "尚硅谷");
        }
    }

![在这里插入图片描述][c4b92f5bd415409da88a56aa4643b8d5.png_pic_center]

[fd4099a691a742198992aa37e013728d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/33c6a56df6b24241ae0bd0a689e30ba9.png
[4db3059302be4440a41da8b58ffce1c8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/db5a14a67b3a4b5cbfcad216d14ccb07.png
[81a9565eb0c8497facf088b0112641df.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/fd48ea8629f54adabcc38645762399c6.png
[c4b92f5bd415409da88a56aa4643b8d5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e28989483e1b4845b09a181aaa893aef.png