疯狂java讲义之类加载与反射

本文主要是介绍疯狂java讲义之类加载与反射，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. 类的加载, 连接和初始化

1.1 JVM和类

当我们调用java命令运行某个java程序时，该命令将会启动一条Java虚拟机进程，不管该Java程序多复杂、启动了多少个线程，它们都处于该虚拟机进程里、使用同一个进程里的内存区。这几种情况的JVM进程被终止：

1）程序运行完正常结束.

2）运行到System.exit()或Runtime.getRuntime().exit()代码处结束程序.

3）程序运行过程中遇到未捕获的异常或错误而结束.

4）程序所在平台强制结束了JVM进程.

当Java程序结束时，jvm进程也结束，该进程在内存的状态也将丢失，下面举例说明：

    public class A
   {
       //定义该类的静态属性
      public static int a = 6;
   }

   public class TestA1
   {
      public static void main(String[] args)
     {
        //创建A类的实例
        A a = new A();
        //让a实例的a属性自加
       a.a ++;
       System.out.println(a.a);
     }
}

   public class TestA2
   {
      public static void main(String[] args)
     {
         //创建A类的实例
         A b = new A();
         //输出b实例的a的属性值
         System.out.println(b.a);
      }
   }

TestA1中的a自加1后输出为7，而TestA2中的b输出仍然为6，说明进程结束后状态也跟着丢失，且两个JVM进程独立运行，它们之间不共享数据。

1. 2 类的加载

. 当程序主动使用某个类时, 如果该类还未被加载到内存中, 则系统会通过加载、连接、初始化3个步骤来对该类进行初始化. (如果没有意外, JVM会连续完成这3个步骤, 所以有时也把这3个步骤统称为类加载或类初始化.)

类加载指将类的class文件读入内存, 并为之创建一个java.lang.Class对象, 就是说当程序中使用任何类时, 系统都会为之建立一个java.lang.Class对象。

类的加载有类加载器(CLassLoader)完成. 类加载器通常由JVM提供. 类加载器除了根类加载器外, 其他的都是用Java语言编写的. JVM提供的类加载器叫系统类加载器, 还可以通过集成ClassLoader基类来创建自己的加载器. 通过不同的类加载器可以从不同来源加载类的二进制数据(如从本机文件系统加载class文件, 从JAR包加载class文件, 从网络加载class文件等)。

1.3 类的链接

类被加载之后, 系统生成一个和它对应的java.lang.Class对象, 然后进入连接阶段把类的二进制数据合并到JRE中. 类的连接分三个阶段.

1）验证: 检测被加载的类是否有正确的内部结构, 并和其他类协调一致.

2）准备: 为类的静态Field分配内存, 并设置默认初始值.

3）解析: 将类的二进制数据中的符号引用替换成直接引用.

1.4 类的初始化

JVM初始化一个类的步骤:

如果这个类还没有被加载和连接, 则程序先加载并连接该类.
如果该类的直接父类没有被初始化, 则先初始化其直接父类. (顺着捋, 都能捋到java.lang.Object类, 所以JVM最先初始化的总是java.lang.Object类. ）
如果类中有初始化语句, 则一次执行这些初始化语句.

1.5 类初始化的时机

使用下面6种方式时，系统会初始化该类或接口：

1）创建类的实例。使用new、反射或反序列化的方式创建。

2）调用某个类的静态方法。

3）使用Class.forName("Person")方式强制创建类对象。

4）初始化某个类的子类，它的所有父类都会被初始化。

5）访问某个类或接口的静态属性，或为该静态属性赋值。

6）直接用java.exe运行某个主类。

除此此之外，下面是一些特殊的情况要考虑的：

1）对于一个final型的静态Field, 如果该Field的值在编译时就可以确定下来, 那么这个field相当于"宏变量", 编译器在编译时直接把这个Field出现的地方替换成它的值, 因此即使程序使用该静态Field也不会导致该类的初始化.

class MyTest
{
      static
     {
          System.out.println("静态初始化块...");
     }
      //使用一个字符串直接量为static final属性赋值
     static final String comileConstant = "Struts2权威指南";
     // //采用系统当前时间为static final属性赋值
     // static final String comileConstant =
     //  System.currentTimeMillis() + "";

}
public class TestCompileConstant
{
     public static void main(String[] args)
    {
         //访问、输出MyTest中的comileConstant属性
         System.out.println(MyTest.comileConstant);
     }
   }

2）使用ClassLoader类的loadClass()方法加载某个类时, 该方法只是加载该类, 不执行初始化. 使用Class的forName()静态方法才会导致强制初始化该类.。

class Tester

{
static
{
System.out.println("Tester类的静态初始化块");
}
}
public class ClassLoaderTest
{
public static void main(String[] args)
throws ClassNotFoundException
{
ClassLoader cl = ClassLoader.getSystemClassLoader();
cl.loadClass("Tester");
System.out.println("系统加载Tester类");
Class.forName("Tester");
}
}

2 类加载器

类加载器负责将.class文件（可能在磁盘上，或网络上）加载到内存中, 并为之生成对应的java.lang.Class对象.

2.1 类加载器简介

加入内存中的类有对应的一个java.lang.Class实例. 一个类一旦加入JVM中, 就不会再次被载入了. 怎样判断是否是同一个类? 答: Java中, 类用其全限定类名(包括包名和类名)作为标识; JVM中, 用其全限定类名和其类加载器名作为其唯一标识(如包pg中的Person类用类加载器ClassLoader的kl实例加载, 则JVM中表示为(Person、pg、kl)). 同名类（Person、pg、k1）和（Person、pg、k2）是不同的。

JVM启动时, 形成由3个类加载器组成的初始类加载器层次结构:

Bootstrap ClassLoader: 根类加载器. 也叫引导(原始)类加载器, 负责加载Java的核心类, 它不是java.lang.ClassLoader的子类而是由JVM自身实现的.
Extension ClasssLoader: 扩展类加载器. 负责加载JRE扩展目录(%JAVA_HOME%/jre/lib/ext或者由java.ext.dirs系统属性制定的目录)中JAR包的类.
System ClassLoader: 系统类加载器. 也叫应用加载器, 负责在JVM启动时加载来自java命令的-classpath选项, java.class.path系统属性或CLASSPATH环境变量所指定的JAR包和类路径. 程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器. 如果没有特别指定, 则用户自定义的类加载器都是以系统类加载器作为父加载器.

类加载器加载Class分为8个步骤：

1）检测Class是否被加载过（即在缓存中是否存在），如果有则直接进入第8步，否则执行第2部。

2）如果父加载器不存在，则跳到第4步执行，否则执行第3步。

3）请求父加载器载入目标类，如果成功在如则跳到第8步，否则执行第5步。

4）请求使用根加载器载入目标类，如果成功跳到第8步，否则执行第7步。

5）寻找Class类，找到则执行第6步，否则执行第7步。

6）从文件中在入Class文件，成功则跳到第8步。

7）抛出异常ClassNotFoundException。

8）返回Class。

3. 通过反射查看类信息

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。当然反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。

Java反射机制主要提供下面几种用途：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法

首先看一个简单的例子，通过这个例子来理解Java的反射机制是如何工作的。

View Code

package com.wanggc.reflection;
import java.lang.reflect.Method;
/**
* Java 反射练习。
* 
* @author Wanggc
*/
public class ForNameTest {
/**
* 入口函数。
* 
* @param args
*            参数
* @throws Exception
*             错误信息
*/
public static void main(String[] args) throws Exception {
// 获得Class
        Class<?> cls = Class.forName(args[0]);
// 通过Class获得所对应对象的方法
        Method[] methods = cls.getMethods();
// 输出每个方法名
        for (Method method : methods) {
System.out.println(method);
}
}
}

当传入的参数是java.lang.String时，会输出如下结果

View Code

public boolean java.lang.String.equals(java.lang.Object)
public java.lang.String java.lang.String.toString()
public int java.lang.String.hashCode()
public int java.lang.String.compareTo(java.lang.String)
public int java.lang.String.compareTo(java.lang.Object)
public int java.lang.String.indexOf(int)
public int java.lang.String.indexOf(int,int)
public int java.lang.String.indexOf(java.lang.String)
public int java.lang.String.indexOf(java.lang.String,int)
public static java.lang.String java.lang.String.valueOf(int)
public static java.lang.String java.lang.String.valueOf(char)
public static java.lang.String java.lang.String.valueOf(boolean)
public static java.lang.String java.lang.String.valueOf(float)
public static java.lang.String java.lang.String.valueOf(char[],int,int)
public static java.lang.String java.lang.String.valueOf(double)
public static java.lang.String java.lang.String.valueOf(char[])
public static java.lang.String java.lang.String.valueOf(java.lang.Object)
public static java.lang.String java.lang.String.valueOf(long)
public char java.lang.String.charAt(int)
public int java.lang.String.codePointAt(int)
public int java.lang.String.codePointBefore(int)
public int java.lang.String.codePointCount(int,int)
public int java.lang.String.compareToIgnoreCase(java.lang.String)
public java.lang.String java.lang.String.concat(java.lang.String)
public boolean java.lang.String.contains(java.lang.CharSequence)
public boolean java.lang.String.contentEquals(java.lang.CharSequence)
public boolean java.lang.String.contentEquals(java.lang.StringBuffer)
public static java.lang.String java.lang.String.copyValueOf(char[])
public static java.lang.String java.lang.String.copyValueOf(char[],int,int)
public boolean java.lang.String.endsWith(java.lang.String)
public boolean java.lang.String.equalsIgnoreCase(java.lang.String)
public static java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[])
public static java.lang.String java.lang.String.format(java.util.Locale,java.lang.String,java.lang.Object[])
public byte[] java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException
public void java.lang.String.getBytes(int,int,byte[],int)
public byte[] java.lang.String.getBytes()
public byte[] java.lang.String.getBytes(java.nio.charset.Charset)
public void java.lang.String.getChars(int,int,char[],int)
public native java.lang.String java.lang.String.intern()
public boolean java.lang.String.isEmpty()
public int java.lang.String.lastIndexOf(java.lang.String)
public int java.lang.String.lastIndexOf(int,int)
public int java.lang.String.lastIndexOf(int)
public int java.lang.String.lastIndexOf(java.lang.String,int)
public int java.lang.String.length()
public boolean java.lang.String.matches(java.lang.String)
public int java.lang.String.offsetByCodePoints(int,int)
public boolean java.lang.String.regionMatches(boolean,int,java.lang.String,int,int)
public boolean java.lang.String.regionMatches(int,java.lang.String,int,int)
public java.lang.String java.lang.String.replace(java.lang.CharSequence,java.lang.CharSequence)
public java.lang.String java.lang.String.replace(char,char)
public java.lang.String java.lang.String.replaceAll(java.lang.String,java.lang.String)
public java.lang.String java.lang.String.replaceFirst(java.lang.String,java.lang.String)
public java.lang.String[] java.lang.String.split(java.lang.String)
public java.lang.String[] java.lang.String.split(java.lang.String,int)
public boolean java.lang.String.startsWith(java.lang.String)
public boolean java.lang.String.startsWith(java.lang.String,int)
public java.lang.CharSequence java.lang.String.subSequence(int,int)
public java.lang.String java.lang.String.substring(int)
public java.lang.String java.lang.String.substring(int,int)
public char[] java.lang.String.toCharArray()
public java.lang.String java.lang.String.toLowerCase()
public java.lang.String java.lang.String.toLowerCase(java.util.Locale)
public java.lang.String java.lang.String.toUpperCase()
public java.lang.String java.lang.String.toUpperCase(java.util.Locale)
public java.lang.String java.lang.String.trim()
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

这样就列出了java.lang.String类的所有方法名、及其限制符、返回类型及抛出的异常。这个程序使用Class类forName方法载入指定的类，然后调用getMethods方法返回指定类的方法列表。java.lang.reflect.Method用来表述某个类中的单一方法。

使用java的反射机制，一般需要遵循三步：

1. 获得你想操作类的Class对象
2. 通过第一步获得的Class对象去取得操作类的方法或是属性名
3. 操作第二步取得的方法或是属性

Java运行的时候，某个类无论生成多少个对象，他们都会对应同一个Class对象，它表示正在运行程序中的类和接口。如何取得操作类的Class对象，常用的有三种方式：

1. 调用Class的静态方法forName，如上例；
2. 使用类的.class语法，如：Class<?> cls = String.class；
3. 调用对象的getClass方法，如：String str = "abc"；Class<?> cls = str .getClass()；

下面将通过实例讲述如何通过前面所诉的三步来执行某对象的某个方法：

View Code

 1 package com.wanggc.reflection;
 2 
 3 import java.lang.reflect.Method;
 4 
 5 /**
 6  * Java 反射练习。
 7  * 
 8  * @author Wanggc
 9  */
10 public class ReflectionTest {
11     public static void main(String[] args) throws Exception {
12         DisPlay disPlay = new DisPlay();
13         // 获得Class
14         Class<?> cls = disPlay.getClass();
15         // 通过Class获得DisPlay类的show方法
16         Method method = cls.getMethod("show", String.class);
17         // 调用show方法
18         method.invoke(disPlay, "Wanggc");
19     }
20 }
21 
22 class DisPlay {
23     public void show(String name) {
24         System.out.println("Hello :" + name);
25     }
26 }

前面说过，Java程序的每个类都会有个Class对象与之对应。Java反射的第一步就是获得这个Class对象，如代码14行。当然，每个类的方法也必有一个Method对象与之对应。要通过反射的方式调用这个方法，就要首先获得这个方法的Method对象,如代码16行，然后用Method对象反过来调用这个方法，如代码18行。注意16行getMethod方法的第一个参数是方法名，第二个是此方法的参数类型，如果是多个参数，接着添加参数就可以了，因为getMethod是可变参数方法。执行18行代码的invoke方法，其实也就是执行show方法，注意invoke的第一个参数，是DisPlay类的一个对象，也就是调用DisPlay类哪个对象的show方法，第二个参数是给show方法传递的参数。类型和个数一定要与16行的getMethod方法一直。

上例讲述了如何通过反射调用某个类的方法，下面将再通过一个实例讲述如何通过反射给某个类的属性赋值：

View Code

  1 package com.wanggc.reflection;
  2 
  3 import java.lang.reflect.Field;
  4 
  5 /**
  6  * Java 反射之属性练习。
  7  * 
  8  * @author Wanggc
  9  */
 10 public class ReflectionTest {
 11     public static void main(String[] args) throws Exception {
 12         // 建立学生对象
 13         Student student = new Student();
 14         // 为学生对象赋值
 15         student.setStuName("Wanggc");
 16         student.setStuAge(24);
 17         // 建立拷贝目标对象
 18         Student destStudent = new Student();
 19         // 拷贝学生对象
 20         copyBean(student, destStudent);
 21         // 输出拷贝结果
 22         System.out.println(destStudent.getStuName() + ":"
 23                 + destStudent.getStuAge());
 24     }
 25 
 26     /**
 27      * 拷贝学生对象信息。
 28      * 
 29      * @param from
 30      *            拷贝源对象
 31      * @param dest
 32      *            拷贝目标对象
 33      * @throws Exception
 34      *             例外
 35 */
 36     private static void copyBean(Object from, Object dest) throws Exception {
 37         // 取得拷贝源对象的Class对象
 38         Class<?> fromClass = from.getClass();
 39         // 取得拷贝源对象的属性列表
 40         Field[] fromFields = fromClass.getDeclaredFields();
 41         // 取得拷贝目标对象的Class对象
 42         Class<?> destClass = dest.getClass();
 43         Field destField = null;
 44         for (Field fromField : fromFields) {
 45             // 取得拷贝源对象的属性名字
 46             String name = fromField.getName();
 47             // 取得拷贝目标对象的相同名称的属性
 48             destField = destClass.getDeclaredField(name);
 49             // 设置属性的可访问性
 50             fromField.setAccessible(true);
 51             destField.setAccessible(true);
 52             // 将拷贝源对象的属性的值赋给拷贝目标对象相应的属性
 53             destField.set(dest, fromField.get(from));
 54         }
 55     }
 56 }
 57 
 58 /**
 59  * 学生类。
 60  */
 61 class Student {
 62     /** 姓名 */
 63     private String stuName;
 64     /** 年龄 */
 65     private int stuAge;
 66 
 67     /**
 68      * 获取学生姓名。
 69      * 
 70      * @return 学生姓名
 71 */
 72     public String getStuName() {
 73         return stuName;
 74     }
 75 
 76     /**
 77      * 设置学生姓名
 78      * 
 79      * @param stuName
 80      *            学生姓名
 81 */
 82     public void setStuName(String stuName) {
 83         this.stuName = stuName;
 84     }
 85 
 86     /**
 87      * 获取学生年龄
 88      * 
 89      * @return 学生年龄
 90 */
 91     public int getStuAge() {
 92         return stuAge;
 93     }
 94 
 95     /**
 96      * 设置学生年龄
 97      * 
 98      * @param stuAge
 99      *            学生年龄
100 */
101     public void setStuAge(int stuAge) {
102         this.stuAge = stuAge;
103     }
104 }

Java的发射机制中类有Class对应，类的方法有Method对应，当然属性也有Field与之对应。代码中注释已经做了详细的注释，在此不再赘述。但要注意，Field提供了get和set方法获取和设置属性的值，但是由于属性是私有类型，所以需要设置属性的可访问性为true，如代码50~51行。也可以在为整个fields设置可访问性，在40行下面使用AccessibleObject的静态方法setAccessible，如：AccessibleObject.setAccessible(fromFields, true);

前面讲述了如何用Java反射机制操作一个类的方法和属性，下面再通过一个实例讲述如何在运行时创建类的一个对象：

View Code

 1 package com.wanggc.reflection;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 /**
 6  * Java 反射之属性练习。
 7  * 
 8  * @author Wanggc
 9  */
10 public class ReflectionTest {
11     public static void main(String[] args) throws Exception {
12         // 建立学生对象
13         Student student = new Student();
14         // 为学生对象赋值
15         student.setStuName("Wanggc");
16         student.setStuAge(24);
17         // 建立拷贝目标对象
18         Student destStudent = (Student) copyBean(student);
19         // 输出拷贝结果
20         System.out.println(destStudent.getStuName() + ":"
21                 + destStudent.getStuAge());
22     }
23 
24     /**
25      * 拷贝学生对象信息。
26      * 
27      * @param from
28      *            拷贝源对象
29      * @param dest
30      *            拷贝目标对象
31      * @throws Exception
32      *             例外
33 */
34     private static Object copyBean(Object from) throws Exception {
35         // 取得拷贝源对象的Class对象
36         Class<?> fromClass = from.getClass();
37         // 取得拷贝源对象的属性列表
38         Field[] fromFields = fromClass.getDeclaredFields();
39         // 取得拷贝目标对象的Class对象
40         Object ints = fromClass.newInstance();
41         for (Field fromField : fromFields) {
42             // 设置属性的可访问性
43             fromField.setAccessible(true);
44             // 将拷贝源对象的属性的值赋给拷贝目标对象相应的属性
45             fromField.set(ints, fromField.get(from));
46         }
47 
48         return ints;
49     }
50 }
51 
52 /**
53  * 学生类。
54  */
55 class Student {
56     /** 姓名 */
57     private String stuName;
58     /** 年龄 */
59     private int stuAge;
60 
61     /**
62      * 获取学生姓名。
63      * 
64      * @return 学生姓名
65 */
66     public String getStuName() {
67         return stuName;
68     }
69 
70     /**
71      * 设置学生姓名
72      * 
73      * @param stuName
74      *            学生姓名
75 */
76     public void setStuName(String stuName) {
77         this.stuName = stuName;
78     }
79 
80     /**
81      * 获取学生年龄
82      * 
83      * @return 学生年龄
84 */
85     public int getStuAge() {
86         return stuAge;
87     }
88 
89     /**
90      * 设置学生年龄
91      * 
92      * @param stuAge
93      *            学生年龄
94 */
95     public void setStuAge(int stuAge) {
96         this.stuAge = stuAge;
97     }
98 }

此例和上例运行的结果是相同的。但是copyBean方法返回的对象不再是外面传入的，而是由方法内部产生的，如第40行代码所示。注意：Class的newInstance方法，只能创建只包含无参数的构造函数的类，如果某类只有带参数的构造函数，那么就要使用另外一种方式：fromClass.getDeclaredConstructor(int.class,String.class).newInstance(24,"wanggc");

至此，Java反射机制的常用机能(运行时调用对象的方法、类属性的使用、创类类的对象)已经介绍完了。

这篇关于疯狂java讲义之类加载与反射的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！