JAVA高级(反射)

1.什么是反射

反射(Reflection)机制是Java语言特性之一，是Java被视为动态(或准动态)语言的一个关键特性 ,是框架设计的灵魂；

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

    对于任意一个对象，都能够调用它的任意一个方法和属性；
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    反射的本质理解，就是获取该类的class对象（类类型 class type）后，反向获取该类对象的各种信息

    反射就是把java类中的各种成分映射成一个个的Java对象
    例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。

————————————————

2.获取反射Class

1.调用类或接口实例的getClass()方法
 Class<? extends Student> aClass1 = student.getClass();

 2.调用类或接口的class属性

 Class<Student> studentClass = Student.class;

 3.使用Class.forName()方法

 Class.forName("com.aaa.dome01.Student");

版权声明：本文为CSDN博主「AnWen03」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_58375976/article/details/124477496

  ///第一种
        Class<?> aClass = Class.forName("com.aaa.dome01.Student");
        //第二种
        Class<Student> studentClass = Student.class;
        //第三种
        Student student = new Student();
        Student student1 = new Student();
        Class<? extends Student> aClass1 = student.getClass();
        Class<? extends Student> aClass2 = student1.getClass();

3.通过反射类获取类对象

通过Class类对象，调用newInstance()

   Class<Student> studentClass = Student.class;
        //通过反射类得到对应的类对象
        Student student = studentClass.newInstance();

4.获取反射类中的属性成员对象

方法	说明
getField(Sting name)	用于某个公有的属性对象
getFields()	获取所有公有的属性对象
getDeclaredField(String name)	获取某个属性对象(public和非pulic)
getDeclaredFields()	获取所有属性对象(public和非pulic)

  //获取反射类
        Class<Student> studentClass = Student.class;
        System.out.println("获取本类sex对象");
        Field sex = studentClass.getDeclaredField("sex");
        System.out.println(sex);
        System.out.println("获取所有公有属性对象");
        Field[] fields1 = studentClass.getFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
        System.out.println("获取本类所有对象");
        Field[] declaredFields = studentClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("获取本类及父类所有public属性对象");

        Field[] fields = studentClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

4.2Field类中具有的常用方法。

setAccessible(true): 设置允许访问私有属性
getAnnotation(注解.class):获取属性上的注解对象

     //1,获取放射类对象
        Class<Teacher> teacherClass = Teacher.class;
        //2.通过反射类得到类对象
        Teacher teacher = teacherClass.newInstance();
        System.out.println(teacher);
        //3.得到反射类中的name属性对象
        Field name = teacherClass.getDeclaredField("name");
        //通过name属性对象为teacher赋值
        name.set(teacher,"张三");
        System.out.println(teacher);

        //4.得到反射类中age属性私有属性对象
        Field age = teacherClass.getDeclaredField("age");
        //允许访问私有属性
        age.setAccessible(true);
        age.set(teacher,20);
        System.out.println(teacher);

        Qy annotation = name.getAnnotation(Qy.class);
        System.out.println(annotation.value());

5.获取获取方法类对象

方法	说明
Method getMethod(String name,Class… params)	返回该实例中指定的public方法，name参数用于指定方法名称，params参数指定参数列表
MethodIl getMethods()	返回该实例中所有public方法
Method getDeclaredMethod(String name,Class… params))	返回该实例中指定的方法，与方法的访问级别无关
MethodI getDeclaredMethods()	返回该实例中的全部方法，与方法的访问级别无关

public class Test {
    public static void main(String[] args) {
        Method[] methods=Person.class.getDeclaredMethods();
        //展示方法的一些信息
        System.out.println("=========方法展示=========");
        for(Method method:methods){
            System.out.println("方法名: "+method.getName());
            System.out.println("返回值类型:"+method.getReturnType().getName());
            //获取方法的参数列表
            Class[] params=method.getParameterTypes();
            if(params.length==0){
                System.out.println("该方法没有参数");
            }else{
                System.out.print("该方法的参数列表为:[");
                for (int i=0;i<params.length;i++){
                    if(i!=0){
                        System.out.println(",");
                    }
                    System.out.print(params[i].getName());
                }
                System.out.println("]");
            }
            System.out.print("访问修饰符:");
            int modifier=method.getModifiers();
            //判断该方法的访问修饰符
            if((modifier & Modifier.PUBLIC)== Modifier.PUBLIC){
                System.out.println("public");
            }else if((modifier & Modifier.PROTECTED)==Modifier.PROTECTED){
                System.out.println("protected");
            }else if((modifier & Modifier.PRIVATE)==Modifier.PRIVATE){
                System.out.println("private");
            }else {
                System.out.println("default(package)");
            }
            //判断该方法是否有static修饰符
            if((modifier&Modifier.STATIC)==Modifier.STATIC)
                System.out.println("这是一个静态方法");
            //判断该方法是否有final修饰符
            if((modifier&Modifier.FINAL)==Modifier.FINAL)
                System.out.println("这是一个final方法");
            //判断该方法是否有ABSTRACT修饰符
            if((modifier&Modifier.ABSTRACT)==Modifier.ABSTRACT)
                System.out.println("这是一个抽象方法");
            //判断该方法是否有synchronized修饰符
            if((modifier&Modifier.SYNCHRONIZED)==Modifier.SYNCHRONIZED)
                System.out.println("这是一个同步方法");

            //获取方法所属的类或接口的class实例
            Class declaringClass=method.getDeclaringClass();
            System.out.println("方法声明在:"+declaringClass.getName()+"中");

            //获取方法抛出的异常处理，即throws子句中声明的异常
            Class[] exceptions=method.getExceptionTypes();
            if(exceptions.length>0){
                System.out.print("该方法抛出的异常有:[");
                for(int i=0;i<exceptions.length;i++){
                    if(i!=0)
                        System.out.print(",");
                    System.out.print(exceptions[i].getName());
                }
                System.out.println("]");
            }
            System.out.println("--------------------------------");
        }


    }
}

5.2Method类中常用的方法

invoke(): 执行该方法体。

getAnnotation()

  public static void main(String[] args) throws Exception{
        Class<Person> personClass = Person.class;
        Person person = personClass.newInstance();
        Method fun01 = personClass.getMethod("fun01", int.class, String.class);
        Object ls = fun01.invoke(person, 15, "李四");
        System.out.println("111111"+ls);

        Qy annotation = fun01.getAnnotation(Qy.class);
        System.out.println(annotation.value());
         System.out.println("--------------------");
		 Method fun03 = personClass.getDeclaredMethod("fun03");
        fun03.setAccessible(true);
        Object invoke = fun03.invoke(person);
        System.out.println("+++++++++++++++++++++++++++"+invoke);

Person方法代码块

public String fun01(){
        System.out.println("~~~~~~~~~~~~~~~~~01");
        return "o1";
    }
    @Qy(value = "你好")
    public String fun01(int age,String name){
        System.out.println("~~~~~~~~~~~~~~~~~01"+age+";============="+name);
        return "01";
    }
    public String fun02(int age){
        System.out.println("~~~~~~~~~~~~~~02");
        return "hello01"+age;
    }
    private void fun03(){
        System.out.println("~~~~~~~~~~~~~~~03");
    }

6.获取构造对象

方法	说明
Constructor getConstructor(Class… params)	返回该类型指定参数列表的public构造方法，构造方法的参数列表与params所指定的类型列表所匹配
Constructoril getConstructors()	返回该类型的所有public构造方法
Constructor getDeclaredConstructor(Class… params)	返回该类型的指定参数列表的构造方法，访问级别不限
Constructorll getDeclaredConstructors()	返回该类型的所有构造方法,访问级别不限

public class Test03 {
    public static void main(String[] args)throws Exception {
        Constructor[] cons= Person.class.getDeclaredConstructors();
        //构造方法的一些信息
        System.out.println("=========构造方法展示=========");
        for(Constructor con:cons){
            System.out.print("访问修饰符:");
            int modifie=con.getModifiers();
            //判断该构造方法的访问修饰符
            if((modifie & Modifier.PUBLIC)== Modifier.PUBLIC){
                System.out.println("public");
            }else if((modifie & Modifier.PROTECTED)==Modifier.PROTECTED){
                System.out.println("protected");
            }else if((modifie & Modifier.PRIVATE)==Modifier.PRIVATE){
                System.out.println("private");
            }else {
                System.out.println("default(package)");
            }

            //获取构造方法的参数列表
            Class[] params=con.getParameterTypes();
            if(params.length==0){
                System.out.println("该构造方法没有参数");
            }else{
                System.out.print("该构造方法的参数列表为:[");
                for(int i=0;i<params.length;i++){
                    if(i!=0)
                        System.out.print(",");
                    System.out.print(params[i].getName());
                }
                System.out.println("]");
            }
            System.out.println("-------------------------------");
        }


    }
}