JAVA反射

java的反射技术功能十分强大，下面是一些例子。

1.retrieving class objects
获取一个class对象(metadata)

a,从对象的实例获取。
class c = mystery.getclass();//(return class)
b,从子类的实例获取
textfield t = new textfield();
class c = t.getclass();
class s = c.getsuperclass();
c,知道类名，则可以把.class加入到名字之后来获取。
class c = java.awt.button.class;
d,如果类名在编译时是未知的，则可以使用class.forname()方法来获取.
class c = class.forname(classstring);

2.getting the class name
获取类名称
c.getname();

例如：
import java.lang.reflect.*;
import java.awt.*;

class samplename {

public static void main(string[] args) {
button b = new button();
printname(b);
}

static void printname(object o) {
class c = o.getclass();
string s = c.getname();
system.out.println(s);
}
}


3.discovering class modifiers
检索修改符
a.通过getmodifiers（）方法获取一个整型标识值。
b.通过java.reflect.modifier对象的ispublic, isabstract, 和 isfinal方法判断此值.

例如：
import java.lang.reflect.*;
import java.awt.*;

class samplemodifier {

public static void main(string[] args) {
string s = new string();
printmodifiers(s);
}

public static void printmodifiers(object o) {
class c = o.getclass();
int m = c.getmodifiers();
if (modifier.ispublic(m))
system.out.println("public");
if (modifier.isabstract(m))
system.out.println("abstract");
if (modifier.isfinal(m))
system.out.println("final");
}
}


4.finding superclasses
检索父类
例如：
import java.lang.reflect.*;
import java.awt.*;

class samplesuper {

public static void main(string[] args) {
button b = new button();
printsuperclasses(b);
}

static void printsuperclasses(object o) {
class subclass = o.getclass();
class superclass = subclass.getsuperclass();
while (superclass != null) {
string classname = superclass.getname();
system.out.println(classname);
subclass = superclass;
superclass = subclass.getsuperclass();
}
}
}


5.identifying the interfaces implemented by a class
检索指定类实现的接口
例如：
import java.lang.reflect.*;
import java.io.*;

class sampleinterface {

public static void main(string[] args) {
try {
randomaccessfile r = new randomaccessfile("myfile", "r");
printinterfacenames(r);
} catch (ioexception e) {
system.out.println(e);
}
}

static void printinterfacenames(object o) {
class c = o.getclass();
class[] theinterfaces = c.getinterfaces();
for (int i = 0; i < theinterfaces.length; i++) {
string interfacename = theinterfaces[i].getname();
system.out.println(interfacename);
}
}
}
6.examining interfaces
判定一个类是不是接口

import java.lang.reflect.*;
import java.util.*;

class samplecheckinterface {

public static void main(string[] args) {
class thread = thread.class;
class runnable = runnable.class;
verifyinterface(thread);
verifyinterface(runnable);
}

static void verifyinterface(class c) {
string name = c.getname();
if (c.isinterface()) {
system.out.println(name + " is an interface.");
} else {
system.out.println(name + " is a class.");
}
}
}



如：c.isinterface()

7.identifying class fields
找出指定类所有的域成员
每个数据成员可以用java.reflect.field来封闭其名称，类型，修改符的集合。
也可以通过相应的方法获取或设置到该成员的值。

如：
import java.lang.reflect.*;
import java.awt.*;

class samplefield {

public static void main(string[] args) {
gridbagconstraints g = new gridbagconstraints();
printfieldnames(g);
}

static void printfieldnames(object o) {
class c = o.getclass();
field[] publicfields = c.getfields();
for (int i = 0; i < publicfields.length; i++) {
string fieldname = publicfields[i].getname();
class typeclass = publicfields[i].gettype();
string fieldtype = typeclass.getname();
system.out.println("name: " + fieldname +
", type: " + fieldtype);
}
}
}



8.discovering class constructors
检索指定类的构造函数

当创建一个类的实例时，是通过检造方法来作的，这种方法可以被重载。
每一个构造方法可以用类constructor来描述，，包括名称，修饰符，参数类型(class[])，和异常列表。
可以通过一个class的getconstructors方法获取到该类的constructor数组。
例程：
import java.lang.reflect.*;
import java.awt.*;

class sampleconstructor {

public static void main(string[] args) {
rectangle r = new rectangle();
showconstructors(r);
}

static void showconstructors(object o) {
class c = o.getclass();
constructor[] theconstructors = c.getconstructors();
for (int i = 0; i < theconstructors.length; i++) {
system.out.print("( ");
class[] parametertypes =
theconstructors[i].getparametertypes();
for (int k = 0; k < parametertypes.length; k ++) {
string parameterstring = parametertypes[k].getname();
system.out.print(parameterstring + " ");
}
system.out.println(")");
}
}
}





9.obtaining method information
检索方法
可以找到隶属于一个类的所有方法，通过getmethods包含method数组，进而得到该方法的返回类型，修饰符，方法名称，参数列表
步骤：
a.指定类的class object
b.getmethods()获取method[]对象
c,遍历该数组对象

例程：

import java.lang.reflect.*;
import java.awt.*;

class samplemethod {

public static void main(string[] args) {
polygon p = new polygon();
showmethods(p);
}

static void showmethods(object o) {
class c = o.getclass();
method[] themethods = c.getmethods();
for (int i = 0; i < themethods.length; i++) {
string methodstring = themethods[i].getname();
system.out.println("name: " + methodstring);
string returnstring =
themethods[i].getreturntype().getname();
system.out.println(" return type: " + returnstring);
class[] parametertypes = themethods[i].getparametertypes();
system.out.print(" parameter types:");
for (int k = 0; k < parametertypes.length; k ++) {
string parameterstring = parametertypes[k].getname();
system.out.print(" " + parameterstring);
}
system.out.println();
}
}
}