反射

1反射的基石Class类
1.Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中的各个Java类，它们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要注意与小写class关键字的区别哦。Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。学习反射，首先就要明白Class这个类。写如下代码进行对比理解：
/*Person p1 = new Person("zhangsan");
Person p2 = new Person("lisi");
*/
/*Class x1 = Vector类在内存里的字节码
Class x2 = Date类在内存里的字节码*/
Class x1 = Vector.class;
Class x2 = Date.class;

每个java类都是Class的一个实例对象，它们的内容不同，但是，它们的特征相同，譬如，都有方法，有字段，有父类，有包。
2. ******讲课时要一定画一张图：多个类的字节码装载入内存，在内存中加入一个个方块空间表示字节码，然后用一个个椭圆表示以这个字节码创建出来的实例对象，并用监视代码来说明字节码只被装载一次，而它构造的实例对象的构造方法被调用了多次。用如下代码更进一步说明Class的实例是什么？是一份字节码，一个类在虚拟机中通常只有一份字节码：
Date d1 = new Date();
Class clazz1 = d1.getClass();
Class clazz2 = Date.class;
Class clazz3 = null;
clazz3 = Class.forName("java.util.Date");

if(clazz1==clazz2)
{
System.out.println(clazz1.getName());
}
if(clazz1==clazz3)
{
System.out.println(clazz1.getName());
}
3.一个奇怪的问题：加载了字节码，并调用了其getMethods之类的方法，但是没有看到类的静态代码块被执行，只有在第一个实例对象被创建时，这个静态代码才会被执行。准确的说，静态代码块不是在类加载时被调用的，而是第一个实例对象被创建时才执行的。




反射的基石--Class类

对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
人--Person
Java类--Class

Class类代表Java类，它的各个实例对象又分别对应什么呢？
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？

如何得到各个字节码对应的实例对象（ Class类型）
类名.class，例如，System.class
对象.getClass()，例如，new Date().getClass()
Class.forName("类名")，例如，Class.forName("java.util.Date");

九个预定义Class实例对象：
参看Class.isPrimitive方法的帮助
Int.class == Integer.TYPE

数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…

Demo：

view plain copy to clipboard print ?

1. package cn.itcast;  
2.   
3. import java.util.Date;  
4.   
5. /** 
6. * 测试三个字节码是否为同一个字节码 
7. * @author partner4java 
8. * 
9. */  
10. public class ReflectTest1 {  
11.     public static void main(String[] args) throws ClassNotFoundException {  
12.         Date date = new Date();  
13.         Class date1 = date.getClass();  
14.         Class date2 = Class.forName("java.util.Date");  
15.         System.out.println("date1 == date2 ?" + (date1 == date2));  
16.           
17.         Class date3 = Date.class;  
18.         System.out.println("date1 == date3 ?" + (date1 == date3));  
19.           
20. //      后台打印：  
21. //      date1 == date2 ?true  
22. //      date1 == date3 ?true  
23.   
24.     }  
25.   
26. }  

Class JDK文档：

public final class Class<T>extends Objectimplements Serializable, GenericDeclaration, Type, AnnotatedElementClass 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

以下示例使用 Class 对象来显示对象的类名：


void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
还可以使用一个类字面值（JLS Section 15.8.2）来获得命名类型（或 void）的 Class 对象。例如：


System.out.println("The name of class Foo is: "+Foo.class.getName());



方法摘要
<U> Class<? extends U>
asSubclass(Class<U> clazz)
强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
T cast(Object obj)
将一个对象强制转换成此 Class 对象所表示的类或接口。
boolean desiredAssertionStatus()
如果要在调用此方法时，将要初始化该类，则返回将分配给该类的断言状态。
static Class<?> forName(String className)
返回与带有给定字符串名的类或接口相关联的 Class 对象。
static Class<?> forName(String name, boolean initialize, ClassLoader loader)
使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 Class 对象。
<A extends Annotation>
A
getAnnotation(Class<A> annotationClass)
如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
Annotation[] getAnnotations()
返回此元素上存在的所有注释。
String getCanonicalName()
返回《Java Language Specification》中所定义的基础类的规范化名称。
Class[] getClasses()
返回一个包含某些 Class 对象的数组，这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口，包括从超类和公共类继承的以及通过该类声明的公共类和接口成员。
ClassLoader getClassLoader()
返回该类的类加载器。
Class<?> getComponentType()
返回表示数组组件类型的 Class。
Constructor<T> getConstructor(Class... parameterTypes)
返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
Constructor[] getConstructors()
返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class[] getDeclaredClasses()
返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口，包括该类所声明的公共、保护、默认（包）访问及私有类和接口，但不包括继承的类和接口。
Constructor<T> getDeclaredConstructor(Class... parameterTypes)
返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。
Constructor[] getDeclaredConstructors()
返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。
Field getDeclaredField(String name)
返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
Field[] getDeclaredFields()
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段，包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。
Method getDeclaredMethod(String name, Class... parameterTypes)
返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] getDeclaredMethods()
返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
Class<?> getDeclaringClass()
如果此 Class 对象所表示的类或接口是另一个类的成员，则返回的 Class 对象表示该对象的声明类。
Class<?> getEnclosingClass()
返回基础类的立即封闭类。
Constructor<?> getEnclosingConstructor()
如果该 Class 对象表示构造方法中的一个本地或匿名类，则返回 Constructor 对象，它表示基础类的立即封闭构造方法。
Method getEnclosingMethod()
如果此 Class 对象表示某一方法中的一个本地或匿名类，则返回 Method 对象，它表示基础类的立即封闭方法。
T[] getEnumConstants()
如果此 Class 对象不表示枚举类型，则返回枚举类的元素或 null。
Field getField(String name)
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
Field[] getFields()
返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
Type[] getGenericInterfaces()
返回表示某些接口的 Type，这些接口由此对象所表示的类或接口直接实现。
Type getGenericSuperclass()
返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。
Class[] getInterfaces()
确定此对象所表示的类或接口实现的接口。
Method getMethod(String name, Class... parameterTypes)
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[] getMethods()
返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。
int getModifiers()
返回此类或接口以整数编码的 Java 语言修饰符。
String getName()
以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
Package getPackage()
获取此类的包。
ProtectionDomain getProtectionDomain()
返回该类的 ProtectionDomain。
URL getResource(String name)
查找带有给定名称的资源。
InputStream getResourceAsStream(String name)
查找具有给定名称的资源。
Object[] getSigners()
获取此类的标记。
String getSimpleName()
返回源代码中给出的基础类的简称。
Class<? super T> getSuperclass()
返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
TypeVariable<Class<T>>[] getTypeParameters()
按声明顺序返回 TypeVariable 对象的一个数组，这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。
boolean isAnnotation()
如果此 Class 对象表示一个注释类型则返回 true。
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。
boolean isAnonymousClass()
当且仅当基础类是匿名类时返回 true。
boolean isArray()
判定此 Class 对象是否表示一个数组类。
boolean isAssignableFrom(Class<?> cls)
判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。
boolean isEnum()
当且仅当该类声明为源代码中的枚举时返回 true。
boolean isInstance(Object obj)
判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
boolean isInterface()
判定指定的 Class 对象是否表示一个接口。
boolean isLocalClass()
当且仅当基础类是本地类时返回 true。
boolean isMemberClass()
当且仅当基础类是成员类时返回 true。
boolean isPrimitive()
判定指定的 Class 对象是否表示一个基本类型。
boolean isSynthetic()
如果此类是复合类，则返回 true，否则 false。
T newInstance()
创建此 Class 对象所表示的类的一个新实例。
String toString()
将对象转换为字符串。



2反射

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。



3Constructor类
Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法：
例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：
例子： Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时要用到类型

创建实例对象：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。





Constructor<T> JDK文档：
public final class Constructor<T>extends AccessibleObjectimplements GenericDeclaration, MemberConstructor 提供关于类的单个构造方法的信息以及对它的访问权限。

Constructor 允许在将实参与带有基础构造方法的形参的 newInstance() 匹配时进行扩展转换，但是如果发生收缩转换，则抛出 IllegalArgumentException。

方法摘要
boolean equals(Object obj)
将此 Constructor 对象与指定的对象进行比较。
<T extends Annotation>
T
getAnnotation(Class<T> annotationClass)
如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class<T> getDeclaringClass()
返回 Class 对象，该对象表示声明由此 Constructor 对象表示的构造方法的类。
Class<?>[] getExceptionTypes()
返回一组表示声明要抛出的异常类型的 Class 对象，这些异常是由此 Constructor 对象表示的基础构造方法抛出的。
Type[] getGenericExceptionTypes()
返回一组 Type 对象，这些对象表示声明要由此 Constructor 对象抛出的异常。
Type[] getGenericParameterTypes()
按照声明顺序返回一组 Type 对象，这些对象表示此 Constructor 对象所表示的方法的形参类型。
int getModifiers()
以整数形式返回此 Constructor 对象所表示构造方法的 Java 语言修饰符。
String getName()
以字符串形式返回此构造方法的名称。
Annotation[][] getParameterAnnotations()
按照声明顺序返回一组数组，这些数组表示通过此 Method 对象表示的方法的形参上的注释。
Class<?>[] getParameterTypes()
按照声明顺序返回一组 Class 对象，这些对象表示此 Constructor 对象所表示构造方法的形参类型。
TypeVariable<Constructor<T>>[] getTypeParameters()
按照声明顺序返回一组 TypeVariable 对象，这些对象表示通过此 GenericDeclaration 对象所表示的一般声明来声明的类型变量。
int hashCode()
返回此 Constructor 的哈希码。
boolean isSynthetic()
如果此构造方法是一个复合构造方法，则返回 true；否则返回 false。
boolean isVarArgs()
如果声明此构造方法可以带可变数量的参数，则返回 true；否则返回 false。
T newInstance(Object... initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
String toGenericString()
返回描述此 Constructor 的字符串，其中包括类型参数。
String toString()
返回描述此 Constructor 的字符串。





4Field类

view plain copy to clipboard print ?

1. Field类代表某个类中的一个成员变量  
2.   
3. ReflectPoint point = new ReflectPoint(1,7);  
4. Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");  
5. System.out.println(y.get(point));  
6. //Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");  
7. Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");  
8. x.setAccessible(true);  
9. System.out.println(x.get(point));  
10.   
11. Demo:  
12. package cn.itcast;  
13.   
14. import java.io.Serializable;  
15.   
16. public class User implements Serializable {  
17.     private String username;  
18.     private String password;  
19.     private static String ENCRYPT_TYPE = "MD5";  
20.     public User(String username, String password) {  
21.         super();  
22.         this.username = username;  
23.         this.password = password;  
24.     }  
25.     public String getUsername() {  
26.         return username;  
27.     }  
28.     public void setUsername(String username) {  
29.         this.username = username;  
30.     }  
31.     public String getPassword() {  
32.         return password;  
33.     }  
34.     public void setPassword(String password) {  
35.         this.password = password;  
36.     }  
37.     public static String getENCRYPT_TYPE() {  
38.         return ENCRYPT_TYPE;  
39.     }  
40.       
41.       
42. }  
43.   
44. package cn.itcast;  
45.   
46. /** 
47. * 改变了本不允许改变的字段 
48. * 要看清楚，为什么ENCRYPT_TYPE字段，可以从String.class里面取，而password必须从User里面取 
49. * @author partner4java 
50. *  
51. */  
52. public class Field {  
53.   
54.     public static void main(String[] args) throws SecurityException,  
55.             NoSuchFieldException, IllegalArgumentException,  
56.             IllegalAccessException {  
57.         get1();  
58.     }  
59.   
60.     private static void get1() throws NoSuchFieldException,  
61.             IllegalAccessException {  
62.         User user = new User("partner4java", "123456");  
63.         User user2 = new User("partner4java2", "1234562");  
64.         java.lang.reflect.Field encryptType = user.getClass().getDeclaredField(  
65.                 "ENCRYPT_TYPE");  
66.         encryptType.setAccessible(true);  
67.         System.out.println(encryptType.get(String.class));  
68.   
69.         encryptType.set(String.class, "MD6");  
70.         System.out.println(user.getENCRYPT_TYPE());  
71.         System.out.println(user2.getENCRYPT_TYPE());  
72.   
73.         System.out.println();  
74.   
75.         java.lang.reflect.Field passworld = user.getClass().getDeclaredField(  
76.                 "password");  
77.         passworld.setAccessible(true);  
78.         System.out.println(passworld.get(user));  
79.   
80.         passworld.set(user, "654321");  
81.         System.out.println(user.getPassword());  
82.         System.out.println(user2.getPassword());  
83.   
84.         // 后台打印：  
85.         // MD5  
86.         // MD6  
87.         // MD6  
88.         //  
89.         // 123456  
90.         // 654321  
91.         // 1234562  
92.   
93.     }  
94.   
95. }  

Field JDK说明：
public final class Fieldextends AccessibleObjectimplements MemberField 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

Array 允许在执行 get 或 set 访问操作期间进行扩展转换，但如果将发生收缩转换，则抛出一个 IllegalArgumentException。

方法摘要
boolean equals(Object obj)
将此 Field 与指定对象比较。
Object get(Object obj)
返回指定对象上此 Field 表示的字段的值。
<T extends Annotation>
T
getAnnotation(Class<T> annotationClass)
如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
boolean getBoolean(Object obj)
获得一个静态或实例 boolean 字段的值。
byte getByte(Object obj)
获得一个静态或实例 byte 字段的值。
char getChar(Object obj)
获得 char 类型或另一个通过扩展转换可以转换为 char 类型的基本类型的静态或实例字段的值。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class<?> getDeclaringClass()
返回表示类或接口的 Class 对象，该类或接口声明由此 Field 对象表示的字段。
double getDouble(Object obj)
获得 double 类型或另一个通过扩展转换可以转换为 double 类型的基本类型的静态或实例字段的值。
float getFloat(Object obj)
获得 float 类型或另一个通过扩展转换可以转换为 float 类型的基本类型的静态或实例字段的值。
Type getGenericType()
返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。
int getInt(Object obj)
获得 int 类型或另一个通过扩展转换可以转换为 int 类型的基本类型的静态或实例字段的值。
long getLong(Object obj)
获得 long 类型或另一个通过扩展转换可以转换为 long 类型的基本类型的静态或实例字段的值。
int getModifiers()
以整数形式返回由此 Field 对象表示的字段的 Java 语言修饰符。
String getName()
返回此 Field 对象表示的字段的名称。
short getShort(Object obj)
获得 short 类型或另一个通过扩展转换可以转换为 short 类型的基本类型的静态或实例字段的值。
Class<?> getType()
返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
int hashCode()
返回该 Field 的哈希码。
boolean isEnumConstant()
如果此字段表示枚举类型的元素，则返回 true；否则返回 false。
boolean isSynthetic()
如果此字段是复合字段，则返回 true；否则返回 false。
void set(Object obj, Object value)
将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
void setBoolean(Object obj, boolean z)
将字段的值设置为指定对象上的一个 boolean 值。
void setByte(Object obj, byte b)
将字段的值设置为指定对象上的一个 byte 值。
void setChar(Object obj, char c)
将字段的值设置为指定对象上的一个 char 值。
void setDouble(Object obj, double d)
将字段的值设置为指定对象上的一个 double 值。
void setFloat(Object obj, float f)
将字段的值设置为指定对象上的一个 float 值。
void setInt(Object obj, int i)
将字段的值设置为指定对象上的一个 int 值。
void setLong(Object obj, long l)
将字段的值设置为指定对象上的一个 long 值。
void setShort(Object obj, short s)
将字段的值设置为指定对象上的一个 short 值。
String toGenericString()
返回一个描述此 Field（包括其一般类型）的字符串。
String toString()
返回一个描述此 Field 的字符串。




5Method类
Method类代表某个类中的一个成员方法

得到类中的某一个方法：
例子： Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式： System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

Demo:

view plain copy to clipboard print ?

1. package cn.itcast;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.InvocationTargetException;  
5. import java.lang.reflect.Method;  
6.   
7. /** 
8. * 注意我只有一个无参的构造器 
9. * 然后，每个test都是每一步递增的解决问题 
10. * @author partner4java 
11. * 
12. */  
13. public class RegUser {  
14.     static{  
15.         System.out.println("Class static area");  
16.     }  
17.       
18.     public RegUser() {  
19.         System.out.println("Constructor");  
20.     }  
21.       
22.     public RegUser(String message) {  
23.         System.out.println("Constructor " + message);  
24.     }  
25.       
26.     public void regUser1() {  
27.         System.out.println("class method regUser1");  
28.     }  
29.       
30.     public static void regUser2(){  
31.         System.out.println("static method regUser2");  
32.     }  
33.       
34.     public static void main(String[] args) throws Exception {  
35. //      test1();  
36. //      test2();  
37. //      test3();  
38. //      test4();  
39. //      test5();  
40. //      test6();  
41. //      test7();  
42.     }  
43.   
44.     /** 
45.      * 只执行了static静态块 
46.      */  
47.     private static void test1() {  
48.         Class regUser = RegUser.class;  
49. //      后台打印：  
50. //      Class static area  
51.   
52.     }  
53.   
54.     /** 
55.      * 只执行了static静态块 
56.      */  
57.     private static void test2() throws ClassNotFoundException {  
58.         Class regUser = Class.forName("cn.itcast.RegUser");  
59. //      后台打印：  
60. //      Class static area  
61.   
62.     }  
63.       
64.     /** 
65.      * 报错：不是一个已经初始化的class 
66.      */  
67.     private static void test3() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {  
68.         Class regUser = RegUser.class;  
69.         Method regUser1 = regUser.getMethod("regUser1", null);  
70.         regUser1.invoke(regUser, null);  
71. //      后台打印：  
72. //      Exception in thread "main" java.lang.IllegalArgumentException: object is not an instance of declaring class  
73. //      Class static area  
74.     }  
75.   
76.     /** 
77.      * 这个测试是去掉了有参的构造器 
78.      */  
79.     private static void test4() throws InstantiationException, IllegalAccessException {  
80.         Class regUser = RegUser.class;  
81.         regUser.newInstance();  
82. //      后台打印：  
83. //      Class static area  
84. //      Exception in thread "main" java.lang.InstantiationException: cn.itcast.RegUser  
85.     }  
86.       
87.     /** 
88.      * 通过获取构造器，调用了构造器 
89.      */  
90.     private static void test5() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {  
91.         Class regUser = RegUser.class;  
92.         Constructor constructor = regUser.getConstructor(String.class);  
93.         constructor.newInstance("Hello World!");  
94. //      后台打印：  
95. //      Class static area  
96. //      Constructor Hello World!  
97.   
98.     }  
99.       
100.     /** 
101.      * 执行了非静态的regUser1方法 
102.      */  
103.     private static void test6() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {  
104.         Class regUser = RegUser.class;  
105.         Constructor constructor = regUser.getConstructor(String.class);  
106.           
107.         RegUser regUserC = (RegUser) constructor.newInstance("Hello World!");  
108.   
109.         Method regUser1 = regUserC.getClass().getMethod("regUser1", null);  
110.         regUser1.invoke(regUserC, null);  
111. //      后台打印：  
112. //      Class static area  
113. //      Constructor Hello World!  
114. //      class method regUser1  
115.     }  
116.       
117.   
118.     /** 
119.      * 静态方法的调用，并不需要new出来一个class(或者说，并没有调用构造器，就本身存在了静态方法) 
120.      */  
121.     private static void test7() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {  
122.         Class regUser = RegUser.class;  
123.         Method regUser2 = regUser.getMethod("regUser2", null);  
124.         regUser2.invoke(null, null);  
125. //      后台打印：  
126. //      Class static area  
127. //      static method regUser2  
128.   
129.     }  
130. }  

用反射方式执行某个类中的main方法：
目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？

问题：
启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了



Method JDK文档：
public final class Methodextends AccessibleObjectimplements GenericDeclaration, MemberMethod 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。

Method 允许在匹配要调用的实参与基础方法的形参时进行扩展转换；但如果要进行收缩转换，则会抛出 IllegalArgumentException。

方法摘要
boolean equals(Object obj)
将此 Method 与指定对象进行比较。
<T extends Annotation>
T
getAnnotation(Class<T> annotationClass)
如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
Annotation[] getDeclaredAnnotations()
返回直接存在于此元素上的所有注释。
Class<?> getDeclaringClass()
返回表示声明由此 Method 对象表示的方法的类或接口的 Class 对象。
Object getDefaultValue()
返回由此 Method 实例表示的注释成员的默认值。
Class<?>[] getExceptionTypes()
返回 Class 对象的数组，这些对象描述了声明将此 Method 对象表示的基础方法抛出的异常类型。
Type[] getGenericExceptionTypes()
返回 Type 对象数组，这些对象描述了声明由此 Method 对象抛出的异常。
Type[] getGenericParameterTypes()
按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的。
Type getGenericReturnType()
返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象。
int getModifiers()
以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符。
String getName()
以 String 形式返回此 Method 对象表示的方法名称。
Annotation[][] getParameterAnnotations()
返回表示按照声明顺序对此 Method 对象所表示方法的形参进行注释的那个数组的数组。
Class<?>[] getParameterTypes()
按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。
Class<?> getReturnType()
返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型。
TypeVariable<Method>[] getTypeParameters()
返回 TypeVariable 对象的数组，这些对象描述了由 GenericDeclaration 对象表示的一般声明按声明顺序来声明的类型变量。
int hashCode()
返回此 Method 的哈希码。
Object invoke(Object obj, Object... args)
对带有指定参数的指定对象调用由此 Method 对象表示的基础方法。
boolean isBridge()
如果此方法是 bridge 方法，则返回 true；否则，返回 false。
boolean isSynthetic()
如果此方法为复合方法，则返回 true；否则，返回 false。
boolean isVarArgs()
如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。
String toGenericString()
返回描述此 Method 的字符串，包括类型参数。
String toString()
返回描述此 Method 的字符串。



6数组的反射
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。

Array工具类用于完成对数组的反射操作。


--------------
附注：
Object[] 与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成new String[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x = “abc”。
main.invoke(null, (Object)(new Object[]{“aaa”,“xxx”}));不能调用public static void main(String [] args)

1.
看Class类帮助文档开始部分的介绍。
String[] a1 = new String[8];
String[] a2 = new String[9];
String[][] a3 = new String[6][4];
().getName());
System.out.println(a3.getClass().getName());
System.out.println(a1.getClass() == a2.getClass());
System.out.println(a1.getClass() == a3.getClass());
2.
看getSuperClass方法的帮助
System.out.println(a1.getClass().getSuperclass().getName());
3.
int[] a = new int[3];
Object obj = a;
//Object[] obj1 = a //有错！
Object[] obj3 = a1
Object obj4 = a3;
if(obj4 instanceof String[][]){
System.out.println(obj1.getClass().isArray());
}
**在这里分析研究Arrays.asList()方法处理int[]和String[]时的差异，以及Arrays.deepToString()方法不能处理int[]，但能处理String[]的原因。
4.
private static void printObject(Object obj) {
if(obj.getClass().isArray()){
int len = Array.getLength(obj);
for(int i=0;i<len;i++) {
System.out.println(Array.get(obj, i));
}
} else {
System.out.println(obj);
}
}
5.
需要取出每个元素对象，然后再对各个对象进行判断，因为其中每个具体元素的类型都可以不同，例如Object[] x = new Object[]{“abc”,Integer.Max}。
--------------



7反射的作用实现框架功能
框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

综合案例
先直接用new 语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
引入了elipse对资源文件的管理方式的讲解。


附言：
什么是框架，例如，我们要写程序扫描.java文件中的注解，要解决哪些问题：读取每一样，在每一个中查找@，找到的@再去查询一个列表，如果@后的内容出现在了列表中，就说明这是一个我能处理和想处理的注解，否则，就说明它不是一个注解或者说至少不是一个我感兴趣和能处理的注解。接着就编写处理这个注解的相关代码。现在sun提供了一个apt框架，它会完成所有前期工作，只需要我们提供能够处理的注解列表，以及处理这些注解的代码。Apt框找到我们感兴趣的注解后通知或调用我们的处理代码去处理。
你做的门调用锁，锁是工具，你做的门被房子调用，房子是框架，房子和锁都是别人提供的。

程序中不处理异常，而是main方法声明抛出异常，便于大家可以集中看主要的关键代码。

Class类也提供getResourceAsStream方法的比喻：如果你每次都找我给你商店买可乐，那我还不如直接向你买可乐，即直接提供一个买可乐的方法给你。


public static void main(String[] args) throws Exception{
//应该先直接用ArrayList和HashSet，然后才引入从配置文件读，这样便于学员学习。
Properties props = new Properties();
//先演示相对路径的问题
//InputStream ips = new FileInputStream("config.properties");
/*一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。*/
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config.properties");
//Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件
//InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");
InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");
props.load(ips);
Ips.close();

String className = props.getProperty("className");
Class clazz = Class.forName(className);

Collection collection = (Collection)clazz.newInstance();
//Collection collection = new ArrayList();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collection.add(pt1);
collection.add(pt2);
collection.add(pt3);
collection.add(pt1);
System.out.println(collection.size());
}