Java之反射四大核心类Class/Constructor/Method/Field

最新推荐文章于 2021-12-26 21:51:54 发布

guangtaoxie

最新推荐文章于 2021-12-26 21:51:54 发布

阅读量1.6k

点赞数 3

分类专栏： Java

本文链接：https://blog.csdn.net/tongxuexie/article/details/80288791

版权

本文详细介绍了Java反射机制中的四大核心类：Class、Constructor、Method和Field，包括它们的实例化方式、获取信息的方法以及如何通过反射创建对象、调用方法和设置/获取属性值。通过实例代码展示了反射在Java中的应用，强调了反射在实例化对象和操作类信息中的重要性。

摘要由CSDN通过智能技术生成

首先什么是反射？反射指的是对象的反向操作，先通过以下代码看看什么是正向操作。

package www.bit.java.reflect;
import java.util.Date;
public class Test {
	public static void main(String[] args) {
		//正向操作：1.先导入要使用的包  2.通过new实例化一个类的对象
		Date date=new Date();
		System.out.println(date);
	}
}

以上代码就是一个典型的正向操作，对于类的使用是通过包名.类名找到该类。而反向操作指的是根据类的实例化对象来取得类的相关信息。

注：在反射的世界里，注重的不再是实例化对象而是对象所对应的类的信息（如类名、构造方法、普通方法、属性等）。

1. Class类

Class类是系统提供的一个类，用于描述类的类，即描述具体类的信息的一个类。Class类对象由JVM产生，当类进行加载时，JVM就会产生该类的Class类对象，并且需要注意的是任何一个类都只有一个Class类对象。

1.1 Class类对象的三种实例化方式

（1）调用Object类的getClass()方法，任何类的实例化对象通过调用Object类的getClass()方法都可以取得其Class类对象。

public final native Class<?> getClass();

该方法是Object类的方法，用于取得Class类的对象，即取得调用该方法的对象对应的类的Class类对象。演示如下：

package www.bit.java.reflect;
import java.util.Date;
public class Test {
	public static void main(String[] args) {
		Date date=new Date();
		//调用getClass()方法取得Class类的对象
		Class<?> dateClass=date.getClass();
		System.out.println(dateClass);
	}
}

运行结果为：

class java.util.Date

此时，通过调用getClass()方法取得了Date类的Class类对象，而该Class类对象用于描述Date类的信息。即通过对象取得了对象的来源，即取得了对象所对应的类的信息。

（2）类.class，即直接根据具体类名称.class取得对应类的Class类对象。

package www.bit.java.reflect;
import java.util.Date;
public class Test {
	public static void main(String[] args) {
		//通过具体类名称.class取得具体类对应的Class类对象
		Class<?> dateClass=Date.class;
		System.out.println(dateClass);
	}
}

运行结果为：

class java.util.Date

（3）调用Class类的类方法forName()方法。

forName()方法的源代码如下：

@CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

通过源代码可以看出：forName()方法是Class类的类方法，传入的参数为具体的类的全名。演示如下：

package www.bit.java.reflect;
class Fruit{ //自定义类
	
}
public class Test {
	public static void main(String[] args) throws ClassNotFoundException {
		//通过Class类的类方法forName()实例化具体类的Class类对象
		Class<?> fruitClass=Class.forName("www.bit.java.reflect.Fruit");
		System.out.println(fruitClass);
	}
}

运行结果如下：

class www.bit.java.reflect.Fruit

通过以上三种方式都可以取得具体类的Class类对象，但是使用getClass()方法时需要先产生具体类的实例化对象，而另外两种不需要产生具体类的实例化对象也可以取得其Class类对象。

那么可不可以通过Class类对象从而实例化具体类的实例化对象呢？答案是肯定的。

1.2 通过反射实例化具体类的对象

通过反射实例化具体类的对象，调用的是Class类的newInstance()方法。演示如下：

package www.bit.java.reflect;
import java.util.Date;
public class Test {
	public static void main(String[] args) throws Exception {
		//通过反射实例化具体类Date的对象：1.先产生具体类的Class类对象  2.调用Class类的newInstance()方法
		Class<?> cls=Class.forName("java.util.Date");
		Object obj=cls.newInstance();
		System.out.println(obj);
		//以上通过反射实例化具体类的对象相当于以下操作：
		Date date=new Date();
		System.out.println(date);
	}
}

运行结果如下：

Sat May 12 10:35:16 CST 2018
Sat May 12 10:35:16 CST 2018

故，实例化具体类的对象有了两种方式：1.通过new关键字 2.通过反射

但需要注意的是：使用newInstance()方法的前提是该具体类具有无参的构造方法，因为newInstance()方法实质上是在其内部默认调用了该具体类的无参构造方法。若该具体类没有无参构造方法而调用了newInstance()方法后，则出现异常。演示如下：

package www.bit.java.reflect;
class Fruit{
	//自定义一个有参的构造方法,则系统默认提供的无参构造方法无效
	public Fruit(String msg){
		System.out.println(msg);
	}
}
public class Test {
	public static void main(String[] args) throws Exception {
		Class<?> cls=Class.forName("www.bit.java.reflect.Fruit");
		Object obj=cls.newInstance();
		System.out.println(obj);
	}
}

运行时出现异常：

Exception in thread "main" java.lang.InstantiationException: www.bit.java.reflect.Fruit
	at java.lang.Class.newInstance(Unknown Source)
	at www.bit.java.reflect.Test.main(Test.java:12)
Caused by: java.lang.NoSuchMethodException: www.bit.java.reflect.Fruit.<init>()
	at java.lang.Class.getConstructor0(Unknown Source)
	... 2 more

1.3 通过反射取得父类信息

在java中任何一个程序类都有父类，因为任何类都继承于Object类。

（1）取得类的包名称-------Class类的getPackage()方法

getPackage()方法的源代码如下：

 public Package getPackage();

调用getPackage()方法如下：

package www.bit.java.reflect;
//自定义接口
interface Fruit{}
//自定义类
class Message{}
//自定义子类
class Apple extends Message implements Fruit{}

public class Test {
	public static void main(String[] args) throws Exception {
		Class<?> cls=Class.forName("www.bit.java.reflect.Apple");
		Object obj=cls.getPackage();
		System.out.println(obj);
	}
}

运行结果如下：

package www.bit.java.reflect

（2）取得父类的Class类对象-------Class类的getSuperclass()方法

getSuperclass()方法的源代码如下：

public native Class<? super T> getSuperclass();

调用getSuperclass()方法如下：

package www.bit.java.reflect;
//自定义接口
interface Fruit{}
//自定义类
class Message{}
//自定义子类
class Apple extends Message implements Fruit{}

public class Test {
	public static void main(String[] args) throws Exception {
		Class<?> cls=Class.forName("www.bit.java.reflect.Apple");
		Class<?> superClass=cls.getSuperclass();
		System.out.println(superClass);
	}
}

运行结果如下：

class www.bit.java.reflect.Message

（3）取得实现的父接口------Class类的getInterfaces()方法

getInterfaces()方法的源代码如下：

public Class<?>[] getInterfaces();

该方法返回的是数组，该数组中存放的是该类实现的所有父接口。

调用getInterfaces()方法如下：

package www.bit.java.reflect;
//自定义接口1
interface Fruit{}
//自定义接口2
interface Drink{}
//自定义接口3
interface Eat{}
//自定义类
class Message{}
//自定义子类
class Apple extends