Java学习笔记——反射与类操作

最新推荐文章于 2022-07-24 17:23:41 发布
最新推荐文章于 2022-07-24 17:23:41 发布
阅读量187 收藏
点赞数
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44336181/article/details/108613896
版权

1.获取类的基本信息

一个类的基本信息主要包括类所在的包名称、父类的定义、父接口的定义。
【范例】定义一个程序类

package demo.service;

public interface IMessageService {
	public void send();
}

package demo.service;

public interface IChannelService {
	public boolean connect();
}


package demo.abs;

public abstract class AbstractBase {

}


package demo.vo;

import demo.abs.AbstractBase;
import demo.service.IChannelService;
import demo.service.IMessageService;

public class Person extends AbstractBase implements IMessageService,IChannelService {

	@Override
	public boolean connect() {
		// TODO Auto-generated method stub
		return true;
	}

	@Override
	public void send() {
		System.out.println("信息发送。。。。。");
	}
	
}

如果要想获得类的一些基础信息可以通过Class类中的如下方法：

  • 获取包名称：public Pakage getPackage()
    【范例】获得包名称
package demo;

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
	Class<?> cls = Person.class;//获取指定类的Class对象
	Package pack = cls.getPackage();//获取指定包定义
	System.out.println(pack.getName());
	}
}
  • 获取继承父类：public Class<? super T>getSuperclass();
    【范例】获取父类信息
package demo;

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
	Class<?> cls = Person.class;//获取指定类的Class对象
	Class<?> parent = cls.getSuperclass();
	System.out.println(parent.getName());
	System.out.println(parent.getSuperclass().getName());
	System.out.println(parent.getSuperclass().getSuperclass());
	}
}
  • 获取实现父接口：public Class<?>[] getInterfaces()
    【范例】获取父接口
package demo;

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
	Class<?> cls = Person.class;//获取指定类的Class对象
	Class<?> clazz[] = cls.getInterfaces();
	for(Class<?> temp:clazz) {
		System.out.println(temp.getName());
	}
	
	}
}

当获取了一个类的Class对象之后就意味着这个对象可以 获取类之中的一切继承结构信息。

2.反射调用构造方法

在一个类之中除了有继承的关系之外最为重要的操作就是类中的结构处理了，而类中的结构里面首先需要观察的就是构造方法的使用问题。

  • 实例化方法替代：clazz.getDeclaredConstructor().newInstance();
    所有类的构造方法获取都可以直接通过Class类来完成，该类中定义有如下的几个方法：
  • 获取所有构造方法：public Constructor<?>[] getDeclaredConstructors() throws SecutrityException
  • 获取指定构造方法:public Constructor<T> getDeclaredConstructor(Class<?>...parameterTypes) throws NoSuchMethodException,SecurityException
  • 获取所有构造方法：public Constructor<?>[] getConstructors() throws SecutrityException
  • 获取指定构造方法:public Constructor<T> getConstructor(Class<?>...parameterTypes) throws NoSuchMethodException,SecurityException
    【范例】修改person类定义
package demo.abs;

public abstract class AbstractBase {
	public AbstractBase() {}
	public AbstractBase(String msg) {}
}


package demo.vo;

import demo.abs.AbstractBase;
import demo.service.IChannelService;
import demo.service.IMessageService;

public class Person extends AbstractBase implements IMessageService,IChannelService {
	private String name;
	private int age;
	public Person() {}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public boolean connect() {
		return true;
	}

	@Override
	public void send() {
		System.out.println("信息发送。。。。。");
	}
	
}

【范例】获取构造

package demo;

import java.lang.reflect.Constructor;

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Person.class;// 获取指定类的Class对象
		Constructor<?>[] constructors = cls.getDeclaredConstructors();//此处与getConstructors()无区别
		for (Constructor<?> cons : constructors) {
			System.out.println(cons);
		}
	}
}
#public demo.vo.Person()
#public demo.vo.Person(java.lang.String,int)

此时获取的是类之中的全部构造方法，但是也可以获取一个指定参数的构造，例如现在Person类之中提供有两个构造方法。

package demo.vo;

import demo.abs.AbstractBase;
import demo.service.IChannelService;
import demo.service.IMessageService;

public class Person extends AbstractBase implements IMessageService,IChannelService {
	private String name;
	private int age;
	public Person() {}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "name:" + this.name + "__age:" + this.age;
	}
	@Override
	public boolean connect() {
		return true;
	}

	@Override
	public void send() {
		System.out.println("信息发送。。。。。");
	}
	
}

此时程序打算调用有参构造方法进行Person类对象的实例化处理，这个时候必须要指明要调用的构造，而后通过Constructor之中提供的实例化方法操作：public T newInstance(Object.. initargs) throws InstantiationException,IllegalAccessException,IllegalArgumentExcpetion,InvocationTargetException

【范例】调用指定构造方法

package demo;

import java.lang.reflect.Constructor;

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Person.class;// 获取指定类的Class对象
		Constructor<?> constructor = cls.getConstructor(String.class,int.class);
		Object obj = constructor.newInstance("小强",88);
		System.out.println(obj);
	}
}

虽然程序本身允许开发者调用有参构造，但从实际开发讲，所有使用反射的类中最好提供有无参构造，因为这样的实例化可以达到统一性。

3.获取方法

在机械能反射处理的时候也可以通过反射来获取类之中的全部方法，如果要想通过反射调用这些方法，必须有前提条件：类之中必须提供有实例化对象。
在Class类里面提供有如下的操作可以获取方法对象：

  • 获取全部方法：public Method[] getMethods() throws SecurityException
  • 获取指定方法：public Method getMethod(String name,Class<?>...parameterTypes) throws NoSuchMethodException,SecurityException
  • 获取全部方法：public Method[] getDeclaredMethods() throws SecurityException
  • 获取指定方法：public Method getDeclaredMethod(String name,Class<?>...parameterTypes) throws NoSuchMethodException,SecurityException

【范例】获取方法：

package demo;

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

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Person.class;// 获取指定类的Class对象
		{
			//获取全部方法(包括父类中的方法)
			Method[] methods = cls.getMethods();//如果只想获取本类的方法，换成getDeclaredMethods()即可
			for(Method met:methods ) {
				System.out.println(met);
			}
		}
	}
}

这个时候的方法信息的获取是依靠Method类提供的toString()方法完成的，很多时候也可以由用户自己来拼凑方法信息的形式展示信息。

package demo;

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

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Person.class;// 获取指定类的Class对象
		{
			//获取全部方法(包括父类中的方法)
			Method[] methods = cls.getMethods();//如果只想获取本类的方法，换成getDeclaredMethods()即可
			for(Method met:methods ) {
				int mod  = met.getModifiers();//修饰符
				System.out.print(Modifier.toString(mod) + " ");
				System.out.print(met.getReturnType().getName() + " ");
				System.out.print(met.getName() + "(");
				Class<?> params[] = met.getParameterTypes();
				for(int x=0; x<params.length;x++) {
					System.out.print(params[x].getName()+ " " + "arg-" + x);
					if(x<params.length-1) {
						System.out.print(",");
					}
				}
				System.out.print(")");
				Class<?> exp [] = met.getExceptionTypes();
				if(exp.length>0){
					System.out.print(" throws ");
				}
				for (int x=0;x< exp.length ;x++) {
					System.out.print(exp[x].getName());
					if(x<exp.length -1) {
						System.out.print(",");
					}
				}
				System.out.println();
			}
		}
	}
}

反射结构获取方法中，Method类最重要的方法：public Object invoke(Object obj,Object... args) throws IllegalAccessException,IllegalArgumentException,InvocationTargetException

public class Person extends AbstractBase implements IMessageService,IChannelService {
	private String name;
	private int age;
	public Person() {}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}

随后通过反射机制来实现Person类之中的setter与getter方法的处理。
【范例】在不导入指定类开发包的情况下实现属性的配置

package demo;

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

import demo.vo.Person;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Class.forName("demo.vo.Person");//获取指定类的class对象
		String attribute = "name";//要操作的类属性
		String value = "小强子";//要设置的属性内容
		//1、任何情况下如果要想保存类中的属性或者调用类中的方法必须要保证存在有实例化对象，既然不允许导入包，则就使用反射实例化
		Object obj = cls.getDeclaredConstructor().newInstance();//调用无参构造实例化
		//2、如果要进行方法的调用，一定要获取方法名称
		String setMethodName = "setName";
		Method setMethod = cls.getDeclaredMethod(setMethodName, String.class);//获取指定方法
		setMethod.invoke(obj, value);//等价于：Person对象.setName(value);
		String getMethodName = "getName";
		Method getMethod = cls.getDeclaredMethod(getMethodName);//getter没有参数
		System.out.println(getMethod.invoke(obj));//等价于：Person对象.getName()
		
	}
}

利用此类操作整体的形式上不会有任何的明确的类对象产生，一切都是依靠反射机制处理的，这样的机制避免了与一个类的耦合问题。

获取成员

类结构之中的最后一个核心的组成就是成员（Field），大部分情况下都将其称为成员属性，对于成员信息的获取通过Class类完成，有如下两组方法：

  • 获取本类全部成员：public Fiekdp[] getDeclaredFields() throws SecurityException;
  • 获取本类指定成员： public Field getDeclaredField(String name) throws NoSuchFieldException,SecurityException
  • 获取父类全部成员：public Field[] getFields() throws SecurityException;
  • 获取父类指定成员：public Field getField(String name) throws NoSuchFieldException,SecurityException

【范例】修改AbstractBase和IChannelService成员

package demo.abs;

public abstract class AbstractBase {
	public static final String BASE = "www.asdasd.asd";
	public String info = "Hello world";
	public AbstractBase() {}
	public AbstractBase(String msg) {}
}


package demo.service;

public interface IChannelService {
	public static final String name ="asdasd";
	public boolean connect();
}


package demo;
import java.lang.reflect.Field;
public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Class.forName("demo.vo.Person");//获取指定类的class对象
		Field fields [] = cls.getFields();//获取成员
		System.out.println("获取父类中的成员");
		for(Field fie:fields) {
			System.out.println(fie);
		}
		System.out.println("------获取子类中的成员------------");
		Field fids [] = cls.getDeclaredFields();
		for(Field fie: fids) {
			System.out.println(fie);
		}
	}
}

//获取父类中的成员
//public static final java.lang.String demo.service.IChannelService.name
//public static final java.lang.String demo.abs.AbstractBase.BASE
//public java.lang.String demo.abs.AbstractBase.info
//-----获取子类中的成员------------
//private java.lang.String demo.vo.Person.name
//private int demo.vo.Person.age

Field类中最为重要的操作方法：最重要三个方法：

  • 设置属性内容： public void set(Object obj,Object value) throws IllegalArgumentException,IllegalAccessException
  • 获取属性内容：public Object get(Object obj) throws IllegalArgumentException,IllegalAccessException
  • 解除封装：public void setAccessible(boolean flag);

所有的成员都是在对象实例化之后进行空间分配的，所以此时的成员获取一定要现有实例化对象，之后，才可以进行成员的操作。
【范例】直接调用Person类中的name私有成员

package demo;

import java.lang.reflect.Field;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Class.forName("demo.vo.Person");//获取指定类的class对象
		Object obj = cls.getConstructor().newInstance();//实例化对象分配成员空间
		Field nameField = cls.getDeclaredField("name");//获取成员对象
		nameField.setAccessible(true);//解除封装
		nameField.set(obj, "cherry");//等价于；Person.name = “cherry”；
		System.out.println(nameField.get(obj));//等价于Person.name;
	}
}

类之中的构造、方法、成员属性都可以通过反射实现调用，对于成员调用大部分操作应该通过setter和getter处理。对于Field类，只有一个方法最为常用：

  • 获取成员类型：public Class<?> getType();
    【范例】获取Person类中name类型
package demo;


import java.lang.reflect.Field;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Class.forName("demo.vo.Person");//获取指定类的class对象
		Object obj = cls.getConstructor().newInstance();//实例化对象分配成员空间
		Field nameField = cls.getDeclaredField("name");//获取成员对象
		System.out.println(nameField.getType().getName());
		System.out.println(nameField.getType().getSimpleName());
	}
}

Unsafe工具类

这个类的主要特点是可以利用反射来获取对象，并且直接使用底层的C++来代替JVM执行，即：可以绕过JVM的相关的对象的管理机制，如果一旦使用了Unsafe类，项目之中将无法使用JVM的内存管理机制以及垃圾回收处理。

  • 构造方法：private Unsafe(){}
  • 私有常量：private static final Unsafe theUnsafe = new Unsafe();
    注意：在Unsafe类里面没有提供static方法，即：不能够通过类似于传统的单例设计模式之中的操作样式来进行操作，如果要想获得这个类的对象，则要用反射操作来完成。
package demo;
import java.lang.reflect.Field;
import sun.misc.Unsafe;
public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Field field = Unsafe.class.getDeclaredField("theUnsafe");
		field.setAccessible(true);
		Unsafe unsafeObject = (Unsafe) field.get(null);//static 属性不需要传递实例化对象
	}
}

【范例】Unsafe绕过实例化对象管理：

package demo;


import java.lang.reflect.Field;

import sun.misc.Unsafe;

public class JavaAPIDemo {
	public static void main(String[] args) throws Exception {
		Field field = Unsafe.class.getDeclaredField("theUnsafe");
		field.setAccessible(true);
		Unsafe unsafeObject = (Unsafe) field.get(null);//static 属性不需要传递实例化对象
		//利用Unsafe类绕过了JVM管理机制，可以在没有实例化对象的情况下获取一个Ｓｉｎｇｌｅｔｏｎ实例化对象
		Singleton instance = (Singleton) unsafeObject.allocateInstance(Singleton.class);
		instance.print();
	}
}
class Singleton{
	private static final Singleton INSTANCE = new Singleton();
	private Singleton() {
		System.out.println("********Singleton类构造***********");
	}
	public static Singleton getInstance() {
		return INSTANCE;
	}
	public void print() {
		System.out.println("wwwwwww");
	}
}
//********Singleton类构造***********
//wwwwwww

参考资料：
https://edu.aliyun.com/lesson_1012_9049?spm=5176.10731542.0.0.6990d290ecMYNk

Demonwuwen
关注
专栏目录
【noip模拟赛】 总结与反思——字符串的展开
C202207LYX的博客
07-25 333
序言： 这次考试我应该是最值得反思呢… 第一题和第三题有思路，注意了坑点。但是最后败在了，代码实现上了… 后面打表吧，样例没有输出，结果自己去算了一个不会出现的测试点的样例… 考完之后，才发现原来的第三道题的代码，是对的，但是细节有问题。结果去打表了。 顿时感觉人生已经失去了光彩。。。 算了考试已经考完了，把总结写好吧。 A——字符串的展开： 题目描述： 在初赛普及组的“阅读程序写结果”的问题中，我们曾给出一个字符串展开的例子：如果在输入的字符串中，含有类似于“d-h”或者“4-8”的字串，我们就把它当作
廖雪峰java教程学习笔记——反射
zhang35的博客
05-28 240
反射 Reflection Java的反射是指程序在运行期可以拿到一个对象的所有信息。 它更多地是给工具或者底层框架来使用，目的是在不知道目标实例任何信息的情况下，获取特定字段的值。 Class类 每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class：： public final class Class { private Class() {} } Class 是一种特殊的类，用来描述各种类信息。 对于未知的类，想知
反射与类操作
weixin_30849591的博客
03-17 91
取得父类信息 　　利用反射可以做出一个对象所具备的所有操作行为，而且最关键的是这一切的操作都可以基于Object类型进行， 　　在java里面任何的程序类都一定会有一个父类，那么在Class类里面就可以通过此方式来取得父类或者是实现的父接口，有如下的两个方法提供： 　　　　取得类的包名称：public Package getPackage() 　　　　取得父类的Class对象：public...
反射的与类操作
QLH的博客
03-29 166
1.取得父类信息 2.反射调用构造 3.反射调用普通方法 4.反射调用类中属性
反射和类操作
liangyuanhao46的博客
10-28 108
1.反射获取类结构信息 类 package fan; public class Javademo extends abstractbase implements fan,server{ @Override public void send() { System.out.println(); } @Override public void server() { System.out.println(); } } packa
Java学习笔记——反射机制
m0_67198282的博客
07-24 335
反射机制
java学习——java中的反射学习笔记.rar_java 反射
09-21
总结，Java反射提供了一种强大的手段来探索和操作类，但它也带来了性能和安全的挑战。在使用时应谨慎评估，确保其带来的灵活性能够抵消潜在的负面影响。了解并熟练掌握反射机制，对于Java程序员来说，是提升代码能力...
JAVA学习笔记——面向对象编程：枚举类与反射
weixin_43410001的博客
04-07 587
目录枚举类定义枚举类枚举类方法反射Class 类捕获异常利用反射分析类的能力在运行时使用反射分析对象使用反射编写泛型数组代码调用任意方法 枚举类 “枚举”，顾名思义，就是一一全部列举。生活中我们时常用到“枚举”，例如性别有“男”和“女”、一星期只有周一到周日 7 天。 而在程序设计时，对于这种有固定个数取值的变量，不妨可以考虑使用枚举类。类比基本数据类型（仅仅是类比，并不完全相同），枚举类可以看作是我们自定义了一个新的“数据类型”，它的取值为有限个，类名等价于 int，我们自定义的取值等价于 int 类的各
JAVA学习笔记————————
04-25
8. **反射机制**：JAVA反射机制允许在运行时动态地获取类的信息并操作类的对象，这对于插件开发、动态代理等高级功能至关重要。 9. **JNI（Java Native Interface）**：当JAVA代码需要调用本地（C/C++）代码时，JNI...
Java反射--反射与类操作
xzzz2020的博客
02-06 483
内容学习于：edu.aliyun.com 1. 反射获取类结构   使用Class实现了对象实例化，并且通过Class类反射构造了类的实例化对象，但是这并不意味着这些全部都属于反射机制的功能，如果认真去分析的话，实际上反射可以完整的实现Java允许规定的类的操作形式。   如果在日后的开发之中你突然发现需要对二进制文件做更深入的一层分析的时候，那么此时你有两个选择: 选择一:通过Oracl...
反射与类操作（3）
monongLY的博客
09-24 206
反射的目的不仅仅只是替代关键字new，而在于反射可以直接操作类的各种结构。取得父类信息 Class类中定义有如下方法： ·取得完整类名称：public String forName(); ·取得类名称：public String getSimpleName(); ·取得父类Class对象：public Class<? super T> getSuperclass(); ·取得所有实现的接口信息：pu
java 反射实例化类_java学习笔记之反射—Class类实例化和对象的反射实例化
weixin_30323179的博客
02-12 289
反射之中所有的核心操作都是通过Class类对象展开的，可以说Class类是反射操作的根源所在，但是这个类的实例化对象，可以采用三种方式完成。java.lang.Class类的定义：public final class Classextends Objectimplements Serializable, GenericDeclaration, Type, AnnotatedElement, Typ...
c# uri.host_C＃| Uri.IsAbsoluteUri属性与示例
cumtb2009的博客
07-13 386
c# uri.host Uri.IsAbsoluteUri属性 (Uri.IsAbsoluteUri Property) Uri.IsAbsoluteUri Property is the instance property of Uri class which used to check that given URI is absolute or not. This property retur...
Java反射-类基本操作
we.think
10-18 312
目录一、Class对象1.1 类描述1.2 类方法1.3 特点二、获取类对象2.1 获取类对象方式 Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。实际上，我们创建的每一个类也都是对象，即类本身是java.lang.Class类的实例对象。这个实例对象称之为类对象，也就是Class对象。那么，Class对象又是什么对象呢？ 一、Class对象 1.1
java--反射与类操作
weixin_43852903的博客
04-15 92
目录 1 反射取得父类、父接口信息 2 反射调用类中构造方法 3 反射调用类中普通方法 4 反射调用类中普通属性 5 动态设置封装 1 反射取得父类、父接口信息 在Class类中可以通过以下方法来取得父类、实现父接口信息： 1.取得父类包名称 public package getPackage(); 2.取得父类class对象 public native Class<? s...
java——反射、反射与类操作
tt 博客
04-20 166
正常处理 public class Test { public static void main(String[] args) { Date date = new Date() ; } } 以上是我们正常的关于对象的处理流程:根据包名.类名找到类；所谓的"反"指的是根据对象来取得对象的来源信息，而这个"反"的操作核心的处理就在Object类的一个方法:取得Class对象:...
java反射操作类结构（二）
wanghaoxin的博客
06-16 354
java反射操作类结构 反射操作构造方法 Class只是作为反射的操作源头，但是严格来讲，反射还有其他内容。反射给用户最大的方便有三点： 1.构造调用 2.方法调用 3.属性调用 在反射机制里面提供有java.lang.reflect包，包中最重要的三个类： Constructor、Method、Field 构造方法调用 利用Class类中的forName()方法可以取得Cl...
C# System.Uri类_获取Url的各种属性_文件名_参数_域名_端口等等
06-23 434
C# System.Uri类_获取Url的各种属性_文件名_参数_域名_端口等等 　System.Uri类用于处理Uri地址信息，常用到它的地方有，相对Uri地址转绝对Uri地址，获取Uri的某部分信息等等，可以说是一个非常有用的类。 一、属性 Absolute...
Java编程：学习笔记——有返回值的方法与异常处理
"Java学习笔记，包含了Java编程中的一些关键概念和常见异常处理。" Java是一种广泛使用的面向对象的编程语言，其语法严谨且具有高度的可移植性。在Java中，方法是代码块，用于执行特定任务。方法可以带有返回值，也...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值