Java学习——Java动态性之反射机制(reflection）

动态性：

动态语言：程序在运行时，可以改变程序结构或者变量类型。典型的动态语言：Python、ruby、JavaScript等。

C、C++、Java不是动态语言，但是Java可以称之为准动态语言。但是Java有一定的动态性、我们可以利用反射机制、字节码操作获得类似于动态语言的特性。这样就使得Java更加灵活

反射机制：

指的是在运行时再加载一些新的类

程序在运行状态时，可以动态加载一个只有名称的类，对于任意一个已经加载的类都能知道这个类的所有信息（属性、方法）；对于任何一个对象，都能调用它的任何一个属性和方法

这个就是我们在反射中常用的一段代码，用来通过类名获取这个类的字节码对象

Class clazz = Class.forName("cn.xiyou.Scanner.MyTest");

加载完类之后，在堆内存中就产生了一个class类型的对象（一个类只有一个class对象），这个对象包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像是一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

利用反射获取相关信息：

先创建一个标准的实体类：

public class Student {    private String name;    private int age;    private int id;        public Student() {    }    public Student(String name, int age, int id) {        this.name = name;        this.age = age;        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }}

反射机制获取相关信息：

public class Test01 {    public static void main(String[] args) throws Exception {        /**         * 对象是表示或封装一些数据。         * 一个类被加载后，JVM会创建一个对应该类的Class对象，类的整个结构信息会被放到对应的Class对象中去         */        //利用反射获取类的信息（类名、属性、方法、构造器），注意：一个类只有一个Class对象        Class clazz = Class.forName("cn.反射机制.demo01.Student");        /*         *  1.获取类的名字         */        String clazzName = clazz.getName();//（包名+类名）        System.out.println(clazzName);        String clazzSimpleName = clazz.getSimpleName();//类名        System.out.println(clazzSimpleName);        System.out.println("----------------这是一个华丽的分割线----------------");        /*         * 2.获得属性信息         */        //获取public的属性        Field[] fields = clazz.getFields();        for (Field field : fields) {            System.out.println(field);        }        //获取所有的属性（不论public和private）        Field[] declaredFields = clazz.getDeclaredFields();        for (Field declaredField : declaredFields) {            System.out.println("属性："+declaredField);        }        //获取某个属性（不论public和private）        Field name = clazz.getDeclaredField("name");        System.out.println(name);        System.out.println("----------------这是一个华丽的分割线----------------");        /*         *3.获取方法信息         */        //获得所有public的方法        Method[] methods = clazz.getMethods();        for (Method method : methods) {            System.out.println(method);        }        //获取所有的方法（不论public和private）        Method[] declaredMethods = clazz.getDeclaredMethods();        for (Method declaredMethod : declaredMethods) {            System.out.println("方法："+declaredMethod);        }        //获取指定方法，参1：方法名，参2：传递的参数类型的class对象        Method declaredMethod = clazz.getDeclaredMethod("getAge");        System.out.println(declaredMethod);        Method declaredMethod1 = clazz.getDeclaredMethod("setAge", int.class);        System.out.println(declaredMethod1);        System.out.println("----------------这是一个华丽的分割线----------------");        /*         *4.获取构造方法信息         */        //获取所有的构造器        Constructor[] constructors = clazz.getDeclaredConstructors();        for (Constructor constructor : constructors) {            System.out.println("构造器："+constructor);        }        //获取无参构造        Constructor constructor = clazz.getDeclaredConstructor(null);        System.out.println("无参构造："+constructor);        //获取有参构造        Constructor constructor1 = clazz.getDeclaredConstructor(String.class,int.class,int.class);        System.out.println("有参构造："+constructor1);    }}

通过反射动态操作：构造器、方法、属性：

/** * 通过反射动态操作：构造器、方法、属性 */public class Test02 {    public static void main(String[] args) throws Exception {        Class clazz = Class.forName("cn.反射机制.demo01.Student");        /*         * 1.通过反射动态操作构造方法，构造对象         */        //通过调用的是无参构造器构造对象        Student student = (Student) clazz.newInstance();        System.out.println(student);        //通过调用的是有参构造器构造对象        Constructor c = clazz.getDeclaredConstructor(String.class,int.class,int.class);        Student student2 = (Student) c.newInstance("张三", 18, 02165055);        System.out.println(student2.getName()+"==="+student2.getAge()+"==="+student2.getId());        /*         * 2.通过反射操作方法         */        //通过反射调用方法        Student student3 = (Student) clazz.newInstance();        Method method = clazz.getDeclaredMethod("setName", String.class);        method.invoke(student3,"李四");        /*         * 3.通过反射操作属性         */        Student student4 = (Student) clazz.newInstance();        Field f = clazz.getDeclaredField("name");        //setAccessible(true)意思是：这个属性关闭安全检查，直接可以访问（就可以访问private的属性了），提高效率        f.setAccessible(true);        f.set(student4,"王五");//给student4的name设置值        String sname = (String) f.get(student4);//获取student4的name值        System.out.println(sname);    }}

我们还需要知道，反射固然强大，但是它在执行效率上还是不如正常执行。那么我们可以适当的使用setAccessible()打开关闭访问检查用来提高效率。

反射操作泛型（Generic）(了解)：

Java中的泛型是在编译器给javac使用的，确保数据的安全性和免掉强制类型转换的麻烦。但是一旦编译完成，所有的泛型都会被擦除。那么Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到class类中的类型但是又和原始类型齐名的类型。

ParameterizedType：表示一张参数化的类型，比如：Collection< String >

GenericArrayType：泛型数组类型

TypeVariable：是各种泛型变量的公共父接口

WildcardType：代表一种通配符类型表达式，比如?，?extends Number，?super Integer

反射操作注解（了解）：

public class Test03 {    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {        Class clazz = Class.forName("cn.反射机制.demo01.Student");        //获取这个类的所有注解        Annotation[] annotations = clazz.getDeclaredAnnotations();        for (Annotation annotation : annotations) {            System.out.println(annotation);        }        //获取类指定注解的值        MyTable tb = (MyTable) clazz.getAnnotation(MyTable.class);        System.out.println(tb.value());        //获得类的属性的注解        Field f = clazz.getDeclaredField("name");        MyField myField = f.getAnnotation(MyField.class);        System.out.println(myField.name()+"--"+myField.type()+"--"+myField.length());    }}

转载地址：http://daiwi.baihongyu.com/

你可能感兴趣的文章