反射机制

反射机制

反射机制是什么

1.反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

2.对于任意一个对象，都能够调用它的任意一个方法和属性；

3.这种动态获取的信息以及动态调用对象的方法的功能就是反射机制；

4.也就是说通过反射机制，我们可以获取想要获取到的东西，对前面所学到的范围限定词的限制就可以打破约束

反射机制的作用

1.在运行时判断任意一个对象所属的类；

2.在运行时构造任意一个类的对象；

3.在运行时判断任意一个类所具有的成员变量和方法；

4.在运行时调用任意一个对象的方法；

5.生成动态代理；

反射机制的使用

由于反射机制操作的是类的字节码文件对象，所以想要使用反射机制就必须获取到该类的字节码文件，获取类的字节码文件有3种操作方式

1.通过Class类中的静态方法forName（）；可以获取到字节码对象

Class class1 = class.forName("包名.类名")

2.直接用该类.class获取字节码文件对象

Class class2 = Dog.class;

3.通过类的实例获取该类的字节码文件对象

 Class class3 = new Dog().getClass();

getDeclaredFields 和 getFields 的区别

• getDeclaredFields()获得某个类的所有申明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
• getFields()获得某个类的所有的公共（public）的字段，包括父类。

获取类中的信息

  import java.lang.reflect.Field;
    class Person extends Human{
        public int age;
        private String name;
        protected long id;  
    }
    class Human{
        public int hight;
    }
    public class Main{
        public static void main(String[] args) {
            Class class1 = Person.class;
            Field[] f1 = class1.getFields();//获取到所有被public修饰的类信息，包括父类中的
            for(Field f:f1)
                System.out.println(f);
            
            Field[] f2 = class1.getDeclaredFields();//获取到本类中所有类的信息
            for(Field f:f2)
                System.out.println(f);
        }
        
    }

获取指定的类属性对象

  import java.lang.reflect.Field;
    class Person extends Human{
        public int age;
        private String name;
        protected long id;  
    }
    class Human{
        public int hight;
    }
    public class Main{
        //因为存在访问不到的可能，所以需要抛出异常
        public static void main(String[] args)throws Exception {
            Class class1 = Person.class;
            Field f1 = class1.getField("age");//只能获取父类及本类被public修饰的类属性
            Field f2 = class1.getDeclaredField("name");//可以任意获取本类中的指定类属性
                System.out.println(f1);
                System.out.println(f2);
        }
        
    }

获取构造方法信息

import java.lang.reflect.Constructor;
    
    class Person extends Human {
        public int age;
        private String name;
        protected long id;
    
        public Person(int age, String name, long id) {
            this.age = age;
            this.name = name;
            this.id = id;
        }
    
        public Person() {
        }
    
        private Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
    }
    
    class Human {
        public int hight;
    }
    
    public class Main {
        public static void main(String[] args) throws Exception {
            Class class1 = Person.class;
            Constructor[] c1 = class1.getConstructors();//获取所有被public修饰的构造器
            for (Constructor c : c1)
                System.out.println(c);
            System.out.println("--------------");
            Constructor[] c2 = class1.getDeclaredConstructors();//获取本类所有的构造器
            for (Constructor c : c2)
                System.out.println(c);
        }
    
    }

获取指定的构造方法

  import java.lang.reflect.Constructor;
    
    class Person extends Human {
        public int age;
        private String name;
        protected long id;
    
        public Person(int age, String name, long id) {
            this.age = age;
            this.name = name;
            this.id = id;
        }
    
        public Person() {
        }
        public Person(int age) {
        }
        private Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
    }
    
    class Human {
        public int hight;
    }
    
    public class Main {
        public static void main(String[] args) throws Exception {
            Class class1 = Person.class;
            Constructor c1 = class1.getConstructor(null);//无参构造器
            System.out.println(c1);
            Constructor c2 = class1.getConstructor(int.class);//有参构造器
            System.out.println(c2);
            System.out.println("--------------");
            Constructor c3 = class1.getDeclaredConstructor(int.class,String.class);
            System.out.println(c3);
            
        }
    
    }

获取方法的信息

    import java.lang.reflect.Method;
    
    class Person extends Human {
        public int age;
        private String name;
        protected long id;
    
        public Person(int age, String name, long id) {
            this.age = age;
            this.name = name;
            this.id = id;
        }
    
        public Person() {
        }
        public Person(int age) {
        }
        private Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
        public void aa() {
    
        }
        private void bb() {
    
        }
        private void cc() {
    
        }
    }
    
    class Human {
        public int hight;
    }
    
    public class Main {
        public static void main(String[] args) throws Exception {
            Class class1 = Person.class;
            //获取到本类被public修饰以及父类中被public修饰的方法
            Method[] m1 = class1.getMethods();
            for(Method m : m1)
                System.out.println(m);
            System.out.println("------------");
            Method[] m2 = class1.getDeclaredMethods();//获取到本类中所有的方法
            for(Method m : m2)
                System.out.println(m);
            
        }
    
    }

获取指定方法的信息

 import java.lang.reflect.Method;
    
    class Person extends Human {
        public int age;
        private String name;
        protected long id;
    
        public Person(int age, String name, long id) {
            this.age = age;
            this.name = name;
            this.id = id;
        }
    
        public Person() {
        }
        public Person(int age) {
        }
        private Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
        public void aa() {
    
        }
        private void bb(int x) {
            System.out.println("bb方法");
    
        }
        private void cc() {
    
        }
    }
    
    class Human {
        public int hight;
        public void oo() {
    
        }
    }
    
    public class Main {
        public static void main(String[] args) throws Exception {
            Class class1 = Person.class;
            Method m1 = class1.getMethod("aa");//只能获取本类及父类中被public修饰的方法
            System.out.println(m1);
            //可以获取本类中所有任意指定的方法
            Method m2 = class1.getDeclaredMethod("bb", int.class);
            System.out.println(m2);
        }
    }

对反射机制的使用

 import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    class Person extends Human {
        public int age;
        private String name;
        protected long id;
    
        public Person(int age, String name, long id) {
            this.age = age;
            this.name = name;
            this.id = id;
        }
    
        public Person() {
        }
        public Person(int age) {
        }
        private Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
        public void aa() {
    
        }
        private void bb(int x) {
            System.out.println("bb方法");
    
        }
        private void cc() {
    
        }
        public static void dd() {
            
        }
    }
    
    class Human {
        public int hight;
         void oo() {
    
        }
    }
    public class Main {
        public static void main(String[] args) throws Exception {
            Class class1 = Person.class;
            Object obj = class1.newInstance();
            //使用无参的构造方法创建对象
            System.out.println(obj);
            Constructor constructor1 = 
                    class1.getDeclaredConstructor(int.class,String.class);
            constructor1.setAccessible(true);
            Object dog = constructor1.newInstance(10,"aa");
            System.out.println(dog);
            
            Field name = class1.getDeclaredField("name");
            name.setAccessible(true);
            
            name.set(dog, "张三");
            //获取dog对象的name属性的值
            System.out.println(name.get(dog));
            
            Method aa = class1.getMethod("aa");
            //调用了dog对象的aa方法
            aa.invoke(dog);
            
            Method bb = class1.getDeclaredMethod("bb", int.class);
            bb.setAccessible(true);
            //静态方法将第一个参数设置为null
            bb.invoke(dog, 10);
            
            Method dd = class1.getDeclaredMethod("dd");
            dd.invoke(null);
            System.out.println(dd);
        }
    
    }