反射

定义

在运行期间可以获取对象的类型，类型的方法，类型的属性，类型的构造方法等，让对象可以认识到自身的结构。

方法

【1】获取对象的类型

（1）方法一

Object.getclass()

public class Reflect {
    private String name;
}
class Test{
    public static void main(String[] args) {
        //方法一：Object.getclass()
        Class<? extends Reflect> reflectclass = new Reflect().getClass();
        System.out.println(reflectclass);
        //class Reflect

        //方法二：class.forName("类名")
        try {
            Class<?> reflect = Class.forName("Reflect");
            System.out.println(reflect);
            //class Reflect
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //方法三：类名.class
        System.out.println(Reflect.class);
        //class Reflect

    }
}

（2）方法二

class.forName(“类名”)；

（3）方法三

类名.class;

【2】类对象的功能

[1]用反射的方式创建对象

我们先比较一下正常创建对象和反射创建对象的不同：

（1）正常创建对象

new 类名();

（2）反射创建对象

创建一个新实例对象：类对象.newInstance();
当然利用反射来创建对象是有限制的：

• 构造方法不能私有
• newInstance要求对象有无参构造

try {
           Reflect reflect = Reflect.class.newInstance();
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       }

[2]获取方法信息

public class Reflect {
    private String name;
    private int age;

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

    public int getAge() {
        return age;
    }

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

我们来对Reflact这个类做反射，获取它的所有方法信息

class Test{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
      

        //获取某个公共方法，包括继承的
        Method method = Class.forName("Reflect").getMethod("getAge");
        System.out.println(method.toString());
        //获取所有公共方法包括继承的
        Method[] methods = new Reflect().getClass().getMethods();
        for (Method method1 : methods) {
            System.out.println(method1.toString());
        }
        //获取本类中所有的方法
        Method[] declaredMethods = Reflect.class.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.toString());
        }
        //找本类的方法，不包括继承的
        Method setAge = new Reflect().getClass().getDeclaredMethod("setAge", int.class);
        System.out.println(setAge.toString());


//        public int Reflect.getAge()
//        public java.lang.String Reflect.toString()
//        public void Reflect.setAge(int)
//        public int Reflect.getAge()
//        public final void java.lang.Object.wait() throws java.lang.InterruptedException
//        public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//        public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
//        public boolean java.lang.Object.equals(java.lang.Object)
//        public native int java.lang.Object.hashCode()
//        public final native java.lang.Class java.lang.Object.getClass()
//        public final native void java.lang.Object.notify()
//        public final native void java.lang.Object.notifyAll()
//        public java.lang.String Reflect.toString()
//        public void Reflect.setAge(int)
//        public int Reflect.getAge()
//        public void Reflect.setAge(int)

    }
}

[3]获取属性信息

        //获取属性信息
        //获取所有属性信息，包括继承的
        Field[] fields = new Reflect().getClass().getFields();
        for (Field field : fields) {
            System.out.println(field.toString());
        }
        //获取某个属性信息(必须是public 的属性才可以拿到)
        Field name = new Reflect().getClass().getField("age");
        System.out.println(name.toString());
        //获取本类某个属性
        Field declaredField = Class.forName("Reflect").getDeclaredField("age");
        System.out.println(declaredField.toString());
        //获取本类的所有属性
        Field[] reflects = Class.forName("Reflect").getDeclaredFields();
        for (Field reflect : reflects) {
            System.out.println(reflect.toString());
        }

//        public int Reflect.age
//        public int Reflect.age
//        public int Reflect.age
//        private java.lang.String Reflect.name
//        public int Reflect.age

这里要强调一下，用getField(属性名")这个方法的时候，属性不能是private
否则会抛出异常：java.lang.NoSuchFieldException: age

[4]获取构造方法

//获取所有的构造方法
        Constructor<?>[] constructors = new Reflect().getClass().getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor.toString());
        }
        //获取int类型参数的构造方法
        Constructor<?> constructor = Class.forName("Reflect").getConstructor(int.class);
        System.out.println(constructor.toString());
        //获取无参构造
        Constructor<? extends Reflect> constructor1 = new Reflect().getClass().getConstructor();
        System.out.println(constructor1.toString());
        //获取本类所有的构造方法
        Constructor<?>[] reflects1 = Class.forName("Reflect").getDeclaredConstructors();
        for (Constructor<?> constructor2 : reflects1) {
            System.out.println(constructor2.toString());
        }

[5]反射调用方法

（1）正常调用方法

对象.方法名（参数）

（2）反射调用方法

---

== 方法.invole(对象，参数)==

---

方法.setAccessible(true)
//设置这个方法可以被访问，可以突破访问修饰符的限制

缺点：性能低，调用复杂

 Method getName = Reflect.class.getDeclaredMethod("gn");
        getName.invoke(new Reflect());