★文件流
文g操作是最单最直接也是最Ҏ(gu)惛_的一U方式，我们说的文g操作不仅仅是通过FileInputStream/FileOutputStreamq么“裸”的方式直接把数据写入到本地文gQ像我以前写的一个扫L(fng)游戏JavaMine是q样保存一局的状态的Q，q样比较“底层”了(jin)?
主要cMҎ(gu)和描q?
FileInputStream.read() //从本地文件读取二q制格式的数?nbsp;
FileReader.read() //从本地文件读取字W（文本Q数?nbsp;
FileOutputStream.write() //保存二进制数据到本地文g
FileWriter.write() //保存字符数据到本地文?
★XML
和上面的单纯的I/O方式相比QXML显得“高档”得多，以至于成ZU数据交换的标准。以DOM方式ZQ它兛_(j)的是首先在内存中构造文档树(wi)Q数据保存在某个l点上（可以是叶子结点，也可以是标签l点的属性）(j)Q构造好?jin)以后一ơ性的写入到外部文Ӟ但我们只需要知道文件的位置Qƈ不知道I/O是怎么操作的，XML操作方式可能多数Z实践q，所以这里也只列出相关的Ҏ(gu)Q供初学者预先了(jin)解一下。主要的包是javax.xml.parsersQorg.w3c.domQjavax.xml.transform?
主要cMҎ(gu)和描q?
DocumentBuilderFactory.newDocumentBuilder().parse() //解析一个外部的XML文gQ得C个Document对象的DOM?nbsp;
DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument() //初始化一DOM?nbsp;
Document.getDocumentElement().appendChild() //Z个标{Ҏ(gu)加一个子l点
Document.createTextNode() //生成一个字W串l点
Node.getChildNodes() //取得某个l点的所有下一层子l点
Node.removeChild() //删除某个l点的子l点
Document.getElementsByTagName() 查找所有指定名U的标签l点
Document.getElementById() //查找指定名称的一个标{点，如果有多个符合，则返回某一个，通常是第一?nbsp;
Element.getAttribute() //取得一个标{某个属性的的?nbsp;
Element.setAttribute() //讄一个标{某个属性的的?nbsp;
Element.removeAttribute() //删除一个标{某个属?nbsp;
TransformerFactory.newInstance().newTransformer().transform() //一DOM?wi)写入到外部XML文g
★序列化
使用基本的文件读写方式存取数据，如果我们仅仅保存相同cd的数据，则可以用同一U格式保存，譬如在我的JavaMine中保存一个盘局Ӟ需要保存每一个方格的坐标、是否有地雷Q是否被d{，q些信息l合成一个“复合类型”；相反Q如果有多种不同cd的数据，那我们要么把它分解成若干部分Q以相同cdQ譬如StringQ保存，要么我们需要在E序中添加解析不同类型数据格式的逻辑Q这很不方ѝ于是我们期望用一U比较“高”的层次上处理数据，E序员应该花可能少的时间和代码Ҏ(gu)据进行解析，事实上，序列化操作ؓ(f)我们提供?jin)这样一条途径?BR> 序列化（SerializationQ大家可能都有所接触Q它可以把对象以某种特定的编码格式写入或从外部字节流Q即ObjectInputStream/ObjectOutputStreamQ中d。序列化一个对象非怹单，仅仅实现一下Serializable接口卛_Q甚至都不用为它专门dMҎ(gu)Q?
public class MySerial implements java.io.Serializable
{
//...
}
但有一个条Ӟ(x)即你要序列化的类当中Q它的每个属性都必须是是“可序列化”的。这句话说v来有Ҏ(gu)口，其实所有基本类型（是intQcharQboolean之类的）(j)都是“可序列化”的Q而你可以看看JDK文档Q会(x)发现很多cd实已l实C(jin)SerializableQ即已经是“可序列化”的?jin)?j)Q于是这些类的对象以?qing)基本数据类型都可以直接作?f)你需要序列化的那个类的内部属性。如果碰C(jin)不是“可序列化”的属性怎么办？对不P那这个属性的c还需要事先实现Serializable接口Q如此递归Q直到所有属性都是“可序列化”的?
主要cMҎ(gu)和描q?
ObjectOutputStream.writeObject() //一个对象序列化到外部字节流
ObjectInputStream.readObject() //从外部字节流dq新构造对?
从实际应用上看来Q“Serializable”这个接口ƈ没有定义MҎ(gu)Q仿?jng)它只是一个标讎ͼ或者说像是Java的关键字Q而已Q一旦虚拟机看到q个“标记”，׃(x)试调用自n预定义的序列化机Ӟ除非你在实现Serializable接口的同时还定义?jin)私有的readObject()或writeObject()Ҏ(gu)。这一点很奇怪。不q你要是不愿意让pȝ使用~省的方式进行序列化Q那必d义上面提到的两个Ҏ(gu)Q?
public class MySerial implements java.io.Serializable
{
private void writeObject(java.io.ObjectOutputStream out) throws IOException
{
//...
}
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
{
//...
}
//...
}
譬如你可以在上面的writeObject()里调用默认的序列化方法ObjectOutputStream.defaultWriteObject();譬如你不愿意某些敏感的属性和信息序列化，你也可以调用ObjectOutputStream.writeObject()Ҏ(gu)明确指定需要序列化那些属性。关于用户可定制的序列化Ҏ(gu)Q我们将在后面提到?
★Bean
上面的序列化只是一U基本应用，你把一个对象序列化到外部文件以后，用notepad打开那个文gQ只能从为数不多的一些可dW中猜到q是有关q个cȝ信息文gQ这需要你熟?zhn)序列化文件的字节~码方式Q那是比较痛苦的（在《Core Java 2》第一卷里提到?jin)相关编码方式，有兴的话可以查看参考资料）(j)Q某些情况下我们可能需要被序列化的文gh更好的可L。另一斚wQ作为Javalg的核?j)概念“JavaBeans”，从JDK 1.4开始，其规范里也要求支持文本方式的“长期的持久化”（long-term persistenceQ?BR> 打开JDK文档Qjava.beans包里的有一个名为“Encoder”的c，q就是一个可以序列化bean的实用类。和它相关的两个主要cLXMLEcoder和XMLDecoderQ显?dng)q是以XML文g的格式保存和dbean的工兗他们的用法也很单，和上面ObjectOutputStream/ObjectInputStream比较cM?
主要cMҎ(gu)和描q?
XMLEncoder.writeObject() //一个对象序列化到外部字节流
XMLDecoder.readObject() //从外部字节流dq新构造对?nbsp;
如果一个bean是如下格式：(x)
public class MyBean
{
int i;
char[] c;
String s;
//...(get和set操作省略)...
}
那么通过XMLEcoder序列化出来的XML文ghq样的Ş式：(x)
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.4.0" class="java.beans.XMLDecoder">
<object class="MyBean">
<void property="i">
<int>1</int>
</void>
<void property="c">
<array class="char" length="3">
<void index="0">
<int>a</int>
</void>
<void index="1">
<int>b</int>
</void>
<void index="2">
<int>c</int>
</void>
</array>
</void>
<void property="s">
<string>fox jump!</string>
</void>
</object>
</java>
像AWT和Swing中很多可视化lg都是beanQ当然也是可以用q种方式序列化的Q下面就是从JDK文档中摘录的一个JFrame序列化以后的XML文gQ?
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.0" class="java.beans.XMLDecoder">
<object class="javax.swing.JFrame">
<void property="name">
<string>frame1</string>
</void>
<void property="bounds">
<object class="java.awt.Rectangle">
<int>0</int>
<int>0</int>
<int>200</int>
<int>200</int>
</object>
</void>
<void property="contentPane">
<void method="add">
<object class="javax.swing.JButton">
<void property="label">
<string>Hello</string>
</void>
</object>
</void>
</void>
<void property="visible">
<boolean>true</boolean>
</void>
</object>
</java>
因此但你惌保存的数据是一些不是太复杂的类型的话，把它做成bean再序列化也不׃ؓ(f)一U方便的选择?
★Properties
在以前我ȝ的一关于集合框架的文章里提到q，Properties是历史集合类的一个典型的例子Q这里主要不是介l它的集合特性。大家可能都l常接触一些配|文Ӟ如Windows的ini文gQApache的conf文gQ还有Java里的properties文g{，q些文g当中的数据以“关键字-值”对的方式保存。“环境变量”这个概念都知道吧，它也是一U“key-value”对Q以前也常常看到版上问“如何取得系l某某信息”之cȝ问题Q其实很多都保存在环境变量里Q只要用一?/P>
System.getProperties().list(System.out);
p获得全部环境变量的列表：(x)
-- listing properties --
java.runtime.name=Java(TM) 2 Runtime Environment, Stand...
sun.boot.library.path=C:\Program Files\Java\j2re1.4.2_05\bin
java.vm.version=1.4.2_05-b04
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
user.country=CN
sun.os.patch.level=Service Pack 1
java.vm.specification.name=Java Virtual Machine Specification
user.dir=d:\my documents\目\eclipse\SWTDemo
java.runtime.version=1.4.2_05-b04
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
os.arch=x86
java.io.tmpdir=C:\DOCUME~1\cn2lx0q0\LOCALS~1\Temp\
line.separator=
java.vm.specification.vendor=Sun Microsystems Inc.
user.variant=
os.name=Windows XP
sun.java2d.fontpath=
java.library.path=C:\Program Files\Java\j2re1.4.2_05\bi...
java.specification.name=Java Platform API Specification
java.class.version=48.0
java.util.prefs.PreferencesFactory=java.util.prefs.WindowsPreferencesFac...
os.version=5.1
user.home=D:\Users\cn2lx0q0
user.timezone=
java.awt.printerjob=sun.awt.windows.WPrinterJob
file.encoding=GBK
java.specification.version=1.4
user.name=cn2lx0q0
java.class.path=d:\my documents\目\eclipse\SWTDemo\bi...
java.vm.specification.version=1.0
sun.arch.data.model=32
java.home=C:\Program Files\Java\j2re1.4.2_05
java.specification.vendor=Sun Microsystems Inc.
user.language=zh
awt.toolkit=sun.awt.windows.WToolkit
java.vm.info=mixed mode
java.version=1.4.2_05
java.ext.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
sun.boot.class.path=C:\Program Files\Java\j2re1.4.2_05\li...
java.vendor=Sun Microsystems Inc.
file.separator=\
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
sun.cpu.endian=little
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.isalist=pentium i486 i386
主要cMҎ(gu)和描q?
load() //从一个外部流d属?nbsp;
store() //属性保存到外部（特别是文Ӟ(j)
getProperty() //取得一个指定的属?nbsp;
setProperty() //讄一个指定的属?nbsp;
list() //列出q个Properties对象包含的全部“key-value”对
System.getProperties() //取得pȝ当前的环境变?nbsp;
你可以这样保存一个properties文gQ?
Properties prop = new Properties();
prop.setProperty("key1", "value1");
...
FileOutputStream out = new FileOutputStream("config.properties");
prop.store(out, "--q里是文件头Q可以加入注?-");
★Preferences
如果我说Java里面可以不用JNI的手D|作Windows的注册表你信不信Q很多Y件的菜单里都有“Setting”或“Preferences”这L(fng)选项用来讑֮或修改Y件的配置Q这些配|信息可以保存到一个像上面所q的配置文g当中Q如果是Windowsq_下，也可能会(x)保存到系l注册表中。从JDK 1.4开始，Java在java.util下加入了(jin)一个专门处理用户和pȝ配置信息的java.util.prefs包，其中一个类Preferences是一U比较“高U”的玩意。从本质上讲QPreferences本n是一个与q_无关的东西，但不同的OS对它的SPIQService Provider InterfaceQ的实现却是与^台相关的Q因此，在不同的pȝ中你可能看到首选项保存为本地文件、LDAP目录V数据库条目{，像在Windowsq_下，它就保存C(jin)pȝ注册表中。不仅如此，你还可以把首选项导出为XML文g或从XML文g导入?
主要cMҎ(gu)和描q?
systemNodeForPackage() //Ҏ(gu)指定的Class对象得到一个Preferences对象Q这个对象的注册表\径是从“HKEY_LOCAL_MACHINE\”开始的
systemRoot() //得到以注册表路径HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs 为根l点的Preferences对象
userNodeForPackage() //Ҏ(gu)指定的Class对象得到一个Preferences对象Q这个对象的注册表\径是从“HKEY_CURRENT_USER\”开始的
userRoot() //得到以注册表路径HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs 为根l点的Preferences对象
putXXX() //讄一个属性的|q里XXX可以为基本数值型cdQ如int、long{，但首字母大写Q表C参Cؓ(f)相应的类型，也可以不写而直接用putQ参数则为字W串
getXXX() //得到一个属性的?nbsp;
exportNode() //全部首选项导出Z个XML文g
exportSubtree() //部分首选项导出Z个XML文g
importPreferences() //从XML文g导入首选项
你可以按如下步骤保存数据Q?/P>
Preferences myPrefs1 = Preferences.userNodeForPackage(this);// q种Ҏ(gu)是在“HKEY_CURRENT_USER\”下按当前类的\径徏立一个注册表?
Preferences myPrefs2 = Preferences.systemNodeForPackage(this);// q种Ҏ(gu)是在“HKEY_LOCAL_MACHINE\”下按当前类的\径徏立一个注册表?
Preferences myPrefs3 = Preferences.userRoot().node("com.jungleford.demo");// q种Ҏ(gu)是在“HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表?
Preferences myPrefs4 = Preferences.systemRoot().node("com.jungleford.demo");// q种Ҏ(gu)是在“HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表?
myPrefs1.putInt("key1", 10);
myPrefs1.putDouble("key2", -7.15);
myPrefs1.put("key3", "value3");
FileOutputStream out = new FileOutputStream("prefs.xml");
myPrefs1.exportNode(out);
|络I/OQSocket→RMI
★Socket
Socket~程可能大家都很熟，所以就不多讨论?jin)，只是说通过socket把数据保存到q端服务器或从网lsocketd数据也不׃ؓ(f)一U值得考虑的方式?/P>
★RMI
RMI机制其实是RPCQ远E过E调用）(j)的Java版本Q它使用socket作ؓ(f)基本传输手段Q同时也是序列化最重要的一个应用。现在网l传输从~程的角度来看基本上都是以流的方式操作，socket是一个例子，对象{换成字节的一个重要目标就是ؓ(f)?jin)方便网l传输?BR> 惌一下传l的单机环境下的E序设计Q对于Java语言的函敎ͼҎ(gu)Q调用（注意与C语言函数调用的区别）(j)的参C递，?x)有两种情况Q如果是基本数据cdQ这U情况下和C语言是一L(fng)Q采用g递方式；如果是对象，则传递的是对象的引用Q包括返回g是引用，而不是一个完整的对象拯Q试想一下在不同的虚拟机之间q行Ҏ(gu)调用Q即使是两个完全同名同类型的对象他们也很可能是不同的引用Q此外对于方法调用过E，׃被调用过E的压栈Q内存“现场”完全被被调用者占有，当被调用Ҏ(gu)q回Ӟ才将调用者的地址写回到程序计数器QPCQ，恢复调用者的状态，如果是两个虚拟机Q根本不可能用简单压栈的方式来保存调用者的状态。因为种U原因，我们才需要徏立RMI通信实体之间的“代理”对象，譬如“存根”就相当于远E服务器对象在客h上的代理Qstub是q么来的Q当然这是后话了(jin)?BR> 本地对象与远E对象（未必是物理位|上的不同机器，只要不是在同一个虚拟机内皆为“远E”）(j)之间传递参数和q回|可能有这么几U情形：(x)
g递：(x)q又包括两种子情形：(x)如果是基本数据类型，那么都是“可序列化”的Q统l序列化成可传输的字节流Q如果是对象Q而且不是“远E对象”（所谓“远E对象”是实现?jin)java.rmi.Remote接口的对象）(j)Q本来对象传递的应该是引用，但由于上q原因，引用是不以证明对象w䆾的，所以传递的仍然是一个序列化的拷贝（当然q个对象也必L上q“可序列化”的条gQ?
引用传递：(x)可以引用传递的只能是“远E对象”。这里所谓的“引用”不要理解成?jin)真的只是一个符P它其实是一个留在（客户机）(j)本地stub中的Q和q端服务器上那个真实的对象张得一模一L(fng)镜像而已Q只是因为它有点“特权”（不需要经q序列化Q，在本地内存里已经有了(jin)一个实例，真正引用的其实是q个“孪生子”?BR>
由此可见Q序列化在RMI当中占有多么重要的地位?/P>
数据库I/OQCMP、Hibernate
★什么是“Persistence?BR> 用过VMWare的朋友大概都知道当一个guest OS正在q行的时候点几ZSuspend”将虚拟OS挂vQ它?x)把整个虚拟内存的内容保存到盘上，譬如你?f)虚拟OS分配?28M的运行内存，那挂起以后你?x)在虚拟OS所在的目录下找C个同h128M的文Ӟq就是虚拟OS内存的完整镜像！q种内存的镜像手D其实就是“Persistence”（持久化）(j)概念的由来?/P>
★CMP和Hibernate
因ؓ(f)我对J2EE的东西不是太熟?zhn)Q随便找?jin)点材料看看Q所以担?j)说的不CQ这ơ就不作具体ȝ?jin)，学?fn)……真是一件痛苦的事情
序列化再探讨
从以上技术的讨论中我们不难体?x)到Q序列化是Java之所以能够出色地实现光吹的两大卖点??分布式（distributedQ和跨^収ͼOS independentQ的一个重要基。TIJQ即“Thinking in Java”）(j)谈到I/OpȝӞ把序列化UCؓ(f)“lightweight persistence??“轻量的持久化”，q确实很有意思?/P>
★ؓ(f)什么叫做“序列”化Q?BR> 开场白里我说更?fn)惯于把“Serialization”称为“序列化”而不是“串行化”，q是有原因的。介l这个原因之前先回顾一些计机基本的知识，我们知道C计算机的内存I间都是U性编址的（什么是“线性”知道吧Q就是一个元素只有一个唯一的“前驱”和唯一的“后l”，当然头尾元素是个例外Q对于地址来说Q它的下一个地址当然不可能有两个Q否则就乱套?jin)?j)Q“地址”这个概忉|q到数据l构Q就相当于“指针”，q个在本U低q大概q道了(jin)。注意了(jin)Q既然是U性的Q那“地址”就可以看作是内存空间的“序号”，说明它的l织是有序的，“序号”或者说“序列号”正是“Serialization”机制的一U体现。ؓ(f)什么这么说呢？譬如我们有两个对象a和b,分别是类A和B的实例，它们都是可序列化的，而A和B都有一个类型ؓ(f)C的属性，Ҏ(gu)前面我们说过的原则，C当然也必L可序列化的?/P>
import java.io.*;
...
class A implements Serializable
{
C c;
...
}
class B implements Serializable
{
C c;
...
}
class C implements Serializable
{
...
}
A a;
B b;
C c1;
...
注意Q这里我们在实例化a和b的时候，有意让他们的c属性用同一个Ccd对象的引用，譬如c1Q那么请试想一下，但我们序列化a和b的时候，它们的c属性在外部字节（当然可以不仅仅是文gQ里保存的是一份拷贝还是两份拷贝呢Q序列化在这里用的是一U类g“指针”的Ҏ(gu)Q它为每个被序列化的对象标上一个“序列号”（serial numberQ，但序列化一个对象的时候，如果其某个属性对象是已经被序列化的，那么q里只向输出写入该属性的序列P从字节流恢复被序列化的对象时Q也Ҏ(gu)序列h到对应的来恢复。这是“序列化”名U的由来Q这里我们看到“序列化”和“指针”是极相似的Q只不过“指针”是内存I间的地址链，而序列化用的是外部流中的“序列号䏀?BR> 使用“序列号”而不是内存地址来标识一个被序列化的对象Q是因ؓ(f)从流中恢复对象到内存Q其地址可能未必是原来的地址??我们需要的只是q些对象之间的引用关p，而不是死板的原始位置Q这在RMI中就更是必要Q在两台不同的机器之间传递对象（）(j)Q根本就不可能指望它们在两台机器上都h相同的内存地址?
★更灉|的“序列化”：(x)transient属性和Externalizable
Serializable实很方便，方便C几乎不需要做M额外的工作就可以L内存中的对象保存到外部。但有两个问题得Serializable的威力收到束~：(x)
一个是效率问题Q《Core Java 2》中指出QSerializable使用pȝ默认的序列化机制?x)?jing)响Y件的q行速度Q因为需要ؓ(f)每个属性的引用~号和查P再加上I/O操作的时_(d)I/O和内存读写差的可是一个数量的大）(j)Q其代h(hun)当然是可观的?BR> 另一个困扰是“裸”的Serializable不可定制Q傻乎乎C么都l你序列化了(jin)Q不你是不是想q么做。其实你可以有至三U定制序列化的选择。其中一U前面已l提C(jin)Q就是在implements Serializable的类里面dU有的writeObject()和readObject()Ҏ(gu)Q这USerializable׃怺(jin)Q）(j)Q在q两个方法里Q该序列化什么，不该序列化什么，那就׃说了(jin)了(jin)Q你当然可以在这两个Ҏ(gu)体里面分别调用ObjectOutputStream.defaultWriteObject()和ObjectInputStream.defaultReadObject()仍然执行默认的序列化动作Q那你在代码上不做无用功了(jin)Q呵呵）(j)Q也可以用ObjectOutputStream.writeObject()和ObjectInputStream.readObject()Ҏ(gu)对你中意的属性进行序列化。但虚拟Z看到你定义了(jin)q两个方法，它就不再用默认的机制?jin)?BR> 如果仅仅Z(jin)跌某些属性不让它序列化，上面的动作似乎显得麻?ch)，更简单的Ҏ(gu)是对不想序列化的属性加上transient关键字，说明它是个“暂态变量”，默认序列化的时候就不会(x)把这些属性也塞到外部里?jin)。当?dng)你如果定义writeObject()和readObject()Ҏ(gu)的化Q仍然可以把暂态变量进行序列化。题外话Q像transient、violate、finallyq样的关键字初学者可能会(x)不太重视Q而现在有的公司招聘就偏偏喜欢问这L(fng)问题 :(
再一个方案就是不实现Serializable而改成实现Externalizable接口。我们研I一下这两个接口的源代码Q发现它们很cMQ甚臛_易淆。我们要C的是QExternalizable默认q不保存M对象相关信息QQ何保存和恢复对象的动作都是你自己定义的。Externalizable包含两个public的方法：(x)
public void writeExternal(ObjectOutput out) throws IOException;
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
乍一看这和上面的writeObject()和readObject()几乎差不多，但Serializable和Externalizable走的是两个不同的程QSerializable在对象不存在的情况下Q就可以仅凭外部的字节序列把整个对象重徏出来Q但Externalizable在重建对象时Q先是调用该cȝ默认构造函敎ͼ即不含参数的那个构造函敎ͼ(j)使得内存中先有这么一个实例，然后再调用readExternalҎ(gu)对实例中的属性进行恢复，因此Q如果默认构造函C和readExternalҎ(gu)中都没有赋值的那些属性，特别他们是非基本cd的话Q将?x)是I（nullQ。在q里需要注意的是，transient只能用在对Serializable而不是Externalizable的实现里面?
★序列化与克?BR> 从“可序列化”的递归定义来看Q一个序列化的对象貌似对象内存映象的外部克隆Q如果没有共享引用的属性的化，那么应该是一个深度克隆。关于克隆的话题有可以谈很多Q这里就不细说了(jin)Q有兴趣的话可以参考IBM developerWorks上的一文章：(x)JAVA中的指针,引用?qing)对象的clone
一点启C?/P>
作ؓ(f)一个实际的应用Q我在写那个易的邮g客户端JExp的时候曾l对比过好几U保存Message对象Q主要是几个关键属性和邮g的内容）(j)到本地的Ҏ(gu)Q譬如XML、Properties{，最后还是选择?jin)用序列化的方式Q因U方法最单， 大约可算是“学以致用”Ş。这里“存取程序状态”其实只是一个引子话题Ş?jin)，我想说的??如同前面我们讨论的关于logging的话题一??在Java面前对同一个问题你可以有很多种solutionQ熟(zhn)文件操作的Q你可能?x)觉得Properties、XML或Bean比较方便Q然后又发现?jin)还有Preferencesq么一个东东，大概又会(x)感慨“天外有天”了(jin)Q等C接触?jin)很多种新方法以后，l果又会(x)“殊途同归”，重新反省Serialization机制本n。这不仅是JavaQ科学也是同L(fng)道理?/P>
参考资?/P>
Core Java 2. by Cay S. Horstmann, Gary Cornell
J2SEq阶. by JavaResearch.org
Thinking in Java. by Bruce Eckel
J2SE 1.4.2 Documentation. by java.sun.com
Java Network Programming. by Elliotte R. Harold
Java分布式对象：(x)RMI和CORBA. by IBM developerWorks
]]>
3.传统的HTML文档序?document->html->(head,body)
4.一个浏览器H口中的DOM序?window->(navigator,screen,history,location,document)
5.得到表单中元素的名称和?document.getElementById("表单中元素的ID?).name(或value)
6.一个小写{大写的JS: document.getElementById("output").value = document.getElementById("input").value.toUpperCase();
7.JS中的值类?String,Number,Boolean,Null,Object,Function
8.JS中的字符型{换成数值型:parseInt(),parseFloat()
9.JS中的数字转换成字W型:(""+变量)
10.JS中的取字W串长度?(length)
11.JS中的字符与字W相q接使用+?
12.JS中的比较操作W有:=={于,!=不等?>,>=,<.<=
13.JS中声明变量?var来进行声?BR>14.JS中的判断语句l构:if(condition){}else{}
15.JS中的循环l构:for([initial expression];[condition];[upadte expression]) {inside loop}
16.循环中止的命令是:break
17.JS中的函数定义:function functionName([parameter],...){statement[s]}
18.当文件中出现多个form表单?可以用document.forms[0],document.forms[1]来代?
19.H口:打开H口window.open(), 关闭一个窗?window.close(), H口本n:self
20.状态栏的设|?window.status="字符";
21.弹出提示信息:window.alert("字符");
22.弹出认?window.confirm();
23.弹出输入提示?window.prompt();
24.指定当前昄链接的位|?window.location.href="URL"
25.取出H体中的所有表单的数量:document.forms.length
26.关闭文档的输出流:document.close();
27.字符串追加连接符:+=
28.创徏一个文档元?document.createElement(),document.createTextNode()
29.得到元素的方?document.getElementById()
30.讄表单中所有文本型的成员的gؓ(f)I?
var form = window.document.forms[0]
for (var i = 0; i<form.elements.length;i++){
if (form.elements.type == "text"){
form.elements.value = "";
}
}
31.复选按钮在JS中判断是否选中:document.forms[0].checkThis.checked (checked属性代表ؓ(f)是否选中q回TRUE或FALSE)
32.单选按钮组(单选按钮的名称必须相同):取单选按钮组的长度document.forms[0].groupName.length
33.单选按钮组判断是否被选中也是用checked.
34.下拉列表框的?document.forms[0].selectName.options[n].value (n有时用下拉列表框名称加上.selectedIndex来确定被选中的?
35.字符串的定义:var myString = new String("This is lightsword");
36.字符串{成大?string.toUpperCase(); 字符串{成小?string.toLowerCase();
37.q回字符?在字W串1中出现的位置:String1.indexOf("String2")!=-1则说明没扑ֈ.
38.取字W串中指定位|的一个字W?StringA.charAt(9);
39.取出字符串中指定L(fng)和终点的子字W串:stringA.substring(2,6);
40.数学函数:Math.PI(q回圆周?,Math.SQRT2(q回开?,Math.max(value1,value2)q回两个C的最在?Math.pow(value1,10)q回value1的十ơ方,Math.round(value1)四舍五入函数,Math.floor(Math.random()*(n+1))q回随机?BR>41.定义日期型变?var today = new Date();
42.日期函数列表:dateObj.getTime()得到旉,dateObj.getYear()得到q䆾,dateObj.getFullYear()得到四位的年?dateObj.getMonth()得到月䆾,dateObj.getDate()得到?dateObj.getDay()得到日期?dateObj.getHours()得到时,dateObj.getMinutes()得到?dateObj.getSeconds()得到U?dateObj.setTime(value)讄旉,dateObj.setYear(val)讄q?dateObj.setMonth(val)讄?dateObj.setDate(val)讄?dateObj.setDay(val)讄星期?dateObj.setHours讄时,dateObj.setMinutes(val)讄?dateObj.setSeconds(val)讄U?nbsp; [注意:此日期时间从0开始计]
43.FRAME的表C方? [window.]frames[n].ObjFuncVarName,frames["frameName"].ObjFuncVarName,frameName.ObjFuncVarName
44.parent代表父亲对象,top代表最端对象
45.打开子窗口的父窗口ؓ(f):opener
46.表示当前所属的位置:this
47.当在链接中调用JS函数时用:(javascript :)来开头后面加函数?BR>48.在老的览器中不执行此JS:<!-- //-->
49.引用一个文件式的JS:<script type="text/javascript" src="aaa.js"></script>
50.指定在不支持脚本的浏览器昄的HTML:<noscript></noscript>
51.当超铑֒onCLICK事g都有?则老版本的览器{向a.html,否则转向b.html.?<a href="a.html" onclick="location.href='b.html';return false">dfsadf</a>
52.JS的内建对象有:Array,Boolean,Date,Error,EvalError,Function,Math,Number,Object,RangeError,ReferenceError,RegExp,String,SyntaxError,TypeError,URIError
53.JS中的换行:\n
54.H口全屏大小:<script>function fullScreen(){ this.moveTo(0,0);this.outerWidth=screen.availWidth;this.outerHeight=screen.availHeight;}window.maximize=fullScreen;</script>
55.JS中的all代表其下层的全部元素
56.JS中的焦点序:document.getElementByid("表单元素").tabIndex = 1
57.innerHTML的值是表单元素的??lt;p id="para">"how are <em>you</em>"</p>,则innerHTML的值就?how are <em>you</em>
58.innerTEXT的值和上面的一?只不q不?x)?lt;em>q种标记昄出来.
59.contentEditable可设|元素是否可被修?isContentEditableq回是否可修改的状?
60.isDisabled判断是否为禁止状?disabled讄止状?BR>61.length取得长度,q回整型数?BR>62.addBehavior()是一UJS调用的外部函数文件其扩展名ؓ(f).htc
63.window.focus()使当前的H口在所有窗口之?
64.blur()指失ȝ?与FOCUS()相反.
65.select()指元素ؓ(f)选中状?
66.防止用户Ҏ(gu)本框中输入文?onfocus="this.blur()"
67.取出该元素在面中出现的数量:document.all.tags("div(或其它HTML标记W?").length
68.JS中分ZU窗体输?模态和非模?window.showModaldialog(),window.showModeless()
69.状态栏文字的设|?window.status='文字',默认的状态栏文字讄:window.defaultStatus = '文字.';
70.d到收藏夹:external.AddFavorite("http://www.dannyg.com";,"jaskdlf");
71.JS中遇到脚本错误时不做M操作:window.onerror = doNothing; 指定错误句柄的语法ؓ(f):window.onerror = handleError;
72.JS中指定当前打开H口的父H口:window.opener,支持opener.opener...的多重l?
73.JS中的self指的是当前的H口
74.JS中状态栏昄内容:window.status="内容"
75.JS中的top指的是框枉中最层的框?BR>76.JS中关闭当前的H口:window.close();
77.JS中提出是否确认的?if(confirm("Are you sure?")){alert("ok");}else{alert("Not Ok");}
78.JS中的H口重定?window.navigate("http://www.sina.com.cn";);
79.JS中的打印:window.print()
80.JS中的提示输入?window.prompt("message","defaultReply");
81.JS中的H口滚动?window.scroll(x,y)
82.JS中的H口滚动C|?window.scrollby
83.JS中设|时间间?setInterval("expr",msecDelay)或setInterval(funcRef,msecDelay)或setTimeout
84.JS中的模态显C在IE4+?在NN中不?showModalDialog("URL"[,arguments][,features]);
85.JS中的退Z前用的句柄:function verifyClose(){event.returnValue="we really like you and hope you will stay longer.";}} window.onbeforeunload=verifyClose;
86.当窗体第一ơ调用时使用的文件句?onload()
87.当窗体关闭时调用的文件句?onunload()
88.window.location的属? protocol(http:),hostname(www.example.com),port(80),host(www.example.com:80),pathname("/a/a.html"),hash("#giantGizmo",指蟩转到相应的锚?,href(全部的信?
89.window.location.reload()h当前面.
90.window.history.back()q回上一?window.history.forward()q回下一?window.history.go(q回W几?也可以用访问过的URL)
91.document.write()不换行的输出,document.writeln()换行输出
92.document.body.noWrap=true;防止链接文字折行.
93.变量?charAt(W几?,取该变量的第几位的字W?
94."abc".charCodeAt(W几?,q回W几个字W的ASCii码?
95.字符串连?string.concat(string2),或用+=q行q接
96.变量.indexOf("字符",起始位置),q回W一个出现的位置(?开始计?
97.string.lastIndexOf(searchString[,startIndex])最后一ơ出现的位置.
98.string.match(regExpression),判断字符是否匚w.
99.string.replace(regExpression,replaceString)替换现有字符?
100.string.split(分隔W?q回一个数l存储?
101.string.substr(start[,length])取从W几位到指定长度的字W串.
102.string.toLowerCase()使字W串全部变ؓ(f)写.
103.string.toUpperCase()使全部字W变为大?
104.parseInt(string[,radix(代表q制)])强制转换成整?
105.parseFloat(string[,radix])强制转换成Q点型.
106.isNaN(变量):试是否为数值型.
107.定义帔R的关键字:const,定义变量的关键字:var
]]>
Reflection ?nbsp;Java E序开发语a的特征之一Q它允许q行中的 Java E序对自w进行检查，或者说“自审”，q能直接操作E序的内部属性。例如，使用它能获得 Java cM各成员的名称q显C出来?BR>
Java 的这一能力在实际应用中也许用得不是很多Q但是在其它的程序设计语a中根本就不存在这一Ҏ(gu)。例如，Pascal、C 或?nbsp;C++ 中就没有办法在程序中获得函数定义相关的信息?BR>
JavaBean ?nbsp;reflection 的实际应用之一Q它能让一些工具可视化的操作Y件组件。这些工具通过 reflection 动态的载入q取?nbsp;Java lg(c? 的属性?BR>
1. 一个简单的例子
考虑下面q个单的例子Q让我们看看 reflection 是如何工作的?BR>
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
} catch (Throwable e) {
System.err.println(e);
}
}
}
按如下语句执行：(x)
java DumpMethods java.util.Stack
它的l果输出为：(x)
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)
q样列Z(jin)java.util.Stack cȝ各方法名以及(qing)它们的限制符和返回类型?BR>
q个E序使用 Class.forName 载入指定的类Q然后调?nbsp;getDeclaredMethods 来获取这个类中定义了(jin)的方法列表?FONT style="BACKGROUND-COLOR: #ffff00">java.lang.reflect.Methods 是用来描q某个类中单个方法的一个类?BR>
2.开始?nbsp;Reflection
用于 reflection 的类Q如 MethodQ可以在 java.lang.relfect 包中扑ֈ。用这些类的时候必要遵@三个步骤Q第一步是获得你想操作的类?nbsp;java.lang.Class 对象。在q行中的 Java E序中，?nbsp;java.lang.Class cL描述cd接口{?BR>
下面是获得一?nbsp;Class 对象的方法之一Q?BR>
Class c = Class.forName("java.lang.String");
q条语句得到一?nbsp;String cȝcd象。还有另一U方法，如下面的语句Q?BR>
Class c = int.class;
或?BR>
Class c = Integer.TYPE;
它们可获得基本类型的cM息。其中后一U方法中讉K的是基本cd的封装类 (?nbsp;Integer) 中预先定义好?nbsp;TYPE 字段?BR>
W二步是调用诸如 getDeclaredMethods 的方法，以取得该cM定义的所有方法的列表?BR>
一旦取得这个信息，可以进行第三步??使用 reflection API 来操作这些信息，如下面这D代码：(x)
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].toString());
它将以文本方式打印出 String 中定义的W一个方法的原型?BR>
在下面的例子中，q三个步骤将Z?nbsp;reflection 处理Ҏ(gu)应用E序提供例证?BR>
模拟 instanceof 操作W?BR>
得到cM息之后，通常下一个步骤就是解军_?nbsp;Class 对象的一些基本的问题。例如，Class.isInstance Ҏ(gu)可以用于模拟 instanceof 操作W：(x)
class A {
}
public class instance1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("A");
boolean b1 = cls.isInstance(new Integer(37));
System.out.println(b1);
boolean b2 = cls.isInstance(new A());
System.out.println(b2);
} catch (Throwable e) {
System.err.println(e);
}
}
}
在这个例子中创徏?jin)一?nbsp;A cȝ Class 对象Q然后检查一些对象是否是 A 的实例。Integer(37) 不是Q但 new A() 是?BR>
3.扑ևcȝҎ(gu)
扑և一个类中定义了(jin)些什么方法，q是一个非常有价g非常基础?nbsp;reflection 用法。下面的代码实C(jin)q一用法Q?BR>
import java.lang.reflect.*;
public class method1 {
private int f1(Object p, int x) throws NullPointerException {
if (p == null)
throw new NullPointerException();
return x;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method1");
Method methlist[] = cls.getDeclaredMethods();
for (int i = 0; i < methlist.length; i++) {
Method m = methlist[i];
System.out.println("name = " + m.getName());
System.out.println("decl class = " + m.getDeclaringClass());
Class pvec[] = m.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = m.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("return type = " + m.getReturnType());
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
q个E序首先取得 method1 cȝ描述Q然后调?nbsp;getDeclaredMethods 来获取一pd?nbsp;Method 对象Q它们分别描qC(jin)定义在类中的每一个方法，包括 public Ҏ(gu)、protected Ҏ(gu)、package Ҏ(gu)?nbsp;private Ҏ(gu){。如果你在程序中使用 getMethods 来代?nbsp;getDeclaredMethodsQ你q能获得l承来的各个Ҏ(gu)的信息?BR>
取得?nbsp;Method 对象列表之后Q要昄q些Ҏ(gu)的参数类型、异常类型和q回值类型等׃难了(jin)。这些类型是基本cdq是cȝ型，都可以由描述cȝ对象按顺序给出?BR>
输出的结果如下：(x)
name = f1
decl class = class method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----
name = main
decl class = class method1
param #0 class [Ljava.lang.String;
return type = void
-----
4.获取构造器信息
获取cL造器的用法与上述获取Ҏ(gu)的用法类|如：(x)
import java.lang.reflect.*;
public class constructor1 {
public constructor1() {
}
protected constructor1(int i, double d) {
}
public static void main(String args[]) {
try {
Class cls = Class.forName("constructor1");
Constructor ctorlist[] = cls.getDeclaredConstructors();
for (int i = 0; i < ctorlist.length; i++) {
Constructor ct = ctorlist[i];
System.out.println("name = " + ct.getName());
System.out.println("decl class = " + ct.getDeclaringClass());
Class pvec[] = ct.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = ct.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
q个例子中没能获得返回类型的相关信息Q那是因为构造器没有q回cd?BR>
q个E序q行的结果是Q?BR>
name = constructor1
decl class = class constructor1
-----
name = constructor1
decl class = class constructor1
param #0 int
param #1 double
-----
5.获取cȝ字段(?
扑և一个类中定义了(jin)哪些数据字段也是可能的，下面的代码就在干q个事情Q?BR>
import java.lang.reflect.*;
public class field1 {
private double d;
public static final int i = 37;
String s = "testing";
public static void main(String args[]) {
try {
Class cls = Class.forName("field1");
Field fieldlist[] = cls.getDeclaredFields();
for (int i = 0; i < fieldlist.length; i++) {
Field fld = fieldlist[i];
System.out.println("name = " + fld.getName());
System.out.println("decl class = " + fld.getDeclaringClass());
System.out.println("type = " + fld.getType());
int mod = fld.getModifiers();
System.out.println("modifiers = " + Modifier.toString(mod));
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
q个例子和前面那个例子非常相伹{例中用了(jin)一个新东西 ModifierQ它也是一?nbsp;reflection c，用来描述字段成员的修饰语Q如“private int”。这些修饰语自n由整数描qͼ而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描q?nbsp;(如“static”在“final”之?。这个程序的输出是：(x)
name = d
decl class = class field1
type = double
modifiers = private
-----
name = i
decl class = class field1
type = int
modifiers = public static final
-----
name = s
decl class = class field1
type = class java.lang.String
modifiers =
-----
和获取方法的情况一下，获取字段的时候也可以只取得在当前cMx?jin)的字段信?nbsp;(getDeclaredFields)Q或者也可以取得父类中定义的字段 (getFields) ?BR>
6.Ҏ(gu)Ҏ(gu)的名U来执行Ҏ(gu)
文本到这里，所丄例子无一例外都与如何获取cȝ信息有关。我们也可以?nbsp;reflection 来做一些其它的事情Q比如执行一个指定了(jin)名称的方法。下面的CZ演示?jin)这一操作Q?BR>
import java.lang.reflect.*;
public class method2 {
public int add(int a, int b) {
return a + b;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method meth = cls.getMethod("add", partypes);
method2 methobj = new method2();
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = meth.invoke(methobj, arglist);
Integer retval = (Integer) retobj;
System.out.println(retval.intvalue());
} catch (Throwable e) {
System.err.println(e);
}
}
}
假如一个程序在执行的某处的时候才知道需要执行某个方法，q个Ҏ(gu)的名U是在程序的q行q程中指定的 (例如QJavaBean 开发环境中׃(x)做这L(fng)?Q那么上面的E序演示?jin)如何做到?BR>
上例中，getMethod 用于查找一个具有两个整型参C名ؓ(f) add 的方法。找到该Ҏ(gu)q创Z(jin)相应?nbsp;Method 对象之后Q在正确的对象实例中执行它。执行该Ҏ(gu)的时候，需要提供一个参数列表，q在上例中是分别包装?jin)整?nbsp;37 ?nbsp;47 的两?nbsp;Integer 对象。执行方法的q回的同h一?nbsp;Integer 对象Q它?yu)装了(jin)返回?nbsp;84?BR>
7.创徏新的对象
对于构造器Q则不能像执行方法那栯行，因ؓ(f)执行一个构造器意味着创徏?jin)一个新的对?nbsp;(准确的说Q创Z个对象的q程包括分配内存和构造对?。所以，与上例最怼的例子如下：(x)
import java.lang.reflect.*;
public class constructor2 {
public constructor2() {
}
public constructor2(int a, int b) {
System.out.println("a = " + a + " b = " + b);
}
public static void main(String args[]) {
try {
Class cls = Class.forName("constructor2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Constructor ct = cls.getConstructor(partypes);
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = ct.newInstance(arglist);
} catch (Throwable e) {
System.err.println(e);
}
}
}
Ҏ(gu)指定的参数类型找到相应的构造函数ƈ执行它，以创Z个新的对象实例。用这U方法可以在E序q行时动态地创徏对象Q而不是在~译的时候创建对象，q一炚w常有价倹{?BR>
8.改变字段(?的?BR>
reflection 的还有一个用处就是改变对象数据字D늚倹{reflection 可以从正在运行的E序中根据名U找到对象的字段q改变它Q下面的例子可以说明q一点：(x)
import java.lang.reflect.*;
public class field2 {
public double d;
public static void main(String args[]) {
try {
Class cls = Class.forName("field2");
Field fld = cls.getField("d");
field2 f2obj = new field2();
System.out.println("d = " + f2obj.d);
fld.setDouble(f2obj, 12.34);
System.out.println("d = " + f2obj.d);
} catch (Throwable e) {
System.err.println(e);
}
}
}
q个例子中，字段 d 的D变ؓ(f)?nbsp;12.34?BR>
9.使用数组
本文介绍?nbsp;reflection 的最后一U用法是创徏的操作数l。数l在 Java 语言中是一U特D的cȝ型，一个数l的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：(x)
import java.lang.reflect.*;
public class array1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("java.lang.String");
Object arr = Array.newInstance(cls, 10);
Array.set(arr, 5, "this is a test");
String s = (String) Array.get(arr, 5);
System.out.println(s);
} catch (Throwable e) {
System.err.println(e);
}
}
}
例中创徏?nbsp;10 个单位长度的 String 数组Qؓ(f)W?nbsp;5 个位|的字符串赋?jin)|最后将q个字符串从数组中取得ƈ打印?jin)出来?BR>
下面q段代码提供?jin)一个更复杂的例子：(x)
import java.lang.reflect.*;
public class array2 {
public static void main(String args[]) {
int dims[] = new int[]{5, 10, 15};
Object arr = Array.newInstance(Integer.TYPE, dims);
Object arrobj = Array.get(arr, 3);
Class cls = arrobj.getClass().getComponentType();
System.out.println(cls);
arrobj = Array.get(arrobj, 5);
Array.setInt(arrobj, 10, 37);
int arrcast[][][] = (int[][][]) arr;
System.out.println(arrcast[3][5][10]);
}
}
例中创徏?jin)一?nbsp;5 x 10 x 15 的整型数l，qؓ(f)处于 [3][5][10] 的元素赋?jin)gؓ(f) 37。注意，多维数组实际上就是数l的数组Q例如，W一?nbsp;Array.get 之后Qarrobj 是一?nbsp;10 x 15 的数l。进而取得其中的一个元素，即长度ؓ(f) 15 的数l，q?nbsp;Array.setInt 为它的第 10 个元素赋倹{?BR>
注意创徏数组时的cd是动态的Q在~译时ƈ不知道其cd?/FONT>
]]>
1.对象的复?/H3>
复? 只复制复合对象本w?
深复? 除了(jin)复制复合对象本n, q复制了(jin)复合对象的引用的对象实例.
例如:
-
- class Pupil{
- public Pupil(String sno, String name, int age){
- this.sno = new String(sno);
- this.name = new String(name);
- this.age = age;
- }
-
- public String getSno() {
- return sno;
- }
-
- public String getName() {
- return name;
- }
-
- public int getAge() {
- return age;
- }
-
- public void setAge(int age) {
- this.age = age;
- }
-
- private String sno;
- private String name;
- private int age;
- }
-
- public class CopyDemo {
- public static Pupil[] shallowCopy(Pupil[] aClass) {
- Pupil[] newClass = new Pupil[aClass.length];
-
- //此时newClass 与aClass 指向同一块内?/FONT>
- for(int i=0; i<aClass.length; i++)
- newClass[i] = aClass[i];
- return newClass;
- }
-
- public static Pupil[] deepCopy(Pupil[] aClass) {
- Pupil[] newClass = new Pupil[aClass.length];
-
- //此时newClass 与aClass 的相应sno , name 指向同一块内?/FONT>
- for(int i=0; i<aClass.length; i++) {
- String sno = aClass[i].getSno();
- String name = aClass[i].getName();
- int age = aClass[i].getAge();
- newClass[i] = new Pupil(sno, name, age);
- }
-
- return newClass;
- }
-
- public static Pupil[] deeperCopy(Pupil[] aClass) {
- Pupil[] newClass = new Pupil[aClass.length];
-
- //完全的复?/FONT>
- for(int i=0; i<aClass.length; i++) {
- String sno = new String(aClass[i].getSno());
- String name = new String(aClass[i].getName());
- int age = aClass[i].getAge();
- newClass[i] = new Pupil(sno, name, age);
- }
-
- return newClass;
- }
- }
2.clone()的?/H3>
* Object.clone()
* Cloneable 接口
* CloneNotSupportedException
a. 使用Object.clone q行复制
两个必须条g:
1.一定要重定义后的clone() Ҏ(gu)定义为公有方?在Object cM, 它是受保护的成员, 不能直接使用)
2.该后代类声明实现接口 Cloneable 接口(当类实现该接? 其Q何子cM?x)承该接?, 该接口实际上没有M
内容, 只是一个标? 标志实现该接口的cL供clone() Ҏ(gu).(q是接口的一U非典型用法)
-
- public class Fraction implements Cloneable {
- public Object clone() {
- try{
- return super.clone(); //call protected method
- } catch (CloneNotSupportedException e) {
- return null;
- }
- }
- //other methods ...
- }
b.重写Object.clone()
例如?nbsp; private char[] cb; character buffer q行复制
- // add in class Cirbuf
- public Object clone() {
- try{
- Cirbuf copy = (Cirbuf)super.clone();
- copy.cb = (char[])cb.clone();
- return copy;
- }catch (CloneNotSupportedException e){
- throw new InternalError(e.toString());
- }
- }
c.复制数组
数组是在Ҏ(gu)调用重以引用的Ş式传递的对象. 下述情况下非帔R合引用来传递数l?
*正在接收的方法不修改数组
*正在调用的方法不必关?j)是否修?gu)l?BR> *正在调用的方法想要得到数l中的修改结?nbsp;
否则, 应该在Ҏ(gu)调用中传递数l对象的副本. 只需调用 arrObj.clone() Ҏ(gu)卛_完成数组arrObj 的复制操? 随后该数组副本强制转换为其正确cd:
(type[])arrObj.clone();
System.arraycopy Ҏ(gu)提供一U用于在数组间复制多个元素的有效方式.
System.arraycopy(source, i, target, j, len)
3.对象实例的比?/H3>
例如:
-
- Pupil p1 = new Pupil("99184001", "zhang3", 18);
- Pupil p2 = new Pupil("99184001", "zhang3", 18);
a. "=="
if(p1 == p2)...
此次试的是对象引用, 其结果肯定是false, 只要两个对象引用不是互ؓ(f)别名׃?x)相{?
b. 比?nbsp; false
-
- if(p1.getSno() == p2.getSno() && p1.getName() == p2.getName()
- && p1.getAge() == p2.getAge()) ...;
c. 深比?nbsp; true[/code]
if(p1.getSno().equals(p2.getSno()) && p1.getName().equals(p2.getName())
&& p1.getAge() == p2.getAge()) ...;[/code]
JAVA API 的跟cObject 也提供了(jin)equals() Ҏ(gu), 但它只是比较两个对象引用, 而非比较两个对象实例.
不管怎样, 如果需要比较Pupil cȝ对象(例如要将它们攑օ对象容器), 应该为Pupil c重定义equals() Ҏ(gu):
-
- public boolean equals(Object otherobj) {
- //(g)查otherobj 是否为空
- if(otherobj == null) return false;
-
- //(g)查otherobj 是否是当前对象
- if(otherobj == this) return true;
-
- //(g)查otherobj 是否h正确的类? x查是否可与当前对象比?/FONT>
- if(!(otherobj instanceof Pupil)) return false;
-
- //otherobj 转换为Pupil cȝ对象引用
- Pupil tmpObj = (Pupil)otherobj;
- //关于学生是否相等的逻辑(g)?/FONT>
- if(sno.equals(tmpObj.sno) && name.equals(tmpObj.name)
- && age == tmpObj.age) return true;
-
- return false;
- }
JAVA API 所提供的每个类几乎都提供了(jin)采用深比较策略的equals() Ҏ(gu), 例如String cequals() Ҏ(gu). 一般来? 用户自己定义的类也应当提供合适的equals() Ҏ(gu), 特别是当E序要将其对象放入JAVA API 所提供的对象容器类的时?
按照U定, McL提供的equals() Ҏ(gu)所实现的相{比较应该是{h(hun)关系, x反? 对称性和传递? 另外一个类重定义了(jin)equals() Ҏ(gu), 也应该重定义相应hashCode() Ҏ(gu), 否则这个类的对象放入映对象容器时也会(x)发生以外.
]]>
- class Pupil{
- public Pupil(String sno, String name, int age){
- this.sno = new String(sno);
- this.name = new String(name);
- this.age = age;
- }
- public String getSno() {
- return sno;
- }
- public String getName() {
- return name;
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- private String sno;
- private String name;
- private int age;
- }
- public class CopyDemo {
- public static Pupil[] shallowCopy(Pupil[] aClass) {
- Pupil[] newClass = new Pupil[aClass.length];
- //此时newClass 与aClass 指向同一块内?/FONT>
- for(int i=0; i<aClass.length; i++)
- newClass[i] = aClass[i];
- return newClass;
- }
- public static Pupil[] deepCopy(Pupil[] aClass) {
- Pupil[] newClass = new Pupil[aClass.length];
- //此时newClass 与aClass 的相应sno , name 指向同一块内?/FONT>
- for(int i=0; i<aClass.length; i++) {
- String sno = aClass[i].getSno();
- String name = aClass[i].getName();
- int age = aClass[i].getAge();
- newClass[i] = new Pupil(sno, name, age);
- }
- return newClass;
- }
- public static Pupil[] deeperCopy(Pupil[] aClass) {
- Pupil[] newClass = new Pupil[aClass.length];
- //完全的复?/FONT>
- for(int i=0; i<aClass.length; i++) {
- String sno = new String(aClass[i].getSno());
- String name = new String(aClass[i].getName());
- int age = aClass[i].getAge();
- newClass[i] = new Pupil(sno, name, age);
- }
- return newClass;
- }
- }
* Object.clone()
* Cloneable 接口
* CloneNotSupportedException
a. 使用Object.clone q行复制
两个必须条g:
1.一定要重定义后的clone() Ҏ(gu)定义为公有方?在Object cM, 它是受保护的成员, 不能直接使用)
2.该后代类声明实现接口 Cloneable 接口(当类实现该接? 其Q何子cM?x)承该接?, 该接口实际上没有M
内容, 只是一个标? 标志实现该接口的cL供clone() Ҏ(gu).(q是接口的一U非典型用法)
- public class Fraction implements Cloneable {
- public Object clone() {
- try{
- return super.clone(); //call protected method
- } catch (CloneNotSupportedException e) {
- return null;
- }
- }
- //other methods ...
- }
b.重写Object.clone()
例如?nbsp; private char[] cb; character buffer q行复制
- // add in class Cirbuf
- public Object clone() {
- try{
- Cirbuf copy = (Cirbuf)super.clone();
- copy.cb = (char[])cb.clone();
- return copy;
- }catch (CloneNotSupportedException e){
- throw new InternalError(e.toString());
- }
- }
c.复制数组
数组是在Ҏ(gu)调用重以引用的Ş式传递的对象. 下述情况下非帔R合引用来传递数l?
*正在接收的方法不修改数组
*正在调用的方法不必关?j)是否修?gu)l?BR> *正在调用的方法想要得到数l中的修改结?nbsp;
否则, 应该在Ҏ(gu)调用中传递数l对象的副本. 只需调用 arrObj.clone() Ҏ(gu)卛_完成数组arrObj 的复制操? 随后该数组副本强制转换为其正确cd:
(type[])arrObj.clone();
System.arraycopy Ҏ(gu)提供一U用于在数组间复制多个元素的有效方式.
System.arraycopy(source, i, target, j, len)
3.对象实例的比?/H3>
例如:
-
- Pupil p1 = new Pupil("99184001", "zhang3", 18);
- Pupil p2 = new Pupil("99184001", "zhang3", 18);
a. "=="
if(p1 == p2)...
此次试的是对象引用, 其结果肯定是false, 只要两个对象引用不是互ؓ(f)别名׃?x)相{?
b. 比?nbsp; false
-
- if(p1.getSno() == p2.getSno() && p1.getName() == p2.getName()
- && p1.getAge() == p2.getAge()) ...;
c. 深比?nbsp; true[/code]
if(p1.getSno().equals(p2.getSno()) && p1.getName().equals(p2.getName())
&& p1.getAge() == p2.getAge()) ...;[/code]
JAVA API 的跟cObject 也提供了(jin)equals() Ҏ(gu), 但它只是比较两个对象引用, 而非比较两个对象实例.
不管怎样, 如果需要比较Pupil cȝ对象(例如要将它们攑օ对象容器), 应该为Pupil c重定义equals() Ҏ(gu):
-
- public boolean equals(Object otherobj) {
- //(g)查otherobj 是否为空
- if(otherobj == null) return false;
-
- //(g)查otherobj 是否是当前对象
- if(otherobj == this) return true;
-
- //(g)查otherobj 是否h正确的类? x查是否可与当前对象比?/FONT>
- if(!(otherobj instanceof Pupil)) return false;
-
- //otherobj 转换为Pupil cȝ对象引用
- Pupil tmpObj = (Pupil)otherobj;
- //关于学生是否相等的逻辑(g)?/FONT>
- if(sno.equals(tmpObj.sno) && name.equals(tmpObj.name)
- && age == tmpObj.age) return true;
-
- return false;
- }
JAVA API 所提供的每个类几乎都提供了(jin)采用深比较策略的equals() Ҏ(gu), 例如String cequals() Ҏ(gu). 一般来? 用户自己定义的类也应当提供合适的equals() Ҏ(gu), 特别是当E序要将其对象放入JAVA API 所提供的对象容器类的时?
按照U定, McL提供的equals() Ҏ(gu)所实现的相{比较应该是{h(hun)关系, x反? 对称性和传递? 另外一个类重定义了(jin)equals() Ҏ(gu), 也应该重定义相应hashCode() Ҏ(gu), 否则这个类的对象放入映对象容器时也会(x)发生以外.
]]>
- Pupil p1 = new Pupil("99184001", "zhang3", 18);
- Pupil p2 = new Pupil("99184001", "zhang3", 18);
- if(p1.getSno() == p2.getSno() && p1.getName() == p2.getName()
- && p1.getAge() == p2.getAge()) ...;
- public boolean equals(Object otherobj) {
- //(g)查otherobj 是否为空
- if(otherobj == null) return false;
- //(g)查otherobj 是否是当前对象
- if(otherobj == this) return true;
- //(g)查otherobj 是否h正确的类? x查是否可与当前对象比?/FONT>
- if(!(otherobj instanceof Pupil)) return false;
- //otherobj 转换为Pupil cȝ对象引用
- Pupil tmpObj = (Pupil)otherobj;
- //关于学生是否相等的逻辑(g)?/FONT>
- if(sno.equals(tmpObj.sno) && name.equals(tmpObj.name)
- && age == tmpObj.age) return true;
- return false;
- }
Java反射机制
摘要
Reflection 是Java被视为动态（或准动态）(j)语言的一个关键性质。这个机制允许程序在q行?BR>透过Reflection APIs取得M一个已知名U的class的内部信息，包括其modifiersQ诸?BR>public, static {等Q、superclassQ例如ObjectQ、实CinterfacesQ例?BR>CloneableQ，也包括fields和methods的所有信息，q可于运行时改变fields内容或唤?BR>methods。本文借由实例Q大面积CReflection APIs?BR>关于本文Q?BR>读者基Q具备Java 语言基础?BR>本文适用工具QJDK1.5
关键词：(x)
IntrospectionQ内省、内观）(j)
ReflectionQ反）(j)
有时候我们说某个语言h很强的动态性，有时候我们会(x)区分动态和?rn)态的不同技术与作法。我?BR>朗朗上口动态绑定（dynamic bindingQ、动态链接（dynamic linkingQ、动态加?BR>Qdynamic loadingQ等。然而“动态”一词其实没有绝对而普遍适用的严格定义，有时候甚?BR>像对象导向当初被导入~程领域一P一Z把号Q各吹各的调?BR>一般而言Q开发者社说到动态语aQ大致认同的一个定义是Q“程序运行时Q允许改变程序结?BR>或变量类型，q种语言UCؓ(f)动态语a”。从q个观点看，PerlQPythonQRuby是动态语aQC+
+QJavaQC#不是动态语a?BR>管在这L(fng)定义与分cMJava不是动态语aQ它却有着一个非常突出的动态相xӞ(x)
Reflection。这个字的意思是“反、映象、倒媄(jing)”，用在Javaw上指的是我们可以于q行时加
载、探知、用编译期间完全未知的classes。换句话_(d)JavaE序可以加蝲一个运行时才得知名
U的classQ获(zhn)其完整构造（但不包括methods定义Q，q生成其对象实体、或对其fields?BR>倹{或唤v其methods1。这U“看透class”的能力Qthe ability of the program to
examine itselfQ被UCؓ(f)introspectionQ内省、内观、反省）(j)。Reflection?BR>introspection是常被ƈ提的两个术语?BR>Java如何能够做出上述的动态特性呢Q这是一个深q话题，本文Ҏ(gu)只简单介l一些概c(din)整个篇
q最主要q是介绍Reflection APIsQ也是让读者知道如何探索class的结构、如何对?BR>个“运行时才获知名U的class”生成一份实体、ؓ(f)其fields讑ր{调用其methods。本文将谈到
file:///H|/download/806.htmlQ第 1Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
java.lang.ClassQ以?qing)java.lang.reflect中的Method、Field、Constructor{等
classes?BR>“Class”class
众所周知Java有个Object classQ是所有Java classes的承根源，其内声明?jin)数个应该在所
有Java class中被改写的methodsQhashCode()、equals()、clone()、toString()?BR>getClass(){。其中getClass()q回一个Class object?BR>Class class十分Ҏ(gu)。它和一般classes一L(fng)承自ObjectQ其实体用以表达JavaE序q行?BR>的classes和interfacesQ也用来表达enum、array、primitive Java types
Qboolean, byte, char, short, int, long, float, doubleQ以?qing)关键词void。当一
个class被加载，或当加蝲器（class loaderQ的defineClass()被JVM调用QJVM 便自动
生一个Class object。如果?zhn)惛_由“修改Java标准库源码”来观察Class object的实际生?BR>时机Q例如在Class的constructor内添加一个println()Q，不能够！因ؓ(f)Classq没?BR>public constructorQ见?Q。本文最后我?x)拨一块幅带谈谈Java标准库源码的改动?BR>法?BR>Class是Reflection故事h。针对Q何?zhn)x勘的classQ唯有先为它产生一个Class
objectQ接下来才能l由后者唤起ؓ(f)数十多个的Reflection APIs。这些APIs在E后的探?BR>zd中一一亮相?BR>#001 public final
#002 class Class<T> implements java.io.Serializable,
#003 java.lang.reflect.GenericDeclaration,
#004 java.lang.reflect.Type,
#005 java.lang.reflect.AnnotatedElement {
#006 private Class() {}
#007 public String toString() {
#008 return ( isInterface() ? "interface " :
#009 (isPrimitive() ? "" : "class "))
#010 + getName();
#011 }
...
?QClass class片段。注意它的private empty ctorQ意指不允许M人经qE方式生Class object。是的，其object 只能?BR>JVM 产生?BR>“Class?nbsp;object的取得途径
Java允许我们从多U管道ؓ(f)一个class生成对应的Class object。图2是一份整理?BR>Class object 诞生道CZ
q用getClass()
注：(x)每个class 都有此函?BR>String str = "abc";
Class c1 = str.getClass();
file:///H|/download/806.htmlQ第 2Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
q用
Class.getSuperclass()2
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
q用static method
Class.forName()
Q最常被使用Q?BR>Class c1 = Class.forName ("java.lang.
String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.
LinkedList$Entry");
Class c4 = Class.forName ("I");
Class c5 = Class.forName ("[I");
q用
.class 语法
Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
q用
primitive wrapper
classes
的TYPE 语法
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;
?QJava 允许多种道生成Class object?BR>Java classes l成分析
首先Ҏ(gu)以图3的java.util.LinkedListZQ将Java class的定义大卸八块，每一块分别对
应图4所C的Reflection API。图5则是“获得class各区块信息”的E序CZ?qing)执行结果，它?BR>都取自本文示例程序的对应片段?BR>package java.util; //(1)
import java.lang.*; //(2)
public class LinkedList<E> //(3)(4)(5)
extends AbstractSequentialList<E> //(6)
implements List<E>, Queue<E>,
Cloneable, java.io.Serializable //(7)
{
private static class Entry<E> { ?nbsp;}//(8)
public LinkedList() { ?nbsp;} //(9)
public LinkedList(Collection<? extends E> c) { ?nbsp;}
public E getFirst() { ?nbsp;} //(10)
public E getLast() { ?nbsp;}
private transient Entry<E> header = ? //(11)
private transient int size = 0;
}
file:///H|/download/806.htmlQ第 3Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
?Q将一个Java class 大卸八块Q每块相应于一个或一lReflection APIsQ图4Q?BR>Java classes 各成份所对应的Reflection APIs
?的各个Java class成䆾Q分别对应于?的Reflection APIQ其中出现的Package?BR>Method、Constructor、Field{等classesQ都定义于java.lang.reflect?BR>Java class ?BR>部模块（参见?BR>3Q?BR>Java class 内部模块说明相应之Reflection
APIQ多半ؓ(f)Class
methods?BR>q回值类?BR>(return type)
(1) package class隶属哪个package getPackage() Package
(2) import class导入哪些classes 无直接对应之API?BR>解决办法见图5-2?BR>(3) modifier classQ或methods,
fieldsQ的属?BR>int getModifiers()
Modifier.toString
(int)
Modifier.
isInterface(int)
int
String
bool
(4) class
name or
interface
name
class/interface 名称getName() String
(5) type
parameters
参数化类型的名称getTypeParameters
()
TypeVariable
<Class>[]
(6) base
class
base classQ只可能一个）(j) getSuperClass() Class
(7)
implemented
interfaces
实现有哪些interfaces getInterfaces() Class[]
(8) inner
classes
内部classes getDeclaredClasses
()
Class[]
(8') outer
class
如果我们观察的class 本n?BR>inner classesQ那么相对它
׃(x)有个outer class?BR>getDeclaringClass() Class
(9)
constructors
构造函?BR>getDeclaredConstructors
()
不论 public ?BR>private 或其?BR>access levelQ皆可获
得。另有功能近g取得
函数?BR>Constructor[]
file:///H|/download/806.htmlQ第 4Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
(10) methods 操作函数
getDeclaredMethods()
不论 public ?BR>private 或其?BR>access levelQ皆可获
得。另有功能近g取得
函数?BR>Method[]
(11) fields 字段Q成员变量）(j) getDeclaredFields()
不论 public ?BR>private 或其?BR>access levelQ皆可获
得。另有功能近g取得
函数?BR>Field[]
?QJava class大卸八块后（如图3Q，每一块所对应的Reflection API。本表ƈ?BR>Reflection APIs 的全部?BR>Java Reflection API q用CZ
?C?提过的每一个Reflection APIQ及(qing)其执行结果。程序中出现的tName()是个辅助?BR>敎ͼ可将其第一自变量所代表的“Java class完整路径字符东y(c)剥除\径部分，留下class?BR>Uͼ储存到第二自变量所代表的一个hashtabledƈq回Q如果第二自变量为nullQ就不储存而只
是返回）(j)?BR>#001 Class c = null;
#002 c = Class.forName(args[0]);
#003
#004 Package p;
#005 p = c.getPackage();
#006
#007 if (p != null)
#008 System.out.println("package "+p.getName()+";");
执行l果Q例Q：(x)
package java.util;
?-1Q找出class 隶属的package。其中的cl沿用于以下各程序片Dc(din)?BR>#001 ff = c.getDeclaredFields();
#002 for (int i = 0; i < ff.length; i++)
#003 x = tName(ff[i].getType().getName(), classRef);
#004
#005 cn = c.getDeclaredConstructors();
#006 for (int i = 0; i < cn.length; i++) {
#007 Class cx[] = cn[i].getParameterTypes();
#008 for (int j = 0; j < cx.length; j++)
#009 x = tName(cx[j].getName(), classRef);
#010 }
#011
#012 mm = c.getDeclaredMethods();
#013 for (int i = 0; i < mm.length; i++) {
#014 x = tName(mm[i].getReturnType().getName(), classRef);
#015 Class cx[] = mm[i].getParameterTypes();
file:///H|/download/806.htmlQ第 5Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
#016 for (int j = 0; j < cx.length; j++)
#017 x = tName(cx[j].getName(), classRef);
#018 }
#019 classRef.remove(c.getName()); //不必记录自己Q不需import 自己Q?BR>执行l果Q例Q：(x)
import java.util.ListIterator;
import java.lang.Object;
import java.util.LinkedList$Entry;
import java.util.Collection;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
?-2Q找出导入的classesQ动作细节详见内文说明?BR>#001 int mod = c.getModifiers();
#002 System.out.print(Modifier.toString(mod)); //整个modifier
#003
#004 if (Modifier.isInterface(mod))
#005 System.out.print(" "); //关键?nbsp;"interface" 已含于modifier
#006 else
#007 System.out.print(" class "); //关键?nbsp;"class"
#008 System.out.print(tName(c.getName(), null)); //class 名称
执行l果Q例Q：(x)
public class LinkedList
?-3Q找出class或interface 的名Uͼ?qing)其属性（modifiersQ?BR>#001 TypeVariable<Class>[] tv;
#002 tv = c.getTypeParameters(); //warning: unchecked conversion
#003 for (int i = 0; i < tv.length; i++) {
#004 x = tName(tv[i].getName(), null); //例如 E,K,V...
#005 if (i == 0) //W一?BR>#006 System.out.print("<" + x);
#007 else //非第一?BR>#008 System.out.print("," + x);
#009 if (i == tv.length-1) //最后一?BR>#010 System.out.println(">");
#011 }
执行l果Q例Q：(x)
public abstract interface Map<K,V>
?nbsp;public class LinkedList<E>
?-4Q找出parameterized types 的名U?BR>#001 Class supClass;
#002 supClass = c.getSuperclass();
#003 if (supClass != null) //如果有super class
#004 System.out.print(" extends" +
#005 tName(supClass.getName(),classRef));
执行l果Q例Q：(x)
public class LinkedList<E>
extends AbstractSequentialList,
file:///H|/download/806.htmlQ第 6Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
?-5Q找出base class。执行结果多Z个不该有的逗号于尾端。此非本处重点，为简化计Q不多做处理?BR>#001 Class cc[];
#002 Class ctmp;
#003 //扑և所有被实现的interfaces
#004 cc = c.getInterfaces();
#005 if (cc.length != 0)
#006 System.out.print(", \r\n" + " implements "); //关键?BR>#007 for (Class cite : cc) //JDK1.5 新式循环写法
#008 System.out.print(tName(cite.getName(), null)+", ");
执行l果Q例Q：(x)
public class LinkedList<E>
extends AbstractSequentialList,
implements List, Queue, Cloneable, Serializable,
?-6Q找出implemented interfaces。执行结果多Z个不该有的逗号于尾端。此非本处重点，为简化计Q不多做?BR>理?BR>#001 cc = c.getDeclaredClasses(); //扑ևinner classes
#002 for (Class cite : cc)
#003 System.out.println(tName(cite.getName(), null));
#004
#005 ctmp = c.getDeclaringClass(); //扑ևouter classes
#006 if (ctmp != null)
#007 System.out.println(ctmp.getName());
执行l果Q例Q：(x)
LinkedList$Entry
LinkedList$ListItr
?-7Q找出inner classes 和outer class
#001 Constructor cn[];
#002 cn = c.getDeclaredConstructors();
#003 for (int i = 0; i < cn.length; i++) {
#004 int md = cn[i].getModifiers();
#005 System.out.print(" " + Modifier.toString(md) + " " +
#006 cn[i].getName());
#007 Class cx[] = cn[i].getParameterTypes();
#008 System.out.print("(");
#009 for (int j = 0; j < cx.length; j++) {
#010 System.out.print(tName(cx[j].getName(), null));
#011 if (j < (cx.length - 1)) System.out.print(", ");
#012 }
#013 System.out.print(")");
#014 }
执行l果Q例Q：(x)
public java.util.LinkedList(Collection)
public java.util.LinkedList()
?-8aQ找出所有constructors
#004 System.out.println(cn[i].toGenericString());
执行l果Q例Q：(x)
file:///H|/download/806.htmlQ第 7Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
public java.util.LinkedList(java.util.Collection<? extends E>)
public java.util.LinkedList()
?-8bQ找出所有constructors。本例在for 循环内用toGenericString()Q省事?BR>#001 Method mm[];
#002 mm = c.getDeclaredMethods();
#003 for (int i = 0; i < mm.length; i++) {
#004 int md = mm[i].getModifiers();
#005 System.out.print(" "+Modifier.toString(md)+" "+
#006 tName(mm[i].getReturnType().getName(), null)+" "+
#007 mm[i].getName());
#008 Class cx[] = mm[i].getParameterTypes();
#009 System.out.print("(");
#010 for (int j = 0; j < cx.length; j++) {
#011 System.out.print(tName(cx[j].getName(), null));
#012 if (j < (cx.length - 1)) System.out.print(", ");
#013 }
#014 System.out.print(")");
#015 }
执行l果Q例Q：(x)
public Object get(int)
public int size()
?-9aQ找出所有methods
#004 System.out.println(mm[i].toGenericString());
public E java.util.LinkedList.get(int)
public int java.util.LinkedList.size()
?-9bQ找出所有methods。本例在for 循环内用toGenericString()Q省事?BR>#001 Field ff[];
#002 ff = c.getDeclaredFields();
#003 for (int i = 0; i < ff.length; i++) {
#004 int md = ff[i].getModifiers();
#005 System.out.println(" "+Modifier.toString(md)+" "+
#006 tName(ff[i].getType().getName(), null) +" "+
#007 ff[i].getName()+";");
#008 }
执行l果Q例Q：(x)
private transient LinkedList$Entry header;
private transient int size;
?-10aQ找出所有fields
#004 System.out.println("G: " + ff[i].toGenericString());
private transient java.util.LinkedList.java.util.LinkedList$Entry<E> ??
java.util.LinkedList.header
private transient int java.util.LinkedList.size
?-10bQ找出所有fields。本例在for 循环内用toGenericString()Q省事?BR>扑ևclass参用Q导入）(j)的所有classes
file:///H|/download/806.htmlQ第 8Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
没有直接可用的Reflection API可以为我们找出某个class参用的所有其它classes。要获得q?BR>信息，必须做苦工，一步一脚印逐一记录。我们必观察所有fields的类型、所有methodsQ包
括constructorsQ的参数cd和回q类型，剔除重复Q留下唯一。这正是Z么图5-2E序代码
要ؓ(f)tName()指定一个hashtableQ而非一个nullQ做为第二自变量的缘故：(x)hashtable可ؓ(f)?BR>们储存元素（本例为字W串Q，又保证不重复?BR>本文讨论xQ几乎可以还原一个class的原貌（唯有methods 和ctors的定义无法取得）(j)。接?BR>来讨论Reflection 的另三个动态性质Q?1) q行时生成instancesQ?2) ?BR>行期唤vmethodsQ?3) q行时改动fields?BR>q行时生成instances
Ʋ生成对象实体，在Reflection 动态机制中有两U作法，一个针对“无自变量ctor”，
一个针对“带参数ctor”。图6是面对“无自变量ctor”的例子。如果欲调用的是“带参数
ctor“就比较ȝ(ch)些，?是个例子Q其中不再调用Class的newInstance()Q而是调用
Constructor 的newInstance()。图7首先准备一个Class[]做ؓ(f)ctor的参数类型（本例指定
Z个double和一个intQ，然后以此变量调用getConstructor()Q获得一个专属ctor?BR>接下来再准备一个Object[] 做ؓ(f)ctor实参|本例指定3.14159?25Q，调用上述专属ctor
的newInstance()?BR>#001 Class c = Class.forName("DynTest");
#002 Object obj = null;
#003 obj = c.newInstance(); //不带自变?BR>#004 System.out.println(obj);
?Q动态生成“Class object 所对应之class”的对象实体Q无自变量?BR>#001 Class c = Class.forName("DynTest");
#002 Class[] pTypes = new Class[] { double.class, int.class };
#003 Constructor ctor = c.getConstructor(pTypes);
#004 //指定parameter listQ便可获得特定之ctor
#005
#006 Object obj = null;
#007 Object[] arg = new Object[] {3.14159, 125}; //自变?BR>#008 obj = ctor.newInstance(arg);
#009 System.out.println(obj);
?Q动态生成“Class object 对应之class”的对象实体Q自变量以Object[]表示?BR>q行时调用methods
q个动作和上q调用“带参数之ctor”相当类伹{首先准备一个Class[]做ؓ(f)ctor的参数类?BR>Q本例指定其中一个是StringQ另一个是HashtableQ，然后以此变量调用getMethod()Q?BR>获得特定的Method object。接下来准备一个Object[]攄自变量，然后调用上述所得之特定
Method object的invoke()Q如?。知道ؓ(f)什么烦(ch)取Method object时不需指定回返cd
吗？因ؓ(f)method overloading机制要求signatureQv名式Q必d一Q而回q类型ƈ?BR>signature的一个成份。换句话_(d)只要指定?jin)method名称和参数列Q就一定指Z(jin)一个独一?BR>二的method?BR>file:///H|/download/806.htmlQ第 9Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
#001 public String func(String s, Hashtable ht)
#002 {
#003 …System.out.println("func invoked"); return s;
#004 }
#005 public static void main(String args[])
#006 {
#007 Class c = Class.forName("Test");
#008 Class ptypes[] = new Class[2];
#009 ptypes[0] = Class.forName("java.lang.String");
#010 ptypes[1] = Class.forName("java.util.Hashtable");
#011 Method m = c.getMethod("func",ptypes);
#012 Test obj = new Test();
#013 Object args[] = new Object[2];
#014 arg[0] = new String("Hello,world");
#015 arg[1] = null;
#016 Object r = m.invoke(obj, arg);
#017 Integer rval = (String)r;
#018 System.out.println(rval);
#019 }
?Q动态唤起method
q行时变更fields内容
与先前两个动作相比，“变更field内容”轻村֤?jin)，因?f)它不需要参数和自变量。首先调?BR>Class的getField()q指定field名称。获得特定的Field object之后便可直接调用Field?BR>get()和set()Q如??BR>#001 public class Test {
#002 public double d;
#003
#004 public static void main(String args[])
#005 {
#006 Class c = Class.forName("Test");
#007 Field f = c.getField("d"); //指定field 名称
#008 Test obj = new Test();
#009 System.out.println("d= " + (Double)f.get(obj));
#010 f.set(obj, 12.34);
#011 System.out.println("d= " + obj.d);
#012 }
#013 }
?Q动态变更field 内容
Java 源码改动办法
先前我曾提到Q原本想借由“改动Java标准库源码”来知Class object的生成，但由于其
ctor原始设计为privateQ也是说不可能透过q个道生成Class objectQ而是由class
loader负责生成Q，因此“在ctor中打印出某种信息”的企图也就失去?jin)意义?BR>q里我要谈点题外话：(x)如何修改Java标准库源码ƈ让它反应到我们的应用E序来。假设我想修?BR>java.lang.ClassQ让它在某些情况下打印某U信息。首先必L出标准源码！当你下蝲JDK ?BR>file:///H|/download/806.htmlQ第 10Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
件ƈ安装妥当Q你?x)发现jdk150\src\java\lang 目录Q见?0Q之中有Class.javaQ这是
我们此次行动的标准源码。备份后加以修改Q编译获得Class.class。接下来准备?class 搬移
到jdk150\jre\lib\endorsedQ见?0Q?BR>q是一个十分特别的目录Qclass loader优先从该处d内含classes?jar文g??成功?BR>条g?jar内的classes压羃路径必须和Java标准库的路径完全相同。ؓ(f)此，我们可以刚才做
出的Class.class先搬C个ؓ(f)此目的而刻意做出来的\java\lang目录中，压羃为foo.zipQQ
意命名，唯需夹带路径java\langQ，再将q个foo.zip搬到jdk150\jre\lib\endorsedq改
名ؓ(f)foo.jar。此后你的应用程序便?x)优先用上这里的java.lang.Class。整个过E可写成一?BR>批处理文Ӟbatch fileQ，如图11Q在DOS Box中用?BR>?0
?0QJDK1.5 安装后的目录l织。其中的endorsed 是我新徏?BR>del e:\java\lang\*.class //清理q净
del c:\jdk150\jre\lib\endorsed\foo.jar //清理q净
c:
cd c:\jdk150\src\java\lang
javac -Xlint:unchecked Class.java //~译源码
javac -Xlint:unchecked ClassLoader.java //~译另一个源码（如有必要Q?BR>move *.class e:\java\lang //搬移臛_意制造的目录?BR>e:
cd e:\java\lang //以下压羃至适当目录
pkzipc -add -path=root c:\jdk150\jre\lib\endorsed\foo.jar *.class
cd e:\test //q入试目录
javac -Xlint:unchecked Test.java //~译试E序
java Test //执行试E序
?1Q一个可在DOS Box中用的批处理文Ӟbatch fileQ，用以自动化java.lang.Class
的修改动作。Pkzipc(.exe)是个命o(h)列压~工Padd和path都是其命令?BR>更多信息
以下是视野所?qing)与本文主题相关的更多讨论。这些信息可以I补因文章幅限制而带来的不Q或
带给(zhn)更多视野?BR>l "Take an in-depth look at the Java Reflection API -- Learn about
the new Java 1.1 tools forfinding out information about classes", by
Chuck McManis。此文章所附程序代码是本文CZE序的主要依据（本文CZE序C?jin)?BR>多Reflection APIsQƈ采用JDK1.5 新式的for-loop 写法Q?BR>l "Take a look inside Java classes -- Learn to deduce properties of
a Java class from inside aJava program", by Chuck McManis?BR>l "The basics of Java class loaders -- The fundamentals of this key
component of the Javaarchitecture", by Chuck McManis?BR>l 《The Java Tutorial Continued? Sun microsystems. Lesson58-61,
"Reflection".
file:///H|/download/806.htmlQ第 11Q?2 ）(j)2005-9-8 12:03:22
侯捷观点??Java反射机制
?用过诸如MFCq类所?nbsp;Application Framework的程序员也许知道QMFC有所谓的
dynamic creation。但它ƈ不等同于Java的动态加载或动态L识；所有能够在MFCE序中v作用
的classesQ都必须先在~译期被~译器“看见”?BR>?如果操作对象是ObjectQClass.getSuperClass()?x)返回null?BR>本文E序源码可至侯捷|站下蝲Q?BR>http://www.jjhou.com/javatwo-2004-reflection-and-generics-in-jdk15-sample.ZIP
发表?nbsp;2004q?0?7?nbsp;11:30 AM
]]>
(Wang hailong)
关于~程的参C递问题，L存在着q样的争论。传|q是传引用？Q还是传指针Q还是传地址Q）(j)q些提法Q经常出现在C++, java, C#的编E技术文档里面。这个问题也l常引v开发h员的争论Q徒耗h力物力。实际上Q这Ҏ(gu)不成为问题，只是׃Zؓ(f)加入的概念，h?jin)h们的视听?/SPAN>
从程序运行的角度来看Q参C递，只有传|从不传递其它的东西。只不过Q?B style="mso-bidi-font-weight: normal">值的内容有可能是数据Q也有可能是一个内存地址?/SPAN>
开发h员应该了(jin)解程序的~译l果是怎样在计机中运行的。程序运行的时候，使用的空间可以分Z个部分，栈和堆。栈是指q行栈，局部变量，参数Q都分配在栈上。程序运行的时候，新生成的对象Q都分配在堆里，堆里分配的对象，栈里的数据参敎ͼ或局部变量?/FONT>
下面举一?/SPAN>C++的例子?/SPAN>
public class Object{
int i;
public Object(int i){
this.i = i;
}
public int getValue(){
return i;
}
public void setValue(int i){
this.i = i;
}
};
class A {
Void func1(int a, Object b){
Object * c = new Object( a );
b = c;
}
public void main(){
Object * param = new Object( 1 );
func1( 2, param )Q?/SPAN>
// what is value of parram now ?
// it is still 1.
}
};
我们来看一下，当调用到func1函数Ӟq行?/SPAN>Object * c = new Object( a ); 栈和堆的状态。不同编译器生成的代码运行的l果可能?x)稍有不同。但参数和局部变量的大致排放序都是相同的?/SPAN>
q时候，我们来看Q?/SPAN>param变量被压入运行栈的时候，只是q行?jin)简单的复制。把param里面的内Ҏ(gu)贝到b里面。这时候，b指向了(jin)Object(1)。这里的参数传递，是把param的g递给b?/SPAN>
下面我们来看Q程序执行到b = c;时候的堆栈状态?/SPAN>
我们可以看到Q?/SPAN>b现在指向?/SPAN>Object(2)。但是对param的值毫无媄(jing)响?/SPAN>param的D?/SPAN>Object(1)?/SPAN>
所以，我们_(d)对参数的赋g?x)?jing)响到外层函数的数据，但是Q调用参数的操作Ҏ(gu)Q却{于直接操作外层函数的数据。比如，如果我们?/SPAN>func1()函数中，不调?/SPAN>b=c;而调?/SPAN>b.setValue(3)Q那?/SPAN>Object(1)的数据就?x)变?/SPAN>3Q?/SPAN>param的数据也?x)改变?f)3?/SPAN>
?/SPAN>java?/SPAN>C#中的情况Q也都是一栗?/SPAN>
C++q有一U变量定义方法，表面上看hQ不W合上面的说明，q里q行说明?/SPAN>
Object * a = new Object(1);
Object & * b = a;
q里?/SPAN>bq于是a的另外一个别名，b是a。对b赋值就{于?/SPAN>a赋倹{甚至作为参C递时Q也是如此。对q种cd的参数的赋|q于对外层函数数据的赋倹{?/SPAN>
public class B{
void func1(Object & * b){
b = new Object(4);
}
public void main(){
Object * a = new Object(1);
func1(a);
// a is changed to Object(4) now.
}
}
当运行完func1(a);Ӟa的值变化ؓ(f)Object(4)。这是因为编译器实际把参?/SPAN>Object & * b~译?/SPAN>Object ** b_addrQ?/SPAN>b_addr的值是b的地址Q也是a的地址?/SPAN>
当调?/SPAN>func1()的时候，实际上是?/SPAN>b_addr作ؓ(f)参数压到栈里Q?/SPAN>b_addr的值是a的地址?/SPAN>
当执?/SPAN>b = new Object(4); Ӟ实际执行?/SPAN> b_addr->b = new Object(4); 也就是执行了(jin) b_addr->a = new Object(4); a的值当然变化了(jin)?/SPAN>
q有一炚w要说明，当?/SPAN>COMQ?/SPAN>CORBA{中间g规范q行开发时Q我们需要定?/SPAN>IDL语言。参数的cd分ؓ(f)Q?/SPAN>[in]Q?/SPAN>[out]Q?/SPAN>[in, out]Q其中的RPCq程调用的参数打包规范，更复杂?jin)，但原理却是一L(fng)?/SPAN>
]]>
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package myclass.test;
import java.awt.*;
import java.awt.image.*;
import java.util.*;
/**
* @author
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class Image {
public String sRand="";
public Color getRandColor(int fc,int bc){//l定范围获得随机颜色
Random random = new Random();
if(fc>255) fc=255;
if(bc>255) bc=255;
int r=fc+random.nextInt(bc-fc);
int g=fc+random.nextInt(bc-fc);
int b=fc+random.nextInt(bc-fc);
return new Color(r,g,b);
}
public BufferedImage creatImage(){
// 在内存中创徏图象
int width=60, height=20;
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
// 获取囑Ş上下?nbsp;
Graphics g = image.getGraphics();
//生成随机c?nbsp;
Random random = new Random();
// 讑֮背景?nbsp;
g.setColor(getRandColor(200,250));
g.fillRect(0, 0, width, height);
//讑֮字体
g.setFont(new Font("Times New Roman",Font.PLAIN,18));
//画边?nbsp;
//g.setColor(new Color());
//g.drawRect(0,0,width-1,height-1);
// 随机产生155条干扰线Q图象中的认证码不易被其它E序探测?nbsp;
g.setColor(getRandColor(160,200));
for (int i=0;i<155;i++)
{
int x = random.nextInt(width);
int y = random.nextInt(height);
int xl = random.nextInt(12);
int yl = random.nextInt(12);
g.drawLine(x,y,x+xl,y+yl);
}
// 取随Z生的认证?4位数?
//String rand = request.getParameter("rand");
//rand = rand.substring(0,rand.indexOf("."));
for (int i=0;i<4;i++){
String rand=String.valueOf(random.nextInt(10));
sRand+=rand;
// 认证码昄到图象中
g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));//调用函数出来的颜色相同，可能是因为种子太接近Q所以只能直接生?nbsp;
g.drawString(rand,13*i+6,16);
}
// 图象生效
g.dispose();
return image;
}
}
======================================================================
image.jsp(对bean的引?
<%@ page contentType="image/jpeg" import="javax.imageio.*" %>
<jsp:useBean id="image" scope="session" class="myclass.test.Image"/>
<%
//讄面不缓?nbsp;
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);
// 认证码存入SESSION
session.setAttribute("rand",image.sRand);
// 输出图象到页?nbsp;
ImageIO.write(image.creatImage(), "JPEG", response.getOutputStream());
%>
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
大家l常在网上登陆的时候经怼(x)看到让你输入验证码，有的是文字的Q有的呢是图片，比如chinaren.com校友录中留言的时候，我们׃(x)看到数字囄验证码；|上关于数字文字验证码实现方法的相关资料很多Q而我们这里介l的是数字和字母随机l成的ƈ且生成图片的验证码的实现Ҏ(gu)。看h很复杂、其实很单的Q大家跟着我往下看Q?BR>
首先Q我们先介绍一下设计思\Q数字和字母的随机组合生成验证码Q然后将验证码生成图片，q里“数字和字母的组合”应该是随机取出来的Q如果是专门的数字验证码Q我们可以这样实玎ͼ(x)
ycodenum=4 '验证码的位数Q或者说成个?BR> for i=1 to ycodenum
Randomize '初始化随机数发生?BR> ycode=ycode&Int((9*Rnd)) 'rnd是随机数Q从0?之间的Q意实敎ͼq里获得0?之间的整?BR> next
response.write ycode '可以输出数字验证码Q?位）(j)
然而，我们要让数字和字母同样随机生成，q里我们可以用到数组来实现这U效果，如下Q?BR>
ychar="0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z" '数字和大写字母l成一个字W串
yc=split(char,",") '字W串生成数组
ycodenum=4
for i=1 to ycodenum
Randomize
ycode=ycode&yc(Int((35*Rnd))) '数组一般从0开始读取，所以这里ؓ(f)35*Rnd
next
response.write ycode
现在看看输出l果是不是数字和字母随机l合的呢Q?BR>
下面看看怎样生成囄Q这个也许有些朋友知道：(x)asp不能生成囄Q必M用asplg。不错，我们q里使用的是ASP图象lgshotgraph。有一点大家注意，服务器不是自q不能用哦Q因Z装不?jin)这lg?BR>
lg的下载地址Q?A )
Response.BinaryWrite (img)
针对以上代码也就是说shotgraph普通的d的原理请参考：(x)http://www.pconline.com.cn/pcedu/empolder/wz/asp/10204/45207.html
]]>