Java语法基础学习DayNineteen（反射机制）

时间：2023-03-08 17:47:20

一、Refection定义

1.概述

　　Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

2.功能

　　在运行时判断任意一个对象所属的类
　　在运行时构造任意一个类的对象
　　在运行时判断任意一个类所具有的成员变量和方法
　　在运行时调用任意一个对象的成员变量和方法
　　生成动态代理

3.反射相关的主要API

java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造方法

4.代码示例

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class Test{

    public static void main(String[] args) throws Exception{

        //有了反射，可以通过反射创建一个类的对象，并调用其中的结构

        Class<Person> clazz = Person.class;

        //1.创建clazz对应的运行时类Person类的对象

        Person p = (Person)clazz.newInstance();

        System.out.println(p);//Person[name=null,age=0]，属性为默认值

        //2.通过反射调用运行时类的指定的属性

        //2.1调用public属性

        Field f1 = clazz.getField("name");

        f1.set(p,"LiuDeHua");

        System.out.println(p);//Person[name=LiuDeHua,age=0]

        //2.2调用其他权限属性（private、default、protected）

        Field f2 = clazz.getDeclaredField("age");

        f2.setAccessible(true);

        f2.set(p, );

        System.out.println(p);//Person[name=LiuDeHua,age=20]

        //3.通过反射调用运行时类的指定的方法

        Method m1 = clazz.getMethod("show");

        m1.invoke(p);//我是一个人！

        Method m2 = clazz.getMethod("display",String.class);//有参数时要加上参数的运行时类

        m2.invoke(p,"CHN");//我的国籍是：CHN

    }

}

class Person{

    public String name;

    private int age;

    public void show(){

        System.out.println("我是一个人！");

    }

    public void display(String nation){

        System.out.println("我的国籍是："+nation);

    }

    public String toString(){

        return "Person[name="+name+",age="+age+"]";

    }

}

二、Class类

1.概述

　　在Object类中定义了以下的方法，此方法将被所有子类继承：

　　public final Class getClass()

　　以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

Java语法基础学习DayNineteen（反射机制）

2.特点

Class本身也是一个类

Class 对象只能由系统建立对象

一个类在 JVM 中只会有一个Class实例

一个Class对象对应的是一个加载到JVM中的一个.class文件

每个类的实例都会记得自己是由哪个 Class 实例所生成

通过Class可以完整地得到一个类中的完整结构

创建了任意一个类时，通过编译（javac.exe）,生成对应的.class文件。之后使用java.exe加载（JVM的类加载器完成的）
此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在于缓存区。那么这个运行时类本身就是一个Class的实例！
每一个运行时类只加载一次！
有了Class的实例以后，我们才可以进行如下的操作：
　　1）创建对应的运行时类的对象
　　2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...）
　　3）调用对应的运行时类的指定的结构(属性、方法、构造器)
　　4）反射的应用：动态代理

3.常用方法

static Class forName(String name)：返回指定类名 name 的 Class 对象

Object newInstance()：调用缺省构造函数，返回该Class对象的一个实例

getName()：返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称

Class [] getInterfaces()：获取当前Class对象的接口

ClassLoader getClassLoader()：返回该类的类加载器

Class getSuperclass()：返回表示此Class所表示的实体的超类的Class

Constructor[] getConstructors()：返回一个包含某些Constructor对象的数组

Field[] getDeclaredFields()：返回Field对象的一个数组

Method getMethod(String name,Class ... paramTypes)：返回一个名字为name的Method对象，此对象的形参类型为paramType

4.获取Class的实例的四种方法

public class Test{

    public static void main(String[] args) throws Exception{

        Test test = new Test();

        //1.调用运行时类本身的.class属性

        Class clazz1 = Person.class;

        System.out.println(clazz1.getName());//Person

        Class clazz2 = String.class;

        System.out.println(clazz2.getName());//java.lang.String

        //2.通过运行时类的对象获取

        Person p = new Person();

        Class clazz3 = p.getClass();

        System.out.println(clazz3.getName());//Person

        //3.通过Class的静态方法获取.通过此方式，体会一下，反射的动态性。

        String className = "Person";

        Class clazz4 = Class.forName(className);

//        clazz4.newInstance();

        System.out.println(clazz4.getName());//Person

        //4.（了解）通过类的加载器

        ClassLoader classLoader = test.getClass().getClassLoader();

        Class clazz5 = classLoader.loadClass(className);

        System.out.println(clazz5.getName());//Person

        System.out.println(clazz1 == clazz3);//true

        System.out.println(clazz1 == clazz4);//true

        System.out.println(clazz1 == clazz5);//true

    }

}

三、创建类对象并获取类的完整结构

1.创建运行时类的对象，使用newInstance()

        String className = "Person";

        Class clazz = Class.forName(className);

        //创建对应的运行时类的对象。使用newInstance()，实际上就是调用了运行时类的空参的构造器。

        //要想能够创建成功：①要求对应的运行时类要有空参的构造器。②构造器的权限修饰符的权限要足够。

        Object obj = clazz.newInstance();

        Person p = (Person)obj;

        System.out.println(p);//Person[name=null,age=0]

2.获取对应的运行时类的属性

public class Test{

    public static void main(String[] args) throws Exception{

        Class clazz = Person.class;

        //1.getFields():只能获取到运行时类中及其父类中声明为public的属性

        Field[] fields = clazz.getFields();

        for(int i = ;i < fields.length;i++){

            System.out.println(fields[i]);//public java.lang.String Person.name

                                          //public double Creature.weight

        }

        System.out.println();

        //2.getDeclaredFields():获取运行时类本身声明的所有的属性

        Field[] fields1 = clazz.getDeclaredFields();

        for(Field f : fields1){

        //    System.out.println(f.getName());只获取属性名

        //1.获取每个属性的权限修饰符，public=1;private=2;default=0，需要使用Modifier的toString方法

            int i = f.getModifiers();

            String str1 = Modifier.toString(i);

            System.out.print(str1 + " ");

            //2.获取属性的类型

            Class type = f.getType();

            System.out.print(type.getName() + " ");

            //3.获取属性名

            System.out.print(f.getName());

            System.out.println();

            //结果：public java.lang.String name

            //      private int age

            //       int id

        }

    }

}

public Person extends Creature{

    public String name;

    private int age;

    int id;

}

3.获取运行时类的方法

public class Test{

    public static void main(String[] args) throws Exception{

        Class clazz = Person.class;

        //1.getMethods():获取运行时类及其父类中所有的声明为public的方法（包括Object的方法）

        Method[] m1 = clazz.getMethods();

        for(Method m : m1){

            System.out.println(m);

        }

        System.out.println();

        //2.getDeclaredMethods():获取运行时类本身声明的所有的方法

        Method[] m2 = clazz.getDeclaredMethods();

        for(Method m : m2){

            //1.注解

            Annotation[] ann = m.getAnnotations();

            for(Annotation a : ann){

                System.out.println(a);

            }

            //2.权限修饰符

            String str = Modifier.toString(m.getModifiers());

            System.out.print(str + " ");

            //3.返回值类型

            Class returnType = m.getReturnType();

            System.out.print(returnType.getName() + " ");

            //4.方法名

            System.out.print(m.getName() + " ");

            //5.形参列表

            System.out.print("(");

            Class[] params = m.getParameterTypes();

            for(int i = ;i < params.length;i++){

                System.out.print(params[i].getName() + " args-" + i + " ");

            }

            System.out.print(")");

            //6.异常类型

            Class[] exps = m.getExceptionTypes();

            if(exps.length != ){

                System.out.print("throws ");

            }

            for(int i = ;i < exps.length;i++){

                System.out.print(exps[i].getName() + " ");

            }

            System.out.println();

        }

    }

}

4.获取运行时类的构造器及其他

public class Test{

    public static void main(String[] args) throws Exception{

        String className = "Person";

        Class clazz = Class.forName(className);

        //1.获取运行时类自身所有构造器

        Constructor[] cons = clazz.getDeclaredConstructors();

        for(Constructor c : cons){

            System.out.println(c);

            //private Person(java.lang.String,int)

            //public Person(java.lang.String)

            //public Person()

        }

        //2.获取运行时类的父类

        Class superClass = clazz.getSuperclass();

        System.out.println(superClass);//class Creature

        //3.获取带泛型的父类

        Type type1 = clazz.getGenericSuperclass();

        System.out.println(type1);//Creature<java.lang.String>

        //4*.获取父类的泛型

        Type type2 = clazz.getGenericSuperclass();

        ParameterizedType param = (ParameterizedType)type2;

        Type[] ars = param.getActualTypeArguments();

        System.out.println(((Class)ars[]).getName());//java.lang.String

        //5.获取实现的接口

        Class[] interfaces = clazz.getInterfaces();

        for(Class i : interfaces){

            System.out.println(i);

            //interface java.lang.Comparable

            //interface MyInterface

        }

        //6.获取所在的包

        Package pack = clazz.getPackage();

        System.out.println(pack);//null

        //7.获取注解（生命周期为RUNTIME的注解才行）

        Annotation[] anns = clazz.getAnnotations();

        for(Annotation a : anns){

            System.out.println(a);//@MyAnnotation(value=victory)

        }

    }

}

四、调用指定的属性、方法、构造器

1.调用运行时类中指定的属性

public class Test{

    public static void main(String[] args) throws Exception{

        Class clazz = Person.class;

        //1.获取指定的属性

        //getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性

        Field name = clazz.getField("name");

        //2.创建运行时类的对象

        Person p = (Person)clazz.newInstance();

        System.out.println(p);//Person [name=null, age=0]

        //3.将运行时类的指定的属性赋值

        name.set(p,"Jerry");

        System.out.println(p);//Person [name=Jerry, age=0]

        System.out.println("%"+name.get(p));//%Jerry

        System.out.println();

        //getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性

        Field age = clazz.getDeclaredField("age");

        //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。

        age.setAccessible(true);

        age.set(p,);

        System.out.println(p);//Person [name=Jerry, age=10]

    }

}

2.调用运行时类中指定的方法

public class Test{

    public static void main(String[] args) throws Exception{

        Class<Person> clazz = Person.class;

        //getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法

        Method m1 = clazz.getMethod("show");

        Person p = (Person)clazz.newInstance();

        //调用指定的方法：Object invoke(Object obj,Object ... obj)

        Object returnVal = m1.invoke(p);//我是一个人

        System.out.println(returnVal);//null

        Method m2 = clazz.getMethod("toString");

        Object returnVal1 = m2.invoke(p);

        System.out.println(returnVal1);//Person [name=null, age=0]

        //对于运行时类中静态方法的调用

        Method m3 = clazz.getMethod("info");

        m3.invoke(Person.class);//中国人！

        //getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法

        Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);

        m4.setAccessible(true);

        Object value = m4.invoke(p,"CHN",);//我的国籍是：CHN

        System.out.println(value);//

    }

}

3.调用指定的构造器，创建运行时类的对象

public class Test{

    public static void main(String[] args) throws Exception{

        Class<Person> clazz = Person.class;

        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);

        cons.setAccessible(true);

        Person p = (Person)cons.newInstance("罗伟",);

        System.out.println(p);//Person [name=罗伟, age=20]

    }

}

相关文章