java中反射 Reflection详细学习

最新推荐文章于 2024-07-24 00:44:45 发布
最新推荐文章于 2024-07-24 00:44:45 发布
阅读量182 收藏 1
点赞数
分类专栏： 学习知识
原文链接：https://blog.csdn.net/sinat_38259539/article/details/71799078
版权

一、反射的概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

反射就是把java类中的各个部分映射成一个个的java类

加载过程：Class对象的由来是由将class文件读入内存，并为之创建一个Class对象
img

二、查看Class类在java中的api详解（1.7的API）

如何阅读java中的api详见java基础之——String字符串处理
Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）
img
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

三、反射的使用（这里使用Student类做演示）

先写一个Student类。

1、获取Class对象的三种方式
1.1 Object ——> getClass();
1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
1.3 通过Class类的静态方法：forName（String className）(常用)

其中1.1是因为Object类中的getClass方法、因为所有类都继承Object类。从而调用Object类来获取


/**
 * 获取Class对象的三种方式
 * 1 Object ——> getClass();
 * 2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
 * 3 通过Class类的静态方法：forName（String  className）(常用)
 *
 */
public class Test {
	public static void main(String[] args) {
		//第一种方式获取Class对象  
		Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
		Class stuClass = stu1.getClass();//获取Class对象
		System.out.println(stuClass.getName());
		
		//第二种方式获取Class对象
		Class stuClass2 = Student.class;
		System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
		
		//第三种方式获取Class对象
		try {
			Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
	}
}

注意：在运行期间，一个类，只有一个Class对象产生。
三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。

2、通过反射获取构造方法并使用：

entity.Student

package entity;

public class Student {
    private String userName;
    public String password;
    public Student(String name ,String pass){
        userName = name;
        password = pass;
    }
    @Override
    public String toString() {
        return "Student{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
    private Student(String name){
        userName = name;
    }
    public Student(){
        password="123456";
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

通过Class对象来获得构造方法：

public class Test {
    public static void main(String[] args) throws Exception {
    Class cls = Student.class;
        Class cls2 = Class.forName("entity.Student");
        System.out.println("~~~~~~~~~~~~~获得所有共有的构造方法~~~~~~~~~~");
        //获得所有共有的构造方法
        Constructor[] cons= cls.getConstructors();
        for(Constructor con :cons){
            System.out.println(con);
        }
        System.out.println("~~~~~~~~~~~~获得所有声明的构造方法~~~~~~~~~~~");
        //获得所有声明的构造方法
        cons = cls.getDeclaredConstructors();
        for(Constructor con :cons){
            System.out.println(con);
        }
        System.out.println("~~~~~~~~~获得公有的指定参数的构造方法~~~~~~~~~");
        //获得公有的指定参数的构造方法
        Constructor con = cls.getConstructor(String.class,String.class);
        System.out.println(con);
        //暴力访问这个构造方法（忽略修饰符）
        con.setAccessible(true);
        Object o = con.newInstance("张三","123423");
        System.out.println(o);
    }
}

后台输出：

~~~~~~~~~~~~~获得所有共有的构造方法~~~~~~~~~~~
public entity.Student()
public entity.Student(java.lang.String,java.lang.String)
~~~~~~~~~~~~获得所有声明的构造方法~~~~~~~~~~~~
public entity.Student()
private entity.Student(java.lang.String)
public entity.Student(java.lang.String,java.lang.String)
~~~~~~~~~~~获得公有的指定参数的构造方法~~~~~~~~
public entity.Student(java.lang.String,java.lang.String)
Student{userName='张三', password='123423'}

Process finished with exit code 0

调用方法：
1.获取构造方法：
1).批量的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)

2).获取单个的方法，并调用：
public Constructor getConstructor(Class… parameterTypes):获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class… parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；

调用构造方法：
Constructor–>newInstance(Object… initargs)

2、 newInstance是 Constructor类的方法（管理构造函数的类）
api的解释为：
newInstance(Object… initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用

3、获取成员变量并调用

测试类：


/*
 * 获取成员变量并调用：
 * 
 * 1.批量的
 * 		1).Field[] getFields():获取所有的"公有字段"
 * 		2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
 * 2.获取单个的：
 * 		1).public Field getField(String fieldName):获取某个"公有的"字段；
 * 		2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
 * 
 * 	 设置字段的值：
 * 		Field --> public void set(Object obj,Object value):
 * 					参数说明：
 * 					1.obj:要设置的字段所在的对象；
 * 					2.value:要为字段设置的值；
 * 
 */
public class Test {
    public static void main(String[] args) throws Exception {
     	//获得Class对象
        Class cls = Class.forName("entity.Student");
        //获得类中的成员变量
        System.out.println("========获得类中的公有成员变量========");
        Field[] fs = cls.getFields();
        for(Field f : fs){
            System.out.println(f);
        }
        System.out.println("=======获得类中定义了的成员变量=======");
        fs = cls.getDeclaredFields();
        for(Field f : fs){
            System.out.println(f);
        }
        System.out.println("======获得指定公有成员变量并调用======");
        Field f = cls.getField("password");
        System.out.println(f);
        //创建Student类的对象
        Object obj = cls.getConstructor().newInstance();
        //为password属性赋值
        f.set(obj,"pwd123");
        //System.out.println("密码："+f.get(obj));
        Student stu = (Student)obj;
        System.out.println("密码："+stu.password);
        System.out.println("=======获得指定成员变量并调用========");
        f = cls.getDeclaredField("userName");
        System.out.println(f);
        f.setAccessible(true);
        f.set(obj,"张三");
        System.out.println("姓名："+stu.getUserName());
     }
}

后台输出：

========获得类中的公有成员变量========
public java.lang.String entity.Student.password
=======获得类中定义了的成员变量=======
private java.lang.String entity.Student.userName
public java.lang.String entity.Student.password
======获得指定公有成员变量并调用======
public java.lang.String entity.Student.password
密码：pwd123
=======获得指定成员变量并调用========
private java.lang.String entity.Student.userName
姓名：张三

4.获取成员方法并调用

student.

public class Student {
	//**************成员方法***************//
	public void show1(String s){
		System.out.println("调用了：公有的，String参数的show1(): s = " + s);
	}
	protected void show2(){
		System.out.println("调用了：受保护的，无参的show2()");
	}
	void show3(){
		System.out.println("调用了：默认的，无参的show3()");
	}
	private String show4(int age){
		System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
		return "abcd";
	}
}

测试类：

/*
 * 获取成员方法并调用：
 * 
 * 1.批量的：
 * 		public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
 * 		public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
 * 2.获取单个的：
 * 		public Method getMethod(String name,Class<?>... parameterTypes):
 * 					参数：
 * 						name : 方法名；
 * 						Class ... : 形参的Class类型对象
 * 		public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
 * 
 * 	 调用方法：
 * 		Method --> public Object invoke(Object obj,Object... args):
 * 					参数说明：
 * 					obj : 要调用方法的对象；
 * 					args:调用方式时所传递的实参；
):
 */
public class Test {
    public static void main(String[] args) throws Exception {
     Class cls = Class.forName("entity.Student");
        //拿取类中公有的方法
        System.out.println("==========拿取所有公有的方法============");
        Method[] ms = cls.getMethods();
        for(Method m : ms){
            System.out.println(m);
        }
        //拿取类中所有定义了的方法
        System.out.println("==========拿取所有定义的方法============");
        ms = cls.getDeclaredMethods();
        for(Method m : ms){
            System.out.println(m);
        }
        //拿取指定公有方法
        System.out.println("============拿取指定公有方法===========");
        //传参数的class对象
        Method m = cls.getMethod("show1",String.class);
        System.out.println(m);
        //使用该方法
        Object o = cls.newInstance();//与getConstructor().newInstance();的区别？？
        m.invoke(o,"啦啦啦啦啦");
        //获取指定私有方法并调用
        System.out.println("========获取指定私有方法并调用=========");
        m = cls.getDeclaredMethod("show4",int.class);
        o = cls.getConstructor().newInstance();
        //解除私有限定（暴力访问）
        m.setAccessible(true);
        Object result = m.invoke(o,1);//返回值为Object类型
        System.out.println(result);
    }
}

控制台输出：

==========拿取所有公有的方法============
public void entity.Student.show1(java.lang.String)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
==========拿取所有定义的方法============
void entity.Student.show3()
protected void entity.Student.show2()
public void entity.Student.show1(java.lang.String)
private java.lang.String entity.Student.show4(int)
============拿取指定公有方法===========
public void entity.Student.show1(java.lang.String)
调用了：公有的，String参数的show1(): s = 啦啦啦啦啦
========获取指定私有方法并调用=========
调用了，私有的，并且有返回值的，int参数的show4(): age = 1
abcd

Process finished with exit code 0

由此可见：
m = stuClass.getDeclaredMethod(“show4”, int.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println(“返回值：” + result);//

5.反射main方法

Student类：

public class Student {
 
	public static void main(String[] args) {
		System.out.println("main方法执行了！");
		for(String s : args){
            System.out.print(s+"\t");
        }
        System.out.println();
	}
}

测试类:

public class Test {
    public static void main(String[] args) throws Exception {
    	Class cls = Class.forName("entity.Student");
        Method m = cls.getMethod("main",String[].class);
        System.out.println(m);
        //invoke方法里面需要两个参数 Object->调用方法的对象  Object[]->方法的参数
        //所以String[]必须转成Object类型
        m.invoke(null,(Object)new String[]{"1","2","3"});
        //另一种写法：
        m.invoke(null,new Object[]{new String[]{"1","2","3"}});
    }
}

控制台输出：

public static void entity.Student.main(java.lang.String[])
main方法执行了！
1	2	3	
main方法执行了！
1	2	3

6.通过反射运行配置文件内容

Student：

public class Student(){
	public void show(){
        System.out.println("show方法执行了");
    }
}

配置文件method.properties：

className=entity.Student
methodName=show

测试类：

public class Test{
	public static void main(String[] args){
	
        Class cls = Class.forName(getValue("className"));
        System.out.println(cls);
        Method m = cls.getMethod(getValue("methodName"));
        System.out.println(m);
        m.invoke(cls.newInstance());
    }

    public static String getValue(String key){
        Properties pro = new Properties();
        try(FileReader reader = new FileReader("G:\\IdeaProjects\\et2004\\reflation\\src\\main\\resources\\method.properties");) {
            pro.load(reader);
            return pro.getProperty (key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

控制台输出：

class entity.Student
public void entity.Student.show()
show方法执行了

Process finished with exit code 0

7.反射方法的其它使用之—通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的
测试类：

/*
 * 通过反射越过泛型检查
 * 
 * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
 */
public class Demo {
	public static void main(String[] args) throws Exception{
		ArrayList<String> strList = new ArrayList<>();
		strList.add("aaa");
		strList.add("bbb");
		
	//	strList.add(100);
		//获取ArrayList的Class对象，反向的调用add()方法，添加数据
		Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
		//获取add()方法
		Method m = listClass.getMethod("add", Object.class);
		//调用add()方法
		m.invoke(strList, 100);
		
		//遍历集合
		for(Object obj : strList){
			System.out.println(obj);
		}
	}
}

控制台输出：

aaa
bbb
100
小野居大王
关注
专栏目录
Java中的反射
张子又
01-07 252
反射的应用场合 在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息 反射的作用 通过反射可以使程序代码访问装载到JVM 中的类的内部信息 获取已装载类的属性信息 获取已装载类的方法 获取已装载类的构造方法信息 在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中 —Class类：代表一个类 —Construct...
Java Reflection (JAVA反射)
天亮说晚安
06-24 1992
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。JavaBe
Java基础—反射
最新发布
qq_42449963的博客
07-24 607
Java基础 反射
Java 中的反射
ShadowySpirits的博客
07-06 1125
反射(Reflection)是Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。  简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。 程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建...
JAVA中的反射
qfc8930858的博客
04-30 1080
一 概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象. 反射就是把java类中...
java 反射Reflection；Class类
12-21
以下是关于Java反射机制及其相关API的详细解释。 1. 反射机制概述： Java反射机制是在程序运行期间，通过类的全名（包括包名）获取该类的Class对象。一旦有了Class对象，就能获取到类的所有信息，如类的名称、方法...
javaReflection反射机制.ppt
04-03
之前上课的时候老师总结的JavaReflection反射学习资料，内容简单易懂，浅显易懂，适合小白入手学习。。
Reflection_in_Java.zip_in_java 反射_java 反射机制_java反射_反射机制
09-23
Java反射机制是Java编程语言中一个强大的特性，它允许运行时的程序动态地获取类的信息并操作类的对象。在Java中，反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包下的类如`Constructor`、`Method`和`...
JAVA Reflection（反射机制）
12-22
　尽管在这样得定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关的机制：反射机制 （Reflection）。 　什么是反射？ 　反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改...
Java反射机制深入探索：Introspection与Reflection
"Java反射机制是Java编程语言中的一个重要特性，允许程序在运行时获取任何已知类的内部信息，并能动态地改变字段内容或调用方法。通过反射API，开发者可以实现对类、接口、字段和方法的深入操作。侯捷的观点强调了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值