java之反射机制

空口说反射，很难理解这是个什么东西，举个例子就明了了。

假设现在我们有一张动漫的图片，我们通过这张图片，在大脑中搜索有关记忆，就清楚这张图片是什么动漫里的谁；假设我们现在有一个名字，在大脑中搜索有关记忆，就自然而然地想到了该名字人物的具体形象，这种思维过程就是反射。

假设一个类已经加载进JVM，那么，给定该类名，我们就可以通过反射来获取该类的相应信息。

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

java反射机制提供的功能：

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

反射相关的API：

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

一。class类

在Object类中定义了以下的方法，此方法将被所有子类继承：public final Class getClass()。

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

反射可以得到的信息：某个类的属性、方法、构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个Class类型的对象。一个Class对象包含了特定某个类的有关信息。

Class本身也是一个类；
Class对象只能由系统建立；
一个类在JVM中只含有一个实例；
一个Class对象对应的是一个加载进JVM中的一个.class文件；
每个类的实例都会记得自己是由哪个Class实例所生成；
通过Class可以完整地得到一个类中的完整结构；

实例化Class类的四种方式：

Class clazz = String.Class();通过类名.class()
Class clazz = p.getClass();通过对象的实例.getClass()
Class clazz = Class.forName(“java.lang.String);已知一个类的全类名，且在该类的类路径下，可用过forName()获取
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);

二、通过反射调用类的完整结构

Person.java

package ref;

public class Person {
    public String name;
    public int age;
}

Move.java

package ref;

interface Move {
    void move();
}

Study.java

package ref;

public interface Study {
    void study();
}

Student.java

package ref;

public class Student extends Person implements Move,Study{
    
    public String school;
　 private String privateField;
    public void showInfo() {
        System.out.println("学校是"+this.school);
    }

    @Override
    public void study() {
        // TODO Auto-generated method stub
        System.out.println("学习到中学的知识");
    }

    @Override
    public void move() {
        // TODO Auto-generated method stub
        System.out.println("骑自行车上学");
    }
    
    public Student() {
        System.out.println("调用的是Student()");
    }
    
    public Student(String school) {
        this.school = school;
        System.out.println("调用的是Student(String school)");
    }
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("调用的是Student(String name,int age)");
    }
    
    private void test(String name) {}
    public String testGetSchool() {
        return school;
    }

}

test.java

package ref;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) {
        try {
            //这里是相关代码
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

1.获取类的父类和接口

            Class clazz = Class.forName("ref.Student");
            Class superClass = clazz.getSuperclass();
            //获取父类的名字
            System.out.println("父类："+superClass.getName());
            //获取实现的接口
            Class[] interfaces = clazz.getInterfaces();
            for(Class itf:interfaces) {
                System.out.println("接口名字："+itf.getName());
            }

父类：ref.Person
接口名字：ref.Move
接口名字：ref.Study

2.获取类的构造方法

//获取公有的构造方法
            Constructor[] cons = clazz.getConstructors();
            for(Constructor con:cons) {
                System.out.println("--------------------------");
                System.out.println("构造方法："+con.getName());//获取构造方法名称
                //返回1代表public
                System.out.println("构造方法修饰符："+con.getModifiers());//获取构造方法修饰符
                //获取构造方法的参数类型
                Class[] parameterClass = con.getParameterTypes();
                for(Class param:parameterClass){
                    System.out.println("构造方法："+con.getName()+"的参数类型为"+param.getName());
                }
                System.out.println("--------------------------");
            }
            //获取私有的构造方法
            Constructor[] cons2 = clazz.getDeclaredConstructors();
            for(Constructor con:cons2) {
                System.out.println("--------------------------");
                System.out.println("构造方法："+con.getName());//获取构造方法名称
                System.out.println("构造方法修饰符："+con.getModifiers());//获取构造方法修饰符
                //获取构造方法的参数类型
                Class[] parameterClass = con.getParameterTypes();
                for(Class param:parameterClass){
                    System.out.println("构造方法："+con.getName()+"的参数类型为"+param.getName());
                }
                System.out.println("--------------------------");
            }

————————–
构造方法：ref.Student
构造方法修饰符：1
————————–
————————–
构造方法：ref.Student
构造方法修饰符：1
构造方法：ref.Student的参数类型为java.lang.String
————————–

————————–
构造方法：ref.Student
构造方法修饰符：1
————————–
————————–
构造方法：ref.Student
构造方法修饰符：2
构造方法：ref.Student的参数类型为java.lang.String
构造方法：ref.Student的参数类型为int
————————–
————————–
构造方法：ref.Student
构造方法修饰符：1
构造方法：ref.Student的参数类型为java.lang.String
————————–

3.通过反射来创建对象

                //相当于调用无参构造方法
                Object obj = clazz.newInstance();
                Student stu = (Student) obj;
                //相当于调用Student(String school)构造方法
                Constructor con = clazz.getConstructor(String.class);
                Student stu1 = (Student) con.newInstance("一中");
                //通过反射机制可以强制获取私有方法
                Constructor con2 = clazz.getDeclaredConstructor(String.class,int.class);
                //解除私有的封装
                con2.setAccessible(true);
                Student stu2 = (Student) con2.newInstance("jack",23);
                System.out.println(stu2.name);
                System.out.println(stu2.age);

调用的是Student()
调用的是Student(String school)
调用的是Student(String name,int age)
jack
23

4.获取类的方法

//获取所有公有方法
            Method[] ms = clazz.getMethods();
            for(Method m:ms) {
                System.out.println("--------------------------");
                System.out.println("方法名："+m.getName());
                System.out.println("返回值类型："+m.getReturnType());
                System.out.println("修饰符："+m.getModifiers());
                Class[] mrs = m.getParameterTypes();
                if(mrs!=null && mrs.length>0) {
                    for(Class mr:mrs){    
                        System.out.println("方法参数类型："+mr.getName());
                    }
                }
                System.out.println("--------------------------");
            }
            //获取所有方法,包括公有和私有
            Method[] ms2 = clazz.getDeclaredMethods();
            for(Method m:ms2) {
                System.out.println("--------------------------");
                System.out.println("方法名："+m.getName());
                System.out.println("返回值类型："+m.getReturnType());
                System.out.println("修饰符："+m.getModifiers());
                Class[] mrs = m.getParameterTypes();
                if(mrs!=null && mrs.length>0) {
                    for(Class mr:mrs){    
                        System.out.println("方法参数类型："+mr.getName());
                    }
                }
                System.out.println("--------------------------");
            }

————————–
方法名：showInfo
返回值类型：void
修饰符：1
————————–
————————–
方法名：study
返回值类型：void
修饰符：1
————————–
————————–
方法名：move
返回值类型：void
修饰符：1
————————–
————————–
方法名：testGetSchool
返回值类型：class java.lang.String
修饰符：1
————————–
————————–
方法名：wait
返回值类型：void
修饰符：17
————————–
————————–
方法名：wait
返回值类型：void
修饰符：17
方法参数类型：long
方法参数类型：int
————————–
————————–
方法名：wait
返回值类型：void
修饰符：273
方法参数类型：long
————————–
————————–
方法名：equals
返回值类型：boolean
修饰符：1
方法参数类型：java.lang.Object
————————–
————————–
方法名：toString
返回值类型：class java.lang.String
修饰符：1
————————–
————————–
方法名：hashCode
返回值类型：int
修饰符：257
————————–
————————–
方法名：getClass
返回值类型：class java.lang.Class
修饰符：273
————————–
————————–
方法名：notify
返回值类型：void
修饰符：273
————————–
————————–
方法名：notifyAll
返回值类型：void
修饰符：273
————————–

————————–
方法名：test
返回值类型：void
修饰符：2
方法参数类型：java.lang.String
————————–

5.获取类的属性

　　　　　　　//获取公有属性
            Field[] fs = clazz.getFields();
            for(Field f:fs) {
                System.out.println("--------------------------");
                System.out.println("属性名："+f.getName());
                System.out.println("属性类型："+f.getType());
                System.out.println("修饰符："+f.getModifiers());
                System.out.println("--------------------------");
            }
            //获取所有属性
            Field[] fs2 = clazz.getDeclaredFields();
            for(Field f:fs2) {
                System.out.println("--------------------------");
                System.out.println("属性名："+f.getName());
                System.out.println("属性类型："+f.getType());
                System.out.println("修饰符："+f.getModifiers());
                System.out.println("--------------------------");
            }

————————–
属性名：school
属性类型：class java.lang.String
修饰符：1
————————–
————————–
属性名：name
属性类型：class java.lang.String
修饰符：1
————————–
————————–
属性名：age
属性类型：int
修饰符：1
————————–

————————–
属性名：school
属性类型：class java.lang.String
修饰符：1
————————–
————————–
属性名：privateField
属性类型：class java.lang.String
修饰符：2
————————–

6.获取类所在的包

            //获取类所在的包
            Package p = clazz.getPackage();
            System.out.println(p.getName());

ref

三、通过反射来调用类中指定的方法和属性

向Student.java中插入以下方法：

    private void test(String name) {
        System.out.println("这是私有的test(String name)方法");
    }

    public void setInfo(String name,String school) {
        this.name = name;
        this.school = school;
        System.out.println("这是公有的setInfo(String name,String school)方法");
    }
    public void setInfo(int age) {
        this.age = age;
        System.out.println("这是公有的setInfo(int age)方法");
    }

1.调用类中指定的方法

                Constructor con = clazz.getConstructor();
                Object obj = con.newInstance();
                //先获取到方法
                Method m = clazz.getMethod("setInfo", String.class,String.class);
                //再进行调用
                m.invoke(obj, "tom","三中");
                //如果想调用私有的方法
                Method m2 = clazz.getDeclaredMethod("test", String.class);
                m2.setAccessible(true);
                m2.invoke(obj, "jack");
                //调用重载的方法
                Method m3 = clazz.getMethod("setInfo", int.class);
                m3.invoke(obj, 12);
                //调用具有返回值的方法
                Method m4 = clazz.getMethod("testGetSchool");
                String school = (String) m4.invoke(obj);
                System.out.println(school);

调用的是Student()
这是公有的setInfo(String name,String school)方法
这是私有的test(String name)方法
这是公有的setInfo(int age)方法
三中

2.调用类中指定的属性

                Constructor con = clazz.getConstructor();
                Object obj = con.newInstance();
                Student stu = (Student) obj;
                Field f = clazz.getField("school");
                //对stu属性school设置值
                f.set(stu,"第三中学");
                String school = (String) f.get(stu);
                System.out.println(school);
                //如果是私有的属性
                Field f2 = clazz.getDeclaredField("privateField");
                f2.setAccessible(true);
                f2.set(stu,"私有属性");
                String privateField = (String) f2.get(stu);
                System.out.println(privateField);

调用的是Student()
第三中学
私有属性

本文链接：https://www.cnblogs.com/xiximayou/p/12073611.html

java之反射机制

java之反射机制

java之反射机制的更多相关文章

随机推荐

热门专题

目录导航