Java反射机制详解-优快云博客

java反射详解

本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。

下面开始正文。

【案例1】通过一个对象获得完整的包名和类名

package Reflect;
/**
* 通过一个对象获得完整的包名和类名
* */
class Demo{
//other codes...
}
public class hello{
public static void main(String[] args) {
Demo demo=new Demo();//这里还是用原来的方法生成的Demo对象，
//我们只是想通过这个对象得到完整的包.类名
//下面你将看到，我们不再用这种方式生成对象，和以前不太一样了，
//刚接触反射有点绕，因为以前的习惯了，刚学习有点反应不过来
System.out.println(demo.getClass().getName());
}
}

【运行结果】：Reflect.Demo

注意：java中是不是每个类都有一个Class类的实例？

如果java中每个类都有一个Class类的实例，那么是不是只要定义了一个类都会因为有一个Class类的实例而占内存空间呢？

可以这么说。　在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。
在运行期间，如果我们要产生某个类的对象，Java虚拟机会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象

这个问题不太确定，请高手解答。。【案例2】实例化 Class 类对象

package Reflect;
class Demo {
// other codes...
}
public class hello {
public static void main(String[] args) {
//实例化Class类对象，实例化Class类对象是反射机制的根源，
//所以涉及到反射的必须先对Class类对象进行实例化
Class<?> demo1 = null;
Class<?> demo2 = null;
Class<?> demo3 = null;
try {
// 一般尽量采用这种形式
demo1 = Class.forName("Reflect.Demo");
} catch (Exception e) {
e.printStackTrace();
}
demo2 = new Demo().getClass();
demo3 = Demo.class;
System.out.println("类名称 " + demo1.getName());
System.out.println("类名称 " + demo2.getName());
System.out.println("类名称 " + demo3.getName());
}
}

【运行结果】：

类名称 Reflect.Demo

【案例3】通过Class实例化其他类的对象,分为两种无参，有参，都是调用 newInstance() 方法

package Reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
class Person {
private String name;
private int age;
public Person() {
System.out.println("无参构造函数");
}
public Person(String name, int age) {
System.out.println("有参构造函数");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "[" + this.name + " " + this.age + "]";
}
}
public class hello {
public static void main(String[] args) throws Exception {
Class<?> demo = null;
// 实例化Class类对象，反射的根源
demo = Class.forName("Reflect.Person");
Person per = null;
// 调用无参构造函数，创建Person对象实例
per = (Person) demo.newInstance();
per.setName("Rollen");
per.setAge(20);
System.out.println(per);
// 使用有参的构造函数初始化，必须要得到相应的构造函数
Constructor<Person> constructor = (Constructor<Person>) demo
.getConstructor(String.class, int.class);
per = constructor.newInstance("张三", 100);
System.out.println(per);
}
}

【运行结果】：

无参构造函数

[Rollen 20]

有参构造函数

[张三 100]

【案例】通过 Class 调用其他类中的构造函数（也可以通过这种方式通过 Class 创建其他类的对象）多个构造函数，一定要注意顺序，Debug时可以清楚的看到顺序

package Reflect;
import java.lang.reflect.Constructor;
class Person{
public Person() {
}
public Person(String name){
this.name=name;
}
public Person(int age){
this.age=age;
}
public Person(String name, int age) {
this.age=age;
this.name=name;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString(){
return "["+this.name+" "+this.age+"]";
}
private String name;
private int age;
}
public class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
Person per1=null;
Person per2=null;
Person per3=null;
Person per4=null;
//取得全部的构造函数
Constructor<?> cons[]=demo.getConstructors();
try{
per1=(Person)cons[0].newInstance();
per2=(Person)cons[1].newInstance("Rollen");
per3=(Person)cons[2].newInstance(20);
per4=(Person)cons[3].newInstance("Rollen",20);
}catch(Exception e){
e.printStackTrace();
}
System.out.println(per1);
System.out.println(per2);
System.out.println(per3);
System.out.println(per4);
}
}

注意一点：上面运行出错，因为构造函数不匹配，通过Debug查看：

cons[0] 对应 public Reflect.Person(java.lang.String)

cons[1] 对应 public Reflect.Person(int)

cons[2] 对应 public Reflect.Person(java.lang.String,int)

cons[3] 对应 public Reflect.Person()

调整顺序才可以正常执行。。

【案例】返回一个类实现的接口：

package Reflect;
interface China{
public static final String name="Rollen";
public static int age=20;
public void sayChina();
public void sayHello(String name, int age);
}
class Person implements China{
public Person() {
}
public Person(String sex){
this.sex=sex;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void sayChina(){
System.out.println("hello ,china");
}
public void sayHello(String name, int age){
System.out.println(name+" "+age);
}
private String sex;
}
public class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
//保存所有的接口
Class<?> intes[]=demo.getInterfaces();
for (int i = 0; i < intes.length; i++) {
System.out.println("实现的接口 "+intes[i].getName());
}
}
}

【运行结果】：

实现的接口 Reflect.China

（注意，以下几个例子，都会用到这个例子的Person类，所以为节省篇幅，此处不再粘贴Person的代码部分，只粘贴主类hello的代码）

【案例】：取得其他类中的父类

public class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
//取得父类
Class<?> temp=demo.getSuperclass();
System.out.println("继承的父类为： "+temp.getName());
}
}

【输出结果】：继承的父类为： java.lang.Object

【案例】：获得其他类中的全部构造函数

public class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
Constructor<?>cons[]=demo.getConstructors();
for (int i = 0; i < cons.length; i++) {
System.out.println("构造方法： "+cons[i]);
}
}
}

【输出结果】：

构造方法： public Reflect.Person(java.lang.String)

构造方法： public Reflect.Person()

【通过拼凑的方法输出构造方法】

public class hello {
public static void main(String[] args) {
Class<?> demo = null;
try {
demo = Class.forName("Reflect.Person");
} catch (Exception e) {
e.printStackTrace();
}
Constructor<?> cons[] = demo.getConstructors();
for (int i = 0; i < cons.length; i++) {
//构造方法参数类型
Class<?> p[] = cons[i].getParameterTypes();
System.out.print("构造方法： ");
//修饰符
int mo = cons[i].getModifiers();
System.out.print(Modifier.toString(mo) + " ");
//构造方法名
System.out.print(cons[i].getName());
System.out.print("(");
for (int j = 0; j < p.length; ++j) {
//构造方法参数类型名
System.out.print(p[j].getName() + " arg" + i);
if (j < p.length - 1) {
System.out.print(",");
}
}
System.out.println("){}");
}
}
}

【运行结果】：

构造方法： public Reflect.Person(){}

构造方法： public Reflect.Person(java.lang.String arg1){}

有时候一个方法可能还有异常，呵呵。下面看看：

class hello {
public static void main(String[] args) {
Class<?> demo = null;
try {
demo = Class.forName("Reflect.Person");
} catch (Exception e) {
e.printStackTrace();
}
Method method[] = demo.getMethods();
for (int i = 0; i < method.length; ++i) {
//返回类型
Class<?> returnType = method[i].getReturnType();
//参数类型
Class<?> para[] = method[i].getParameterTypes();
//修饰符
int temp = method[i].getModifiers();
System.out.print(Modifier.toString(temp) + " ");
System.out.print(returnType.getName() + " ");
System.out.print(method[i].getName() + " ");
System.out.print("(");
for (int j = 0; j < para.length; ++j) {
//参数类型名
System.out.print(para[j].getName() + " " + "arg" + j);
if (j < para.length - 1) {
System.out.print(",");
}
}
Class<?> exce[] = method[i].getExceptionTypes();
if (exce.length > 0) {
System.out.print(") throws ");
for (int k = 0; k < exce.length; ++k) {
//异常的名字
System.out.print(exce[k].getName() + " ");
if (k < exce.length - 1) {
System.out.print(",");
}
}
} else {
System.out.print(")");
}
System.out.println();
}
}
}

【运行结果】

public java.lang.String getSex ()
public void setSex (java.lang.String arg0)
public void sayChina ()
public void sayHello (java.lang.String arg0,int arg1)
public native int hashCode ()
public final native java.lang.Class getClass ()
public final void wait () throws java.lang.InterruptedException
public final void wait (long arg0,int arg1) throws java.lang.InterruptedException
public final native void wait (long arg0) throws java.lang.InterruptedException
public boolean equals (java.lang.Object arg0)
public final native void notify ()
public final native void notifyAll ()
public java.lang.String toString ()