Java高级之反射

来源：互联网发布：windows 8 apart from 编辑：程序博客网时间：2024/05/16 07:25

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 plaincopy to clipboardprint?
package cn.itcast;  
  
import java.util.Date;  
  
/** 
* 测试三个字节码是否为同一个字节码 
* @author partner4java 
* 
*/  
public class ReflectTest1 {  
    public static void main(String[] args) throws ClassNotFoundException {  
        Date date = new Date();  
        Class date1 = date.getClass();  
        Class date2 = Class.forName("java.util.Date");  
        System.out.println("date1 == date2 ?" + (date1 == date2));  
          
        Class date3 = Date.class;  
        System.out.println("date1 == date3 ?" + (date1 == date3));  
          
//      后台打印：  
//      date1 == date2 ?true  
//      date1 == date3 ?true  
  
    }  
  
}  

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 plaincopy to clipboardprint?
Field类代表某个类中的一个成员变量  
  
ReflectPoint point = new ReflectPoint(1,7);  
Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");  
System.out.println(y.get(point));  
//Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");  
Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");  
x.setAccessible(true);  
System.out.println(x.get(point));  
  
Demo:  
package cn.itcast;  
  
import java.io.Serializable;  
  
public class User implements Serializable {  
    private String username;  
    private String password;  
    private static String ENCRYPT_TYPE = "MD5";  
    public User(String username, String password) {  
        super();  
        this.username = username;  
        this.password = password;  
    }  
    public String getUsername() {  
        return username;  
    }  
    public void setUsername(String username) {  
        this.username = username;  
    }  
    public String getPassword() {  
        return password;  
    }  
    public void setPassword(String password) {  
        this.password = password;  
    }  
    public static String getENCRYPT_TYPE() {  
        return ENCRYPT_TYPE;  
    }  
      
      
}  
  
package cn.itcast;  
  
/** 
* 改变了本不允许改变的字段 
* 要看清楚，为什么ENCRYPT_TYPE字段，可以从String.class里面取，而password必须从User里面取 
* @author partner4java 
*  
*/  
public class Field {  
  
    public static void main(String[] args) throws SecurityException,  
            NoSuchFieldException, IllegalArgumentException,  
            IllegalAccessException {  
        get1();  
    }  
  
    private static void get1() throws NoSuchFieldException,  
            IllegalAccessException {  
        User user = new User("partner4java", "123456");  
        User user2 = new User("partner4java2", "1234562");  
        java.lang.reflect.Field encryptType = user.getClass().getDeclaredField(  
                "ENCRYPT_TYPE");  
        encryptType.setAccessible(true);  
        System.out.println(encryptType.get(String.class));  
  
        encryptType.set(String.class, "MD6");  
        System.out.println(user.getENCRYPT_TYPE());  
        System.out.println(user2.getENCRYPT_TYPE());  
  
        System.out.println();  
  
        java.lang.reflect.Field passworld = user.getClass().getDeclaredField(  
                "password");  
        passworld.setAccessible(true);  
        System.out.println(passworld.get(user));  
  
        passworld.set(user, "654321");  
        System.out.println(user.getPassword());  
        System.out.println(user2.getPassword());  
  
        // 后台打印：  
        // MD5  
        // MD6  
        // MD6  
        //  
        // 123456  
        // 654321  
        // 1234562  
  
    }  
  
}  

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 plaincopy to clipboardprint?
package cn.itcast;  
  
import java.lang.reflect.Constructor;  
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
  
/** 
* 注意我只有一个无参的构造器 
* 然后，每个test都是每一步递增的解决问题 
* @author partner4java 
* 
*/  
public class RegUser {  
    static{  
        System.out.println("Class static area");  
    }  
      
    public RegUser() {  
        System.out.println("Constructor");  
    }  
      
    public RegUser(String message) {  
        System.out.println("Constructor " + message);  
    }  
      
    public void regUser1() {  
        System.out.println("class method regUser1");  
    }  
      
    public static void regUser2(){  
        System.out.println("static method regUser2");  
    }  
      
    public static void main(String[] args) throws Exception {  
//      test1();  
//      test2();  
//      test3();  
//      test4();  
//      test5();  
//      test6();  
//      test7();  
    }  
  
    /** 
     * 只执行了static静态块 
     */  
    private static void test1() {  
        Class regUser = RegUser.class;  
//      后台打印：  
//      Class static area  
  
    }  
  
    /** 
     * 只执行了static静态块 
     */  
    private static void test2() throws ClassNotFoundException {  
        Class regUser = Class.forName("cn.itcast.RegUser");  
//      后台打印：  
//      Class static area  
  
    }  
      
    /** 
     * 报错：不是一个已经初始化的class 
     */  
    private static void test3() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {  
        Class regUser = RegUser.class;  
        Method regUser1 = regUser.getMethod("regUser1", null);  
        regUser1.invoke(regUser, null);  
//      后台打印：  
//      Exception in thread "main" java.lang.IllegalArgumentException: object is not an instance of declaring class  
//      Class static area  
    }  
  
    /** 
     * 这个测试是去掉了有参的构造器 
     */  
    private static void test4() throws InstantiationException, IllegalAccessException {  
        Class regUser = RegUser.class;  
        regUser.newInstance();  
//      后台打印：  
//      Class static area  
//      Exception in thread "main" java.lang.InstantiationException: cn.itcast.RegUser  
    }  
      
    /** 
     * 通过获取构造器，调用了构造器 
     */  
    private static void test5() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {  
        Class regUser = RegUser.class;  
        Constructor constructor = regUser.getConstructor(String.class);  
        constructor.newInstance("Hello World!");  
//      后台打印：  
//      Class static area  
//      Constructor Hello World!  
  
    }  
      
    /** 
     * 执行了非静态的regUser1方法 
     */  
    private static void test6() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {  
        Class regUser = RegUser.class;  
        Constructor constructor = regUser.getConstructor(String.class);  
          
        RegUser regUserC = (RegUser) constructor.newInstance("Hello World!");  
  
        Method regUser1 = regUserC.getClass().getMethod("regUser1", null);  
        regUser1.invoke(regUserC, null);  
//      后台打印：  
//      Class static area  
//      Constructor Hello World!  
//      class method regUser1  
    }  
      
  
    /** 
     * 静态方法的调用，并不需要new出来一个class(或者说，并没有调用构造器，就本身存在了静态方法) 
     */  
    private static void test7() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {  
        Class regUser = RegUser.class;  
        Method regUser2 = regUser.getMethod("regUser2", null);  
        regUser2.invoke(null, null);  
//      后台打印：  
//      Class static area  
//      static method regUser2  
  
    }  
}  

用反射方式执行某个类中的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());
}

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

下面开始正文。

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

package Reflect;

/**

* 通过一个对象获得完整的包名和类名

* */

class Demo{

//other codes...

}

class hello{

public static void main(String[] args) {

Demo demo=new Demo();

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

}

【运行结果】：Reflect.Demo

添加一句：所有类的对象其实都是Class的实例。

【案例2】实例化Class类对象

package Reflect;

class Demo{

//other codes...

}

class hello{

public static void main(String[] args) {

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实例化其他类的对象

通过无参构造实例化对象

package Reflect;

class Person{

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+"]";

}

private String name;

private int age;

}

class hello{

public static void main(String[] args) {

Class<?> demo=null;

try{

demo=Class.forName("Reflect.Person");

}catch (Exception e) {

e.printStackTrace();

}

Person per=null;

try {

per=(Person)demo.newInstance();

}catch (InstantiationException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}catch (IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

per.setName("Rollen");

per.setAge(20);

System.out.println(per);

}

【运行结果】：

[Rollen 20]

但是注意一下，当我们把Person中的默认的无参构造函数取消的时候，比如自己定义只定义一个有参数的构造函数之后，会出现错误：

比如我定义了一个构造函数：

public Person(String name,int age) {

this.age=age;

this.name=name;

}

然后继续运行上面的程序，会出现：

java.lang.InstantiationException: Reflect.Person

at java.lang.Class.newInstance0(Class.java:340)

at java.lang.Class.newInstance(Class.java:308)

at Reflect.hello.main(hello.java:39)

Exception in thread "main" java.lang.NullPointerException

at Reflect.hello.main(hello.java:47)

所以大家以后再编写使用Class实例化其他类的对象的时候，一定要自己定义无参的构造函数

【案例】通过Class调用其他类中的构造函数（也可以通过这种方式通过Class创建其他类的对象）

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;

}

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

}

【运行结果】：

[null 0]

[Rollen 0]

[null 20]

[Rollen 20]

【案例】

返回一个类实现的接口：

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 Personimplements China{

public Person() {

}

public Person(String sex){

this.sex=sex;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

@Override

public void sayChina(){

System.out.println("hello ,china");

}

@Override

public void sayHello(String name, int age){

System.out.println(name+" "+age);

}

private String sex;

}

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的代码）

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

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

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

这个例子需要在程序开头添加import java.lang.reflect.*;

然后将主类编写为：

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

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

但是细心的读者会发现，上面的构造函数没有public 或者private这一类的修饰符

下面这个例子我们就来获取修饰符

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 final native void wait (long arg0) throws java.lang.InterruptedException

public final void wait () throws java.lang.InterruptedException

public final void wait (long arg0,int arg1) throws java.lang.InterruptedException

public boolean equals (java.lang.Object arg0)

public java.lang.String toString ()

public native int hashCode ()

public final native java.lang.Class getClass ()

public final native void notify ()

public final native void notifyAll ()

【案例】接下来让我们取得其他类的全部属性吧，最后我讲这些整理在一起，也就是通过class取得一个类的全部框架

class hello {

public static void main(String[] args) {

Class<?> demo =null;

try {

demo = Class.forName("Reflect.Person");

}catch (Exception e) {

e.printStackTrace();

}

System.out.println("===============本类属性========================");

// 取得本类的全部属性

Field[] field = demo.getDeclaredFields();

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

// 权限修饰符

int mo = field[i].getModifiers();

String priv = Modifier.toString(mo);

// 属性类型

Class<?> type = field[i].getType();

System.out.println(priv +" " + type.getName() +" "

+ field[i].getName() +";");

}

System.out.println("===============实现的接口或者父类的属性========================");

// 取得实现的接口或者父类的属性

Field[] filed1 = demo.getFields();

for (int j = 0; j < filed1.length; j++) {

// 权限修饰符

int mo = filed1[j].getModifiers();

String priv = Modifier.toString(mo);

// 属性类型

Class<?> type = filed1[j].getType();

System.out.println(priv +" " + type.getName() +" "

+ filed1[j].getName() +";");

}

【运行结果】：

===============本类属性========================

private java.lang.String sex;

===============实现的接口或者父类的属性========================

public static final java.lang.String name;

public static final int age;

【案例】其实还可以通过反射调用其他类中的方法：

class hello {

public static void main(String[] args) {

Class<?> demo =null;

try {

demo = Class.forName("Reflect.Person");

}catch (Exception e) {

e.printStackTrace();

}

try{

//调用Person类中的sayChina方法

Method method=demo.getMethod("sayChina");

method.invoke(demo.newInstance());

//调用Person的sayHello方法

method=demo.getMethod("sayHello", String.class,int.class);

method.invoke(demo.newInstance(),"Rollen",20);

}catch (Exception e) {

e.printStackTrace();

}

　　【运行结果】：

hello ,china

Rollen 20

【案例】调用其他类的set和get方法

class hello {

public static void main(String[] args) {

Class<?> demo =null;

Object obj=null;

try {

demo = Class.forName("Reflect.Person");

}catch (Exception e) {

e.printStackTrace();

}

try{

obj=demo.newInstance();

}catch (Exception e) {

e.printStackTrace();

}

setter(obj,"Sex","男",String.class);

getter(obj,"Sex");

}

/**

* @param obj

* 操作的对象

* @param att

* 操作的属性

* */

public static void getter(Object obj, String att) {

try {

Method method = obj.getClass().getMethod("get" + att);

System.out.println(method.invoke(obj));

}catch (Exception e) {

e.printStackTrace();

}

/**

* @param obj

* 操作的对象

* @param att

* 操作的属性

* @param value

* 设置的值

* @param type

* 参数的属性

* */

public static void setter(Object obj, String att, Object value,

Class<?> type) {

try {

Method method = obj.getClass().getMethod("set" + att, type);

method.invoke(obj, value);

}catch (Exception e) {

e.printStackTrace();

}

}// end class

【运行结果】：

男

【案例】通过反射操作属性

class hello {

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

Class<?> demo =null;

Object obj =null;

demo = Class.forName("Reflect.Person");

obj = demo.newInstance();

Field field = demo.getDeclaredField("sex");

field.setAccessible(true);

field.set(obj,"男");

System.out.println(field.get(obj));

}

}// end class

【案例】通过反射取得并修改数组的信息：

import java.lang.reflect.*;

class hello{

public static void main(String[] args) {

int[] temp={1,2,3,4,5};

Class<?>demo=temp.getClass().getComponentType();

System.out.println("数组类型： "+demo.getName());

System.out.println("数组长度 "+Array.getLength(temp));

System.out.println("数组的第一个元素: "+Array.get(temp,0));

Array.set(temp,0,100);

System.out.println("修改之后数组第一个元素为： "+Array.get(temp,0));

}

【运行结果】：

数组类型： int

数组长度 5

数组的第一个元素: 1

修改之后数组第一个元素为： 100

【案例】通过反射修改数组大小

class hello{

public static void main(String[] args) {

int[] temp={1,2,3,4,5,6,7,8,9};

int[] newTemp=(int[])arrayInc(temp,15);

print(newTemp);

System.out.println("=====================");

String[] atr={"a","b","c"};

String[] str1=(String[])arrayInc(atr,8);

print(str1);

}

/**

* 修改数组大小

* */

public static Object arrayInc(Object obj,int len){

Class<?>arr=obj.getClass().getComponentType();

Object newArr=Array.newInstance(arr, len);

int co=Array.getLength(obj);

System.arraycopy(obj,0, newArr,0, co);

return newArr;

}

/**

* 打印

* */

public static void print(Object obj){

Class<?>c=obj.getClass();

if(!c.isArray()){

return;

}

System.out.println("数组长度为： "+Array.getLength(obj));

for (int i = 0; i < Array.getLength(obj); i++) {

System.out.print(Array.get(obj, i)+" ");

}

【运行结果】：

数组长度为： 15

1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================

数组长度为： 8

a b c null null null null null

动态代理

【案例】首先来看看如何获得类加载器：

class test{

}

class hello{

public static void main(String[] args) {

test t=new test();

System.out.println("类加载器 "+t.getClass().getClassLoader().getClass().getName());

}

【程序输出】：

类加载器 sun.misc.Launcher$AppClassLoader

其实在java中有三种类类加载器。

1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。

2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类

3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。

如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。

package Reflect;

import java.lang.reflect.*;

//定义项目接口

interface Subject {

public String say(String name,int age);

}

// 定义真实项目

class RealSubjectimplements Subject {

@Override

public String say(String name,int age) {

return name +" " + age;

}

class MyInvocationHandlerimplements InvocationHandler {

private Object obj =null;

public Object bind(Object obj) {

this.obj = obj;

return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj

.getClass().getInterfaces(),this);

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

Object temp = method.invoke(this.obj, args);

return temp;

}

class hello {

public static void main(String[] args) {

MyInvocationHandler demo =new MyInvocationHandler();

Subject sub = (Subject) demo.bind(new RealSubject());

String info = sub.say("Rollen",20);

System.out.println(info);

}

【运行结果】：

Rollen 20

类的生命周期

在一个类编译完成之后，下一步就需要开始使用类，如果要使用一个类，肯定离不开JVM。在程序执行中JVM通过装载，链接，初始化这3个步骤完成。

类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。但是同一个类只会被类装载器装载以前

链接就是把二进制数据组装为可以运行的状态。

链接分为校验，准备，解析这3个阶段

校验一般用来确认此二进制文件是否适合当前的JVM（版本），

准备就是为静态成员分配内存空间，。并设置默认值

解析指的是转换常量池中的代码作为直接引用的过程，直到所有的符号引用都可以被运行程序使用（建立完整的对应关系）

完成之后，类型也就完成了初始化，初始化之后类的对象就可以正常使用了，直到一个对象不再使用之后，将被垃圾回收。释放空间。

当没有任何引用指向Class对象时就会被卸载，结束类的生命周期

将反射用于工厂模式

先来看看，如果不用反射的时候，的工厂模式吧：

http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html

/**

* @author Rollen-Holt 设计模式之工厂模式

*/

interface fruit{

public abstract void eat();

}

class Appleimplements fruit{

public void eat(){

System.out.println("Apple");

}

class Orangeimplements fruit{

public void eat(){

System.out.println("Orange");

}

// 构造工厂类

// 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了

class Factory{

public static fruit getInstance(String fruitName){

fruit f=null;

if("Apple".equals(fruitName)){

f=new Apple();

}

if("Orange".equals(fruitName)){

f=new Orange();

}

return f;

}

class hello{

public static void main(String[] a){

fruit f=Factory.getInstance("Orange");

f.eat();

}

这样，当我们在添加一个子类的时候，就需要修改工厂类了。如果我们添加太多的子类的时候，改的就会很多。

现在我们看看利用反射机制：

package Reflect;

interface fruit{

public abstract void eat();

}

class Appleimplements fruit{

public void eat(){

System.out.println("Apple");

}

class Orangeimplements fruit{

public void eat(){

System.out.println("Orange");

}

class Factory{

public static fruit getInstance(String ClassName){

fruit f=null;

try{

f=(fruit)Class.forName(ClassName).newInstance();

}catch (Exception e) {

e.printStackTrace();

}

return f;

}

class hello{

public static void main(String[] a){

fruit f=Factory.getInstance("Reflect.Apple");

if(f!=null){

f.eat();

}

现在就算我们添加任意多个子类的时候，工厂类就不需要修改。

上面的爱吗虽然可以通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过属性文件的形式配置所需要的子类。

下面我们来看看：结合属性文件的工厂模式

首先创建一个fruit.properties的资源文件，

内容为：

apple=Reflect.Apple

orange=Reflect.Orange

　然后编写主类代码：

package Reflect;

import java.io.*;

import java.util.*;

interface fruit{

public abstract void eat();

}

class Appleimplements fruit{

public void eat(){

System.out.println("Apple");

}

class Orangeimplements fruit{

public void eat(){

System.out.println("Orange");

}

//操作属性文件类

class init{

public static Properties getPro() throws FileNotFoundException, IOException{

Properties pro=new Properties();

File f=new File("fruit.properties");

if(f.exists()){

pro.load(new FileInputStream(f));

}else{

pro.setProperty("apple","Reflect.Apple");

pro.setProperty("orange","Reflect.Orange");

pro.store(new FileOutputStream(f),"FRUIT CLASS");

}

return pro;

}

class Factory{

public static fruit getInstance(String ClassName){

fruit f=null;

try{

f=(fruit)Class.forName(ClassName).newInstance();

}catch (Exception e) {

e.printStackTrace();

}

return f;

}

class hello{

public static void main(String[] a) throws FileNotFoundException, IOException{

Properties pro=init.getPro();

fruit f=Factory.getInstance(pro.getProperty("apple"));

if(f!=null){

f.eat();

}

【运行结果】：Apple

另一种总结：

一、什么是反射机制

        简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，
    那么就可以通过反射机制来获得类的所有信息。
二、哪里用到反射机制
        有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，
    Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成
    驱动对象实例，并不知道它的具体含义。听了反射机制这节课后，才知道，原来这就是反射，现在很多开
    框架都用到反射机制，hibernate、struts都是用反射机制实现的。
三、反射机制的优点与缺点
        为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，
    静态编译：在编译时确定类型，绑定对象,即通过。
    动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多
    态的应用，有以降低类之间的藕合性。
    一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中
    它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编
    译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如
    这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能
    的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功
    能。
       它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它
    满足我们的要求。这类操作总是慢于只直接执行相同的操作。
四、利用反射机制能获得什么信息
         一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了
    首先得根据传入的类的全名来创建Class对象。
    Class c=Class.forName("className");注明：className必须为全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo;
    Object obj=c.newInstance();//创建对象的实例
    OK，有了对象就什么都好办了，想要什么信息就有什么信息了。
    获得构造函数的方法
    Constructor getConstructor(Class[] params)//根据指定参数获得public构造器

Constructor[] getConstructors()//获得public的所有构造器

Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器

    Constructor[] getDeclaredConstructors()//获得public的所有构造器
    获得类方法的方法
    Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法

Method[] getMethods()//获得所有的public方法

Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得public和非public的方法

    Method[] getDeclaredMethods()//获得所以的public和非public方法
    获得类中属性的方法
    Field getField(String name)//根据变量名得到相应的public变量

Field[] getFields()//获得类中所以public的方法

Field getDeclaredField(String name)//根据方法名获得public和非public变量

    Field[] getDeclaredFields()//获得类中所有的public和非public方法
    常用的就这些，知道这些，其他的都好办……
五、用反射机制能干什么事
        刚开始在使用jdbc时侯，在编写访问数据库时写到想吐，有八个表，每个表都有增删改查中操作
    那时候还不知道有反射机制这个概念，所以就对不同的表创建不同的dao类,这样不仅开发速率地，而且代码
    冗余的厉害，最要命的是看着差不多的，然后直接复制修改，由于容易犯各种低级的错误（大小写啊，多一
    个或少一个字母啊……）,一个错误就可以让你找半天。
        有了java反射机制，什么都好办了，只需要写一个dao类，四个方法，增删改查，传入不同的对象，就OK啦，
    无需为每一个表都创建dao类，反射机制会自动帮我们完成剩下的事情，这就是它的好处。说白了，反射机制就是专门
    帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的，只要你按照规则
    输入相关的参数，所以低级的程序员慢慢的就被抹杀了，为什么？因为代码都不用写了，随便一个人都会开发，还要程
    序员干什么啊？所以我们只有一条出路，那就是努力努力再努力，成为高级程序员，专门开发傻瓜软件，让其他程序员到一边凉快去，呵呵~
六、用反射机制实现对数据库数据的增、查例子
    基本原理；保存数据时，把需要保存的对象的属性值全部取出来再拼凑sql语句
                 查询时，将查询到的数据全部包装成一个java对象。
    游戏规则：俗话说的好，无规矩不成方圆，特别是程序来说，它只能做有规则的事情，没有规则的它干不了，好，那就
              先定规则
              1）数据库的每一个表对象一个pojo类，表中的每一个字段对应pojo类的中的一个属性。
                 并且pojo类的名字和表的名字相同，属性名和字段名相同，大小写没有关系，因为数据库一般不区分大小写
              2）为pojo类中的每一个属性添加标准的set和get方法。
    有了游戏规则，那么开始游戏吧。

1、首先数据库的有一个表，假设数据库名称为：blogsystem,里面的一个表名userinfo。如图：

2、创建对应的pojo类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package cn.netjava.pojo;
 
publicclass UserInfo {
privateint id;
private String name;
private String pwd;
privateint age;
 
@Override
public String toString() {
    return "UserInfo [id=" + id + ", name=" + name+ ", pwd=" + pwd+ ", age="
            + age+ "]";
}
publicint getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name= name;
}
public String getPwd() {
    return pwd;
}
public void setPwd(String pwd) {
    this.pwd= pwd;
}
publicint getAge() {
    return age;
}
public void setAge(int age) {
    this.age= age;
}
 
}

2、编写获得数据库连接的工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package cn.netjava.factory;
 
import java.sql.Connection;
import java.sql.DriverManager;
 
publicclass Connect2DBFactory {
    public static Connection getDBConnection() {
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/blogsystem";
            String user = "root";
            String password = "netjava";
            conn= DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return conn;
    }
}

3、好戏开始啦，编写操作数据库的dao类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
package cn.netjava.session;
 
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
 
import cn.netjava.factory.Connect2DBFactory;
import cn.netjava.pojo.UserInfo;
 
publicclass NetJavaSession {
    /**
     * 解析出保存对象的sql语句
     *
     * @paramobject
     *            ：需要保存的对象
     * @return：保存对象的sql语句
     */
    public static String getSaveObjectSql(Object object) {
        // 定义一个sql字符串
        String sql = "insert into ";
        // 得到对象的类
        Class c = object.getClass();
        // 得到对象中所有的方法
        Method[] methods = c.getMethods();
        // 得到对象中所有的属性
        Field[] fields = c.getFields();
        // 得到对象类的名字
        String cName = c.getName();
        // 从类的名字中解析出表名
        String tableName = cName.substring(cName.lastIndexOf(".")+ 1,
                cName.length());
        sql+= tableName+ "(";
        List<String> mList = new ArrayList<String>();
        List vList= new ArrayList();
        for (Method method : methods) {
            String mName = method.getName();
            if (mName.startsWith("get") && !mName.startsWith("getClass")) {
                String fieldName = mName.substring(3, mName.length());
                mList.add(fieldName);
                System.out.println("字段名字----->" + fieldName);
                try {
                    Object value= method.invoke(object, null);
                    System.out.println("执行方法返回的值：" + value);
                    if (value instanceof String) {
                        vList.add("\"" + value+ "\"");
                        System.out.println("字段值------>" + value);
                    }else {
                        vList.add(value);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        for (int i= 0; i < mList.size(); i++) {
            if (i < mList.size() - 1) {
                sql+= mList.get(i)+ ",";
            }else {
                sql+= mList.get(i)+ ") values(";
            }
        }
        for (int i= 0; i < vList.size(); i++) {
            if (i < vList.size() - 1) {
                sql+= vList.get(i)+ ",";
            }else {
                sql+= vList.get(i)+ ")";
            }
        }
 
        return sql;
    }
 
    public static List getDatasFromDB(String tableName, int Id) {
 
        return null;
 
    }
 
    /**
     * 将对象保存到数据库中
     *
     * @paramobject
     *            ：需要保存的对象
     * @return：方法执行的结果;1:表示成功，0:表示失败
     */
    publicint saveObject(Object object) {
        Connection con = Connect2DBFactory.getDBConnection();
        String sql = getSaveObjectSql(object);
        try {
            // Statement statement=(Statement) con.createStatement();
            PreparedStatement psmt = con.prepareStatement(sql);
            psmt.executeUpdate();
            return 1;
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
 
    /**
     * 从数据库中取得对象
     *
     * @param arg0
     *            ：对象所属的类
     * @paramid
     *            ：对象的id
     * @return:需要查找的对象
     */
    publicObject getObject(String className, int Id) {
        // 得到表名字
        String tableName = className.substring(className.lastIndexOf(".")+ 1,
                className.length());
        // 根据类名来创建Class对象
        Class c = null;
        try {
            c= Class.forName(className);
 
        } catch (ClassNotFoundException e1) {
 
            e1.printStackTrace();
        }
        // 拼凑查询sql语句
        String sql = "select * from " + tableName+ " where Id=" + Id;
        System.out.println("查找sql语句：" + sql);
        // 获得数据库链接
        Connection con = Connect2DBFactory.getDBConnection();
        // 创建类的实例
        Object obj= null;
        try {
 
            Statement stm = con.createStatement();
            // 得到执行查寻语句返回的结果集
            ResultSetset = stm.executeQuery(sql);
            // 得到对象的方法数组
            Method[] methods = c.getMethods();
            // 遍历结果集
            while (set.next()) {
                obj= c.newInstance();
                // 遍历对象的方法
                for (Method method : methods) {
                    String methodName = method.getName();
                    // 如果对象的方法以set开头
                    if (methodName.startsWith("set")) {
                        // 根据方法名字得到数据表格中字段的名字
                        String columnName = methodName.substring(3,
                                methodName.length());
                        // 得到方法的参数类型
                        Class[] parmts = method.getParameterTypes();
                        if (parmts[0]== String.class) {
                            // 如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法
                            method.invoke(obj,set.getString(columnName));
                        }
                        if (parmts[0]== int.class) {
                            method.invoke(obj,set.getInt(columnName));
                        }
                    }
 
                }
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}

4、开始测试效果怎么样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package cn.netjava.tester;
 
import cn.netjava.pojo.UserInfo;
import cn.netjava.session.NetJavaSession;
 
publicclass Tester {
    public static void main(String args[]) {
        //获得NetJavaSession对象
        NetJavaSession session = new NetJavaSession();
        //创建一个UserInfo对象
        UserInfo user = new UserInfo();
        //设置对象的属性
        user.setId(6988);
        user.setAge(44);
        user.setPwd("pwd");
        user.setName("champion");
        //将对象保存到数据库中
        String sql = session.getSaveObjectSql(user);
        System.out.println("保存对象的sql语句：" + sql);
        //查找对象
        UserInfo userInfo = (UserInfo) session.getObject(
                "cn.netjava.pojo.UserInfo",6988);
        System.out.println("获取到的信息：" + userInfo);
 
    }
}

5、打印出来的结果：

七、总节一下

总的来说，java反射机制是一个很好用的东西，用它可以解决很多死的东西，因为反射机制的灵活行很大，有了他，我们就不要花太多的时间来写操做数据库的代码了，而是方法更多的时间在项目的逻辑功能上，这个可以很大的减少开发时间，而且代码的可读性好。先在的很多开源框架都是才用的反射机制，它只要配置文件，然后按规则来调用他的方法就可以了。

0 0