Java高级中的反射

系统管理员 2023-10-03 21:07 27阅读 0赞

##  ##

**目录**

一、什么是反射

二、获取反射Class类对象

三、通过反射类获取对应的类对象

四、通过反射类获取属性类对象

五、Field类中具有的相关方法

六、通过反射类获取方法类对象

七、Method类中常用的方法

--------------------

## 一、什么是反射 ##

>  **反射它是框架设计的灵魂。**
> 
>  **框架：它是一个半成品，我们使用框架，只需要把自己的业务代码填写。使用框架可以提高开发效率。SpringMvc Spring Mybatis 这些都是框架**
> 
> **反射：在运行时，把类中成员抽取为其他类的过程，这就是反射**

![a9de6c0c7b1c44f2bec836fc2e097a77.png][]

## 二、获取反射Class类对象 ##

>  **获取反射Class类对象有三种方式**
> 
>  **一、通过类名直接获取**
> 
>  **二、通过对象直接获取**
> 
>  **三、通过类名的全路径获取**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/10/27 9:30
     * @Version 1.0
     */
    package com.wjk.demo01;
    
    public class Test01 {
        public static void main(String[] args)throws Exception {
            /**
             * 通过类名直接获取
             */
            Class<Phone> phoneClass = Phone.class;
    
            /**
             * 通过对象直接来获取
             */
            Phone phone=new Phone();
            Class<? extends Phone> aClass = phone.getClass();
    
            /**
             * 通过类名的全路径来获取
             */
            Class<?> aClass1 = Class.forName("com.wjk.demo01.Test01$Phone");
    
    
            System.out.println(phoneClass==aClass);
            System.out.println(phoneClass==aClass1);
            System.out.println(aClass1==aClass);
    
        }
    
        static class Phone{
            private String name;
            private String address;
    
            public void show(){
                System.out.println("使用改方法");
            }
        }
    }

## 三、通过反射类获取对应的类对象 ##

>  **调用反射对象中的newInstance()方法来获取对应的类对象。**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/10/27 9:46
     * @Version 1.0
     */
    package com.wjk.demo02;
    
    public class Test02 {
        public static void main(String[] args)throws Exception {
            //通过类名获取反射类
            Class<Phone> phoneClass = Phone.class;
    
            //通过反射类也可以获取对应的类对象
            Phone phone = phoneClass.newInstance();
            Phone phone1 = phoneClass.newInstance();
    
            System.out.println(phone==phone1);
        }
    }
    class Phone{
        public String name;
        private String address;
    }
    class Student{
        public String sex;
        private Integer age;
    }

## 四、通过反射类获取属性类对象 ##

> **1. Field getDeclaredField(String name) 获取本类中指定的属性对象** 
> 
> **2. Field\[\] getDeclaredFields() 获取本类中所有的属性对象**
> 
> **3. Field getField(String name) 获取本类以及父类中指定的public属性**
> 
> **4. Field\[\] getFields() 获取本类以及父类中所有public属性**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/10/27 10:13
     * @Version 1.0
     */
    package com.wjk.demo03;
    
    import java.lang.reflect.Field;
    
    public class Test03 {
        public static void main(String[] args) throws Exception{
    
            Class<Phone> phoneClass = Phone.class;
            /**
             * 获取本类中指定的属性
             */
            Field name = phoneClass.getDeclaredField("name");
            System.out.println(name);
    
            Field address = phoneClass.getDeclaredField("address");
            System.out.println(address);
            /**
             * 获取本类中所有的属性
             */
            Field[] declaredFields = phoneClass.getDeclaredFields();
            for (Field field:declaredFields){
                System.out.println(field);
            }
    
            /**
             * 获取本类以及父类的指定公共属性
             */
            Field sex = phoneClass.getField("sex");
            System.out.println(sex);
    
            /**
             * 获取本类以及父类中所有的公共属性
             */
            Field[] fields = phoneClass.getFields();
            for (Field field:fields){
                System.out.println(field);
            }
        }
    }
    class Phone extends Student{
        public String name;
        private String address;
    
        @Override
        public String toString() {
            return "Phone{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }
    class Student {
        public String sex;
        private Integer age;
    }

## 五、Field类中具有的相关方法 ##

> **1.setAccessible(true);//允许访问私有属性  
> 2.Object get(Object obj) 返回该所表示的字段的值 Field ，指定的对象上。  
> 3.void set(Object obj, Object value) 将指定对象参数上的此 Field对象表示的字段设置为指定的新值。**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/10/27 10:33
     * @Version 1.0
     */
    package com.wjk.demo04;
    
    import java.lang.reflect.Field;
    
    public class Test04 {
        public static void main(String[] args)throws Exception {
    
            Class<Phone> phoneClass = Phone.class;
            Phone phone = phoneClass.newInstance();
            System.out.println(phone);
            //获取反射类对应的属性对象
            Field name = phoneClass.getDeclaredField("name");
            //通过反射对指定的属性的对象赋值
            name.set(phone,"苹果13");
            System.out.println(phone);
    
            //通过反射获取指定的属性的对象值
            Object o = name.get(phone);
            System.out.println(o);
    
            //因为address是私有化的 不可以直接访问
            Field address = phoneClass.getDeclaredField("address");
            //允许访问私有化的属性
            address.setAccessible(true);
            address.set(phone,"富士康");
            System.out.println(phone);
    
        }
    }
    class Phone extends Student {
        public String name;
        private String address;
    
        @Override
        public String toString() {
            return "Phone{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }
    class Student {
        public String sex;
        private Integer age;
    }

## 六、通过反射类获取方法类对象 ##

> **1. Method getDeclaredMethod(String name, 类<?>... parameterTypes)  
> 根据方法名和参数获取本类中指定的方法对象  
> 2. Method\[\] getDeclaredMethods()  
> 获取到本类中所有的方法**
> 
> **3.Method getMethod(String name, 类<?>... parameterTypes)  
> 根据方法名和参数类型获取本类以及父类中指定public的方法对象  
> 4.Method\[\] getMethods()  
> 获取本类以及父类中所有public方法对象**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/10/27 10:41
     * @Version 1.0
     */
    package com.wjk.demo05;
    
    import java.lang.reflect.Method;
    
    public class Test05 {
        public static void main(String[] args)throws Exception {
            Class<?> aClass = Class.forName("com.wjk.demo05.Cat");
            /**
             * 获取本类中的指定方法对象
             */
            Method fun1 = aClass.getDeclaredMethod("fun1");
            System.out.println(fun1);
    
            Method fun2 = aClass.getDeclaredMethod("fun2", String.class);
            System.out.println(fun2);
    
            /**
             * 获取本类中的所有方法
             */
            Method[] methods = aClass.getDeclaredMethods();
            for (Method method:methods){
                System.out.println(method);
            }
    
            /**
             * 获取本类以及父类中指定的公共方法
             */
            Method show = aClass.getMethod("show");
            System.out.println(show);
    
            /**
             * 获取本类以及父类中所有的公共方法  包括Object父类
             */
            Method[] methods1 = aClass.getMethods();
            for (Method method:methods1){
                System.out.println(method);
            }
    
    
        }
    }
    class Animal{
        public void show(){
            System.out.println("动物的show方法");
        }
        private void print(){
            System.out.println("动物的print方法");
        }
    }
    class Cat extends Animal{
        public void fun1(){
            System.out.println("Cat中fun1方法");
        }
    
        public void fun2(String name){
            System.out.println("fun2"+name);
        }
    }

## 七、Method类中常用的方法 ##

> **Object invoke(Object obj, Object... args)  
> 在具有指定参数的 方法对象上调用此 方法对象表示的底层方法。**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/10/27 12:17
     * @Version 1.0
     */
    package com.wjk.demo06;
    
    import java.lang.reflect.Method;
    
    public class Test06 {
        public static void main(String[] args)throws Exception {
            Class<?> aClass = Class.forName("com.wjk.demo06.Cat");
    
            Method fun1 = aClass.getDeclaredMethod("fun1");
    
            /**
             * 反射 invoke(对象名，实参)
             */
            Object o = aClass.newInstance();
            Object invoke = fun1.invoke(o);
            System.out.println(invoke);
    
    
            Method fun2 = aClass.getDeclaredMethod("fun2", String.class);
            Object result = fun2.invoke(o, "王俊凯");
            System.out.println(result);
        }
    }
    class Animal{
        public void show(){
            System.out.println("动物的show方法");
        }
        private void print(){
            System.out.println("动物的print方法");
        }
    }
    class Cat extends Animal {
        public void fun1(){
            System.out.println("Cat中fun1方法");
        }
    
        public String fun2(String name){
            System.out.println("fun2"+name);
            return "八嘎";
        }
    }

[a9de6c0c7b1c44f2bec836fc2e097a77.png]: https://img-blog.csdnimg.cn/a9de6c0c7b1c44f2bec836fc2e097a77.png