高薪课程一-----扩展(反射))

简单说反射就是获取任何对象所具有的任何属性，方法或者构造函数等。通过固定的一些方法，可以对其进行访问，修改。
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

　　 Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

Java有个Object class，是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class
object。

　　Class class十分特殊。它和一般classes一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types（boolean, byte, char, short, int, long, float, double）以及关键词void。当一个class被加载，或当加载器（class
loader）的defineClass()被JVM调用，JVM 便自动产生一个Class object。它的构造函数被私有化，不能创建对象。

java程序中各个java类属于同一类事物，描述该类事物的java的类名就是Class。

简单来说就是获取类的属性，比如类名字，类属于哪个包，有哪些成员变量等。

如何得到字节码文件：

类名.class System.class

对象.class new Date().getClass()

Class.forName(“类名”) Class.forName(“java.util.Date”);

9个预定义Class字节码实例对象:

8个基本数据类型也有对应的class对象
void也有 Class cls = void.

Demo:

String str = "fd";

Class cls = str.getClass();

System.out.println(cls.isPrimitive()); //字节码文件是否是基本数据类型

System.out.println(int.class
== Integer.class);//两者不同，一个是基本数据类型，一个是包装类

System.out.println(int.class
== Integer.TYPE);//
Integer.TYPE代表包装类所包装的基本数据类型的字节码

System.out.println(int[].class.isPrimitive()); //引用数据类型

总结：只要在源程序中出现的类型，都有各自对应的class实例对象。

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();

}

}

}