二十六、Java--------反射

反射

正常情况下，我们必须知道一个类的完整路径后才可以实例化对象，但是在Java也可以通过一个对象来找到其所在类的信息，这其实就是Class的功能。

可以看到此时的所有操作都是反着来，这就是反射。

package reflect;

class X{

}

public class GetClassDemo01 {

public static void main(String[] args) {

X x=new X();

System.out.println(x.getClass().getName());

}

}

Class

Class本身表示一个类的本身，通过Class可以完整的得到一个类的完整结构，包括此类中的方法定义、属性定义等。

此类在jdk中文档中没有发现任何构造方法，所以此类的构造方法是被私有化了。

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

♥ 第一种：通过forName()方法

♥ 第二种: 通过类class

♥ 第三种：通过对象.getClass()

package reflect;

class X{

}

public class GetClassDemo01 {

public static void main(String[] args) {

Class <?> c1=null;

Class <?> c2=null;

Class <?> c3=null;

try {

//通过第一种方式实例化Class对象，这种方法也是最常用的一种形式

c1=Class.forName("reflect.X");

//通过Object类中的放过实例化Class对象

c2=new X().getClass();

//通过类.cass实例化Class

c3=X.class;

System.out.println("类名称：" + c1.getName() );

System.out.println("类名称：" + c2.getName() );

System.out.println("类名称：" + c3.getName() );

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

一旦可以实例化Class对象之后就可以进行反射的进一步操作了。

Class的使用

Class主要是反射的源头，不光可以取得对象所在类的信息，也可以直接通过Class类的方法进行对象的实例化对象操作，使用关键字new为对象实例化，如果现在已经实例化好Class对象，则可以通过Class类提供的newInstance()方法实例化对象。

package reflect;

class Person{

private String name;

private int age;

@Override

public String toString(){//为了操作方便，复写toString放过

return "姓名:"+this.name+",年龄"+this.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;

}

}

public class InstanceDemo01 {

public static void main(String[] args) {

Class<?> c=null;

try {

c=Class.forName("reflect.Person");

Person per=null;

per=(Person) c.newInstance();//实例化对象

per.setName("月芽之上");

per.setAge(24);

System.out.println(per.toString());

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (InstantiationException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

通过以上的代码可以发现，即使不适用 new关键字对象也可以进行实例化操作，这也就是反射的作用。但是我们也发现在使用以上操作的时候有一点需要注意，就是所操作的类中必须有午餐构造函数，否则无法进行实例化！

为了解决这一问题，我们需要明确的指明要调用的方法，并传递参数，（实际开发中一般会有午无参构造）。步骤如下：

❤ 1、通过Class类中的getConstructors()取得本类中的全部构造方法。

❤ 2、向构造方法中传递一个对象数组进去，里面包含了构造方法中所需的各个参数

❤ 3、之后通过Constructor实例化对象

在Construction类中存在一个方法：

public T newInstance(Object... initargs)

throws InstantiationException,

IllegalAccessException,

IllegalArgumentException,

InvocationTargetException

传递参数初始化，以进行对象的实例化操作。

Constru中常用方法：

调用带参数的构造方法示例

package reflect;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

class Person{

private String name;

private int age;

public Person(String name,int age){//定义一个有两个参数的构造函数，此时当前类不再存在无参构造

this.name=name;

this.age=age;

}

@Override

public String toString(){//为了操作方便，复写toString放过

return "姓名:"+this.name+",年龄"+this.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;

}

}

public class InstanceDemo01 {

public static void main(String[] args) {

Class<?> c=null;

try {

c=Class.forName("reflect.Person");

Constructor<?> cons[]=null;

cons=c.getConstructors();

Person per=null;

per=(Person) cons[0].newInstance("月芽之上",24);//实例化对象

System.out.println(per.toString());

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

}

通过反射获取类的结构

在实际开发中，上面介绍的程序就是反射用的最多的情况，当然反射机制所提供的功能远不止这些，还可以通过反射获取一个类的完整结构，那么这是就要使用到java.lang.reflect保重的一些几个类。

❤ 1、Constructor ：表示类中的构造方法

❤ 2、Filed ：表示类中的属性

❤ 3、Method ：表示类中的方法

这三个类都是AccessibleObject的子类

package reflect.construction;

interface China{

String NATIONAL="China";//定义全局变量

String AUTHOR="月芽之上";//定义全局变量

void sayChina();

String sayHello(String name,int age);

}

public class Person implements China {

private String name;

private int age;

Person(){//无参构造

}

Person(String name){//设置name

this.name=name;

}

Person(String name,int age){//设置name

this.name=name;

this.age=age;

}

@Override

public void sayChina() {

System.out.println("作者："+AUTHOR+",国籍"+NATIONAL);

}

@Override

public String sayHello(String name, int age) {

return name+",你好，我今年"+ 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;

}

}

取得类所实现的全部接口

要取得一个类所实现的接口，则必须使用Class类中的getInterfaces()方法。此方法定义如下：

public Class<?>[] getInterfaces()

方法的返回值是一个class类的对象数组，之后就可以直接利用Class类中的getName()方法输出即可、

public class GetInterfaceDemo {

public static void main(String[] args) {

Class<?> c1=null;

try {

c1=Class.forName("reflect.construction.Person");

Class<?> c[]=c1.getInterfaces();

for(int i=0;i<c.length;i++){

System.out.println(c[i].getName());

}

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

取得该类所继承的父类

一个类可与有多个实现，但是却只能有一个直接父类，所以想要取得一个类的父类，可以使用Class类中的getSuperclass()方法。

public Class<? super T> getSuperclass()

此方法返回的是Class实例，和之前取得接口一样，可以通过getName(0方法取得名次

public class GetSuperClassDemo {

public static void main(String[] args) {

Class<?> c1 = null;

try {

c1 = Class.forName("reflect.construction.Person");

Class<?> c = c1.getSuperclass();

System.out.println(c.getName());

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

取得全部构造函数

import java.lang.reflect.Constructor;

public class GetConstructorDemo {

public static void main(String[] args) {

Class<?> c1=null;

try {

c1=Class.forName("reflect.construction.Person");//实例化Class对象

Constructor<?>[] cons=c1.getConstructors();//得到全部构造方法

for(int i=0;i<cons.length;i++){

System.out.println(cons[i]);//打印所以构造方法

}

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

取得类中的方法

要取出一个类中的全部方法，可以使用Class类中的getDeclaredMethods()方法，此方法返回的是一个Method类的对象数组。而想取得方法的具体信息例如：方法参数、抛出的异常等等，就必须依靠Mehod类。

public Method getDeclaredMethod(String name, Class<?>... parameterTypes)                    取出本类的全部方法

throws NoSuchMethodException,SecurityException

public Method[] getMethods()                                                                  取得全部方法

throws SecurityException

public class GetMethodDemo {

public static void main(String[] args) throws ClassNotFoundException {

Class<?> c1=null;

c1=Class.forName("reflect.construction.Person");

Method m[]=c1.getMethods();

for(int i=0;i<m.length;i++){

System.out.println(m[i]);

}

}

}

取出类中的属性：

依赖的方法：

public Field[] getFields()  throws SecurityException

public Field[] getDeclaredFields()  throws SecurityException

public class GetFiledDemo {

public static void main(String[] args) throws ClassNotFoundException {

Class<?> c1=null;

c1=Class.forName("reflect.construction.Person");

Field f[]=c1.getFields();

for(int i=0;i<f.length;i++)

{

System.out.println(f[i]);

}

}

}

通过反射调用类中的方法

在正常情况下一个类对象产生后就可以直接调用类中的方法了．如果要调用的话肯定必须清楚的指定调用的方法名是什么，之后通过Class 中的getMethod()方法。

public Method getMethod(String name, Class<?>... parameterTypes)

throws NoSuchMethodException, SecurityException

该方法得到的Method对象，之后通过此Method对象来执行方法，但是在调用的时候因为会涉及到参数的问题，所以通过getMehod()取得的时候需要要设置好对应的参数类型。

比如调用Person中sayChina()方法，因为该方法中没有任何参数，所以只需要调用Method 中invoke()方法。

public Object invoke(Object obj,Object... args)
                throws IllegalAccessException,IllegalArgumentException,InvocationTargetException

执行的时候需要还需要传递参数进去， 而且需要实例化对象。

public class InvokeSayChinaDemo {

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {

Class<?> c1=null;

c1=Class.forName("reflect.construction.Person");//实例化Class对象

Method met=c1.getMethod("sayChina");//找到sayChina()方法

met.invoke(c1.newInstance());//调用方法

}

}

调用有参数的方法

public class InvokeSayChinaDemo {

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {

Class<?> c1=null;

c1=Class.forName("reflect.construction.Person");//实例化Class对象

Method met=c1.getMethod("sayHello",String.class,int.class);//找到sayHello()方法

String returnValue=(String) met.invoke(c1.newInstance(),"李占祥",24);//调用方法

System.out.println(returnValue);

}