Java基础——反射

最新推荐文章于 2021-03-14 02:51:01 发布
最新推荐文章于 2021-03-14 02:51:01 发布
阅读量470 收藏
点赞数
分类专栏： Java基础 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_29174099/article/details/47665569
版权

概述&应用场景

java反射机制是在运行状态中，对于任意的一个类（class文件）都能够知道这个类的所有属性和方法
对于任意一个对象，都能够调用它的任意一个方法和属性
这种动态获取信息以及动态调用对象的方法的功能称为java的反射机制

动态获取类中的信息，就是java反射
可以理解为对类的解剖

对于一个已经写好的应用程序，我们想给他添加新的功能，
就计划在外边建立了一个类，然后在程序中new一个对象，直接调用方法就可以了，
但是，我们没有源代码，只有一个类（class文件），这可怎么办呢？

办法是，我们不会在应用程序里边new对象，程序都有自己对外提供的接口用来实现功能的扩展，
我们先实现了这个接口创建出来他的子类，在应用程序对外提供的一个配置文件中写入子类的名称，就可以了
程序运行会读取配置文件中的信息，当读取到写入的类名的时候，就会将该类加载进来，
如果想要对指定名称的字节码文件进行加载，并获取其中的内容，并调用，
怎么可以实现呢？这时就用到了反射技术。

比如说tomcat就是一个java应用程序，他提供了处理请求和应答的方式
因为具体的处理动作不同，所以必须对外提供了接口（Servlet），要求开发者来实现具体请求和应答处理

具体图解是这样的：

这里写图片描述

那么当应用程序读取到配置文件中给写出的类名的时候，就会去找找该名称对应的class文件，找到之后又是怎么对类文件进行解析的呢？

使用图例来说明

这里写图片描述

接下来演示获取class对象的三种方式：

第一种，Object类中有getClass方法，可以获取到class对象

先创建一个对象，用来获取

package cn.itcast.bean;

public class Person {
	private String name;
	private int age;
	public Person(String name,int age)
	{
		this.name = name;
		this.age = age;
		System.out.println("param person   run");
	}
	public Person()
	{
		super();
		System.out.println("noparam   person   run");
	}
	public void  show()
	{
		System.out.println(name+"..show   run.."+age);
	}
	public void method()
	{
		System.out.println("method      run");
	}
	public void method(String str,int age)
	{
		System.out.println("param   method   run  "+str+"...."+age);
	}
	public static void staticMethod()
	{
		System.out.println("static method  run");
	}
}

第一种方法获取：

package cn.itcast.demo;
import cn.itcast.bean.Person;
/**
 * @author Lenovo
 * 获取class对象的第一种方法：通过Object类中的getClass方法
 */
public class ReflectDemo {
public static void main(String[] args) {
	//创建一个对象，使用对象调用方法获取class对象，
	Person p = new Person();
	Class<?> clazz = p.getClass();
	
	Person p1 = new Person();
	Class<?> clazz1 = p1.getClass();
	//判断两次获取到的对象是不是同一个
	System.out.println(clazz==clazz1);
}
}

这里写图片描述

想要用这种方式，必须要明确具体的类，并创建对象，
麻烦

第二种方法，每个对象都有一个静态的.class属性，可以获取到所属的class对象

package cn.itcast.demo;
import cn.itcast.bean.Person;
/**
 * @author Lenovo
 * 获取class对象第二种方法，每个对象都有一个静态的,class属性
 */
public class ReflectDemo2 {
public static void main(String[] args) {
	Class<?> clazz  = Person.class;
	Class<?> clazz1 = Person.class;
	System.out.println(clazz==clazz1);
}
}

这里写图片描述

这种方法相对简单，但还是要明确到类中的静态成员，
还是不够扩展

第三种方法：通过字符串名称就可以获取到该类对象

package cn.itcast.demo;
import cn.itcast.bean.Person;
/**
 * @author Lenovo
 * 获取class对象第三种方法，直接通过字符串名称获取到该类
 * 通过Class中的forName方法完成
 */
public class ReflectDemo3 {
public static void main(String[] args) throws ClassNotFoundException {
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");//这里记得要写全包名和类名
	Class<?> clazz1 = Class.forName("cn.itcast.bean.Person");
	System.out.println(clazz==clazz1);
}
}

这里写图片描述

这种方法有名称即可，更为方便，扩展性更强。

获取对象

那么我们获取到了class对象了，是不是就可以new对象了呢？

在早期我们创建对象是这么干的：


//早期的时候根据类名找到对应的字节码文件，加载进内存，
//然后创建该类的字节码文件对象，紧接着就创建该字节码文件对应的Person对象
cn.itcast.bean.Person p = new cn.itcast.bean.Person();

现在我们只有一个字节码文件的名字，应该怎么获取对象，并且创建对象呢？

package cn.itcast.demo;

public class GetNewObject {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
	//现在我们先根据字符串类型的名字，获取到他的字节码文件的对象
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	//根据有了clazz就可以直接获取到对象了：
	Object obj = clazz.newInstance();
}
}

就这样对象就获取成功了：

这里写图片描述

我们看到了，获取到的对象是根据Person对象的无参数的构造方法获取到的对象

但要是Person对象没有无参数构造方法，或者Person类的无参构造方法被私有了呢？

我们想要获取带参数的改造方法，也就是Person(String name,int age)这样的对象，

package cn.itcast.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class GetNewObject {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
	//现在我们先根据字符串类型的名字，获取到他的字节码文件的对象
	
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	
	//既然都获取到了字节码文件对象，那么就可以获取到所有的构造函数了
	//getConstructor方法可以获取到字节码文件对象的带参数的构造器
	//需要把参数类型的字节码文件传进去，获取到该种参数类型的构造器
	
	Constructor<?> cons = clazz.getConstructor(String.class,int.class);
	
	//然后使用获取到的构造器来创建带参数的对象
	
	Object obj = cons.newInstance("小强",34);
}
}

这里写图片描述

可以看到，带参数的person对象执行了。

获取class对象的字段

道理也一样，都获取到字节码文件对象了，获取到他的字段还不简单？

Class中有这样的方法

这里写图片描述

所以开始获取：

package cn.itcast.demo;

import java.lang.reflect.Field;

public class GetFiled {
public static void main(String[] args) throws Exception {
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	Object obj = clazz.newInstance();//获取到对象
	//想要什么字段，输进方法中
	Field filed = clazz.getField("age");
	
	//然后获取字段的信息，因为字段信息需要使用本类对象来调用，所以这里需要传进来他的本类对象
	//返回指定对象上此 Field 表示的字段的值。
	
	Object o = filed.get(obj);
	
	//那么这个o是什么呢？我们打印一下就知道了
	
	System.out.println(o);
	
}
}

运行时出现了这样的结果:
这里写图片描述

出现了异常，这是为什么呢？我获取一个age字段，他告诉我没有这个字段，，

这是因为在Person类中设置的age的访问类型是private私有的，所以他访问不到，抛出没有这个字段异常。

要想访问到私有部分的字段，可以使用Class中的方法getDeclaredField方法（可以获取到所有权限的字段）

package cn.itcast.demo;

import java.lang.reflect.Field;

public class GetFiled {
public static void main(String[] args) throws Exception {
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	Object obj = clazz.newInstance();//获取到对象
	//获取所有权限类型的字段，想要什么字段，输进方法中
	Field filed = clazz.getDeclaredField("age");
	
	//然后获取字段的信息，因为字段信息需要使用本类对象来调用，所以这里需要传进来他的本类对象
	//返回指定对象上此 Field 表示的字段的值。
	
	Object o = filed.get(obj);
	
	//那么这个o是什么呢？我们打印一下就知道了
	
	System.out.println(o);
	
}
}

运行时又出现了这样的错误：

这里写图片描述

无效的访问异常，

这是因为我获取到了私有的字段，仅仅是字段，里边被私有的数据并拿不到，

我想要拿到数据怎么办呢？

Field类有一个父类AccessibleObject

这里写图片描述

他可以取消java默认的访问权限使用的是setAccessible方法

这里写图片描述

所以再修改代码如下：

package cn.itcast.demo;

import java.lang.reflect.Field;

public class GetFiled {
public static void main(String[] args) throws Exception {
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	Object obj = clazz.newInstance();//获取到对象
	//获取所有权限类型的字段，包括私有，想要什么字段，输进方法中
	Field field = clazz.getDeclaredField("age");
	
	//获取到私有对象之后，想要访问里边的数据，就要对私有字段的访问取消权限检查
	field.setAccessible(true);
	
	//能访问数据了就可以给字段设置值
	field.set(obj, 39);
	
	//然后获取字段的信息，因为字段信息需要使用本类对象来调用，所以这里需要传进来他的本类对象
	//返回指定对象上此 Field 表示的字段的值。
	
	Object o = field.get(obj);
	
	//那么这个o是什么呢？我们打印一下就知道了
	
	System.out.println(o);
	
}
}

运行结果为：

这里写图片描述

这种明知道是私有成员还要访问的模式称为暴力访问。

获取class对象中的方法

直接演示：

package cn.itcast.demo;

import java.lang.reflect.Method;

public class GetMethodDemo1 {
public static void main(String[] args) throws Exception {
	
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	Object obj = clazz.newInstance();
	
	//获取字节码文件兑现中的所有的方法
	Method[] methods = clazz.getMethods();
	
	for(Method method:methods)
	{
		System.out.println(method);
	}
}
}

运行方法：

这里写图片描述

可以看到，使用getMethods方法获取到的都是公有的方法，还有他的父类Object中的方法，

想要获取本类中的方法可以使用getDeclaredMethods方法：

package cn.itcast.demo;

import java.lang.reflect.Method;

public class GetMethodDemo1 {
public static void main(String[] args) throws Exception {
	
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	Object obj = clazz.newInstance();
	
	//获取字节码文件兑现中的所有的方法
	Method[] methods = null;//clazz.getMethods();//获取的都是公有的方法
	methods = clazz.getDeclaredMethods();//获取的都是本类中的方法，包括私有的
	
	for(Method method:methods)
	{
		System.out.println(method);
	}
}
}

运行结果：

这里写图片描述

结果看出，获取到了本类中的所有方法，包括私有的方法

接下来获取指定名称和空参数类型的方法：

package cn.itcast.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class GetMethodDemo1 {
public static void main(String[] args) throws Exception {
	
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	//创建一个有参数的对象方便show方法调用
	
	//先获取到构造器：
	Constructor<?> cons = clazz.getConstructor(String.class,int.class);
	//创建一个有参数的对象，
	Object obj = cons.newInstance("zhagnsan",25);
	
	//获取字节码文件对象中的指定名称指定参数类型的方法
	Method method = clazz.getMethod("show", null);//获取一个空参数的方法
	
	//拿获取到的方法进行调用是使用invoke方法，将要调用的对象和方法需要的参数传进来
	method.invoke(obj, null);
}
}

运行结果：

这里写图片描述

那怎么样获取到有参数的方法呢？

package cn.itcast.demo;

import java.lang.reflect.Method;

public class GetMethodDemo1 {
public static void main(String[] args) throws Exception {
	
	Class<?> clazz = Class.forName("cn.itcast.bean.Person");
	//获取到参数对象，把方法的名称和参数的类型传进来
	Method method = clazz.getMethod("method", String.class,int.class);
	//创建一个对象用来调用方法
	Object obj = clazz.newInstance();
	//将对象传进来，参数也传进来使用method的invoke方法调用
	method.invoke(obj,"lisi",45);
}
}

运行结果：

这里写图片描述

练习：电脑主板的例子，电脑已经安装好了，但是后期来了一个声卡，或者网卡，我们怎么样在不拆电脑的情况下让这个声卡运行起来：

先定义一个接口，后来的部件只要实现了我的这个接口，就可以被电脑使用

package cn.itcast.test;

public interface PCI {
public void open();
public void close();
}

然后定义实现了接口的声卡：

package cn.itcast.test;

public class SoundCard implements PCI {

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("声卡开启");
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("声卡关闭");
	}

}

最后在主函数中调用：

package cn.itcast.test;

public class MainBoard {
public static void main(String[] args) {
	System.out.println("主板运行......");
	usePCI(new SoundCard());
}

private static void usePCI(PCI p) {
	p.open();
	p.close();
}
}

运行结果：

这里写图片描述

我们以前一直都是这么干的，但是
有一个缺陷，就是我每添加一个外部部件，都要回来new一个对象
能不能不改代码的前提下，来一个部件实现了PCI我就能直接用呢？

这就用到了反射，
我们需要在一个配置文件中写上实现了PCI接口的子类的名称，
然后让主程序去读取配置文件中的信息，
获取到声卡还有其他部件的类名，然后加载到内存中来，
然后开始使用class对象中的方法

然后重写程序：

建立名为pci.properties的配置文件，里边写上：

pci1=cn.itcast.test.SoundCard

键为pci加数字作为顺序，值为后来的实现了PCI接口的类的名称

然后在主函数中关联配置文件并且每次运行主程序的时候读取配置文件中的信息，加载类，创建对象，进行调用

package cn.itcast.test;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class MainBoard {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
	System.out.println("主板运行......");
	//先创建一个配置文件的文件对象
	File file = new File("pci.properties");
	//既然用到了配置信息那么就创建一个配置信息的类
	Properties prop  = new Properties();
	//创建读取配置文件的流
	FileReader fr = new FileReader(file);
	//将配置信息从流中读取到配置信息的类中
	prop.load(fr);
	//通过循环读取配置集合中的信息
	for(int x = 0;x<prop.size();x++)
	{
		//通过键获取到对应的值，也就是要加载的类的名字
		String className = prop.getProperty("pci"+(x+1));
		//根据类的名字获取到类文件对象
		Class<?> clazz = Class.forName(className);
		//创建出来类文件对应的对象
		PCI p = (PCI)clazz.newInstance();
		//调用一次使用PCI的方法
		usePCI(p);
	}
	fr.close();
}

private static void usePCI(PCI p) {
	p.open();
	p.close();
}
}

运行结果：

这里写图片描述

这时候，来了一个网卡，实现了PCI接口，内容是这样的：

package cn.itcast.test;

public class NetCard implements PCI {

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("网卡开启");
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("网卡关闭");
	}

}

然后我什么都不做，只在配置文件pci.properties文件中加上一句：

这里写图片描述

然后再次运行主函数：

结果变为：

这里写图片描述

下山打老虎◆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——反射方法总结
12-22
以下是对标题"Java——反射方法总结"中提到的知识点的详细解释： 1. **获取Class类对象的方法** - `Class.forName(String packageNameAndClassName)`：这是Class类的静态方法，它通过完整的包名和类名来动态加载...
反射-10.19
xt_cloud的博客
10-19 131
反射：框架设计的灵魂 * 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码 * 反射：将类的各个组成部分封装为其他对象，这就是反射机制 * 好处： 1. 可以在程序运行过程中，操作这些对象。 2. 可以解耦，提高程序的可扩展性。 * 获取Class对象的方式： 1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象 * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类 2. 类名.class：通过类名的属性class获取 * 多.
java 反射 配置文件,利用java反射机制运行加载配置文件，有错误求帮解决
weixin_42099987的博客
03-14 54
package cn.itcast.day1;import java.io.File;import java.io.InputStream;import java.util.Properties;public class ReflectTest {public static void main(String[] args)throws Exception {//笔记本电脑使用usb设备NoteBo...
java反射踩坑
qq_39130032的博客
12-31 426
代码： public class ReflectTest { public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldExcepti...
黑马程序员——Java基础---反射
u011916243的博客
07-01 322
反射     JAVA反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。     动态获取类中信息，就是java反射。可以理解为对类的解剖。     如果想要对指定名称的字节码文件进行加载并获取其中的内容并调用，这时
《黑马程序员》 通过反射获取字节码文件中的字段
青云志,我心不死,必度青天...
03-10 819
public static void main(String[] args) throws Exception{ /** * 反射的测试 */ NewReflectPoint nrp=new NewReflectPoint(112, 205); //通过反射获取到里面的对象 //通过反射获取到里面的y变量 Field fieldY=nrp.getCla
java学习——java中的反射学习笔记.rar_java 反射
最新发布
09-21
一、反射基础 1. 类加载：当Java虚拟机（JVM）加载一个类时，它会创建该类的Class对象。这个对象包含了关于类的所有信息，包括方法、字段、构造器等。例如，`Class<?> clazz = Class.forName("com.example.MyClass"...
Java期末复习——枚举与反射机制
08-07
Java编程语言中，枚举和反射机制是两个重要的特性，它们在不同的场景下有着独特的用途。下面我们将详细探讨这两个主题。 一、枚举 枚举（Enum）在Java中用于定义一组固定数量的值，这些值可以作为常量使用。枚举...
Java知识点——反射初识以及基本API
12-22
1. 反射概述 1.1 Java文件和.class文件的关系 Java文件 Java文件中包含代码的所有内容，类，接口，成员变量，成员方法&hellip; .class字节码文件 .java文件 通过 javac编译工具生成对应的.class字节码文件 使用JDK中提供的...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java基础——异常及处理方法
12345~
06-20 982
什么是异常？让我们先运行一段代码来理解 class Demo { int chuFa(int x,int y)//这是一个除法运算 { return x/y; } } public class ExceptionDemo { public static v
Java基础——IO流（四）
12345~
08-07 797
序列化对象将堆内存中的东西（对象）写到硬盘中ObjectOutputStream(OutputStream)中的writeObject方法可以将对象写入到硬盘中来 ObjectInputStream(InputStream)中的readObject方法可以将硬盘中的对象读取出来。先上手写程序： 先定义一个Per
Java基础——GUI概述
12345~
08-08 742
GUI图形用户界面GUI用户图形接口：用图形的方式，来显示计算机操作的界面，这样更方便更直观CLI命令行用户接口：就是常见的dos命令行操作，需要记忆一些常用的命令，操作不直观java为GUI提供的对象都存在java.Awt和javax.Swing两个包中Awt和Swing java.Awt抽象窗口工具包，需要调用
Java基础——其他类对象，IO流
12345~
07-30 742
System类System：类中的方法和属性都是静态的。 out：标准输出，默认是控制台 in ：标准输入，默认键盘描述系统的一些信息。获取系统属性信息：Propertise getPropertises();//获取系统信息的方法演示 import java.util.*; public class Syst
Java基础——String类、StringBuffer、Integer
12345~
07-12 692
String概述凡是带”“的都是String的实例对象。String s1 = "abc";s1是一个类类型变量，“abc”是一个对象。 字符串的最大特点就是，一旦被初始化就不可以被改变。 那么：String s1 = "abc"; s1 = "kk";这时候打印s1的值是kk; 这是为什么呢？不是说字符串一
Java基础——包
12345~
06-22 649
包package 什么是包？ 用来对类文件进行分类管理的，当类的内容不一样，但名称一样时，在同一个文件夹下不能保存同一个类文件，这个时候需要对类文件进行分类管理，将一个功能的所有class文件封装到一个文件夹中，这个文件夹就是包。 包也是一种封装形式，Java中包的出现，使不同的包中可以有相同名称的
Java基础——线程（一）
12345~
06-27 621
线程 进程：正在执行中的程序。每一个进程执行，都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。 简单一点来说进程和线程的关系，打开任务管理器可以看到很多正在执行的程序，每一个正在执行的程序就是进程， 而比如说迅雷下载数据的时候，会开辟
Java基础——集合框架（一）
12345~
07-14 596
集合类 为什么出现集合类？ 面向对象语言对事物的体现都是以对象形式存在的，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式 数组和集合类同是容器，有何不同？ 数组虽然也可以存储对象，但是长度是固定的。集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。 集合类的特点
线程之间通信、停止线程、守护线程
12345~
07-10 578
线程之间的通信在之前学习的线程的操作中，开启的多个线程执行的都是一样的操作，也就是说执行同一个run方法中的内容，但是，如果需要开启两个线程用不同的操作方法操作同一个数据呢？（a线程存数据，b线程取数据）具体需求如下图：按照需求先写代码出来：/* 需求，一个数据区用来存放姓名了年龄 开启一个线程负责输入数据 开启一个线程负责打印刚刚输入的数据 步骤，先把这三个事物进行描述，因为两个线
Java基础强化教程——张孝祥讲授
"Java基础加强--张孝祥版.ppt" 这份资料是张孝祥主讲的Java基础强化课程，由传智播客提供。课程旨在提升学员的Java编程技能，内容涵盖了诸多Java进阶主题，包括但不限于Eclipse的使用技巧、静态导入、可变参数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值