久久久亚洲精品国产,亚洲va中文字幕无码久久不卡,亚洲宅男精品一区在线观看

同步synchornized�Ҏ(gu��)��与方法块

Tue, 16 Oct 2007 02:43:00 GMT

打个比方�Q�一个object��像一个大房子�Q�大门永�q�打开。房子里有很多房��_��也就是方法）。这些房间有上锁的（synchronized�Ҏ(gu��)��Q�，和不上锁之分�Q�普通方法）。房门口攄��一把钥匙（key�Q�，�q�把钥匙可以打开所有上锁的戉K��。另外我把所有想调用该对象方法的�U�程比喻成想�q�入�q�房子某个房间的人。所有的东西��p��么多了，下面我们看看�q�些东西之间如何作用的�?/p>

在此我们先来明确一下我们的前提条�g。该对象臛_��有一个synchronized�Ҏ(gu��)��Q�否则这个key�q�有啥意义。当然也��׃��会有我们的这个主题了�?/p>

一个�h惌��入某间上了锁的房��_��他来到房子门口，看见钥匙在那儿（说明暂时�q�没有其他�h要��用上锁的戉K��Q�。于是他��C��L��C��钥匙�Q��ƈ且按照自��q��计划使用那些戉K��。注意一点，他每�ơ��用完一�ơ上锁的戉K��后会马上把钥匙还回去。即使他要连�l��用两间上锁的戉K��Q�中间他也要把钥匙还回去�Q�再取回来�?/p>

因此�Q�普通情况下钥匙的��用原则是�Q?#8220;随用随借，用完卌��?#8221;

�q�时其他人可以不受限制的使用那些不上锁的戉K��Q�一个�h用一间可以，两个人用一间也可以�Q�没限制。但是如果当某个人想要进入上锁的戉K��Q�他��p��跑到大门口去看看了。有钥匙当然拿了��p��Q�没有的话，��只能等了�?/p>

要是很多人在�{�这把钥匙，�{�钥匙还回来以后�Q�谁会优先得到钥匙？Not guaranteed。象前面例子里那个想�q�箋使用两个上锁戉K��的家伙，他中间还钥匙的时候如果还有其他�h在等钥匙�Q�那么没有�Q何保证这家伙能再�ơ拿到。（JAVA规范在很多地斚w��明确说明不保证，象Thread.sleep()休息后多久会�q�回�q�行�Q�相同优先权的线�E�那个首先被执行�Q�当要访问对象的锁被释放后处于等待池的多个线�E�哪个会优先得到�Q�等�{�。我��x��l�的军_��权是在JVM�Q�之所以不保证�Q�就是因为JVM在做��Z��q�决定的时候，�l�不是简��单单�Ҏ(gu��)��一个条件来做出判断�Q�而是�Ҏ(gu��)��很多条。而由于判断条件太多，如果说出来可能会影响JAVA的推�q�，也可能是因�ؓ知识产权保护的原因吧。SUN�l�了个不保证��؜�q�去了。无可厚非。但我相信这些不��定�Q��ƈ非完全不��定。因��机�q�东西本�w�就是按指��o�q�行的。即使看��h��很随机的现象�Q�其实都是有规律可寻。学�q�计��机的都知道�Q�计��机里随机数的学名是伪随机数�Q�是��用一定的�Ҏ(gu��)��写出来的�Q�看上去随机�|�了。另外，或许是因��惛_��的确定太费事�Q�也没多大意义，所以不��定��׃��定了吧。）

再来看看同步代码块。和同步�Ҏ(gu��)��有小��的不同�?/p>

1.从尺�怸��Ԍ��同步代码块比同步�Ҏ(gu��)��。你可以把同步代码块看成是没上锁戉K��里的一块用带锁的屏风隔开的空间�?/p>

2.同步代码块还可以��Zؓ的指定获得某个其它对象的key。就像是指定用哪一把钥匙才能开�q�个屏风的锁�Q�你可以用本房的钥匙�Q�你也可以指定用另一个房子的钥匙才能开�Q�这��L��话，你要跑到另一栋房子那儿把那个钥匙拿来�Q��ƈ用那个房子的钥匙来打开�q�个房子的带锁的屏风�?/p>

��C��你获得的那另一栋房子的钥匙�Q��ƈ不媄响其他�h�q�入那栋房子没有锁的戉K��?/p>

��Z��么要使用同步代码块呢�Q�我惛_��该是�q�样的：首先对程序来讲同步的部分很媄响运行效率，而一个方法通常是先创徏一些局部变量，再对�q�些变量做一些操作，如运��，昄��{�等�Q�而同步所覆盖的代码越多，�Ҏ(gu��)��率的影响��p��严重。因此我们通常��量�~�小其媄响范围。如何做�Q�同步代码块。我们只把一个方法中该同步的地方同步�Q�比如运��?/p>

另外�Q�同步代码块可以指定钥匙�q�一特点有个额外的好处，是可以在一定时期内霸占某个对象的key。还记得前面说过普通情况下钥匙的��用原则吗。现在不是普通情况了。你所取得的那把钥匙不是永�q�不�q�，而是在退出同步代码块时才�q��?/p>

�q�用前面那个惌��l�用两个上锁戉K��的家伙打比方。怎样才能在用完一间以后，�l�箋使用另一间呢。用同步代码块吧。先创徏另外一个线�E�，做一个同步代码块�Q�把那个代码块的锁指向这个房子的钥匙。然后启动那个线�E�。只要你能在�q�入那个代码块时抓到�q�房子的钥匙�Q�你��可以一直保留到退出那个代码块。也��是说你甚至可以�Ҏ(gu��)��房内所有上锁的戉K��遍历�Q�甚臛_��sleep(10*60*1000)�Q�而房门口却还�?000个线�E�在�{�这把钥匙呢。很�q�瘾吧�?/p>

在此对sleep()�Ҏ(gu��)��和钥匙的兌��性讲一下。一个线�E�在拿到key后，且没有完成同步的内容�Ӟ��如果被强制sleep()了，那key�q�一直在它那�ѝ��直到它再次�q�行�Q�做完所有同步内容，才会归还key。记住，那家伙只是干�z�d��累了�Q�去休息一下，他�ƈ没干完他要干的事。�ؓ了避免别��入那个房间把里面搞的一团糟�Q�即使在睡觉的时候他也要把那唯一的钥匙戴在��n上�?/p>

最后，也许有�h会问�Q��ؓ什么要一把钥匙通开�Q�而不是一个钥匙一个门呢？我想�q�纯�_Ҏ(gu��)��因�ؓ复杂性问题。一个钥匙一个门当然更安全，但是会牵扯好多问题。钥匙的产生�Q�保��，获得�Q�归�q�等�{�。其复杂性有可能随同步方法的增加呈几何��数增加，严重影响效率�?/p>

�q�也��是一个权衡的问题吧。�ؓ了增加一点点安全性，��D��效率大大降低�Q�是多么不可取啊�?/p>

摘自�Q�http://www.54bk.com/more.asp?name=czp&id=2097

一、当两个�q�发�U�程讉K��同一个对象object中的�q�个synchronized(this)同步代码块时�Q�一个时间内只能有一个线�E�得到执行。另一个线�E�必��ȝ��待当前线�E�执行完�q�个代码块以后才能执行该代码块�?/p>

二、然而，当一个线�E�访问object的一个synchronized(this)同步代码块时�Q�另一个线�E�仍然可以访问该object中的非synchronized(this)同步代码块�?/p>

三、尤其关键的是，当一个线�E�访问object的一个synchronized(this)同步代码块时�Q�其他线�E�对object中所有其它synchronized(this)同步代码块的讉K��被��d��?/p>

四、第三个例子同样适用其它同步代码块。也��是��_��当一个线�E�访问object的一个synchronized(this)同步代码块时�Q�它?y��u)��p��得了�q�个object的对象锁。结果，其它�U�程对该object对象所有同步代码部分的讉K��都被暂时��d��?/p>

五、以上规则对其它对象锁同样适用.

举例说明�Q?/p>

package ths;

public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}

�l�果�Q?/p>

A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

二、然而，当一个线�E�访问object的一个synchronized(this)同步代码块时�Q�另一个线�E�仍然可以访问该object中的非synchronized(this)同步代码块�?/p>

package ths;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt2.m4t1();
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt2.m4t2();
}
}, "t2"
);
t1.start();
t2.start();
}
}

�l�果�Q?/p>

t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0

//修改Thread2.m4t2()�Ҏ(gu��)��Q?/p>

public void m4t2() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

}

�l�果�Q?/p>

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

//修改Thread2.m4t2()�Ҏ(gu��)��如下�Q?/p>

public synchronized void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

�l�果�Q?/p>

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

五、以上规则对其它对象锁同样适用:

package ths;

public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用对象�?
inner.m4t1();
}
}
private void m4t2(Inner inner) {
inner.m4t2();
}
public static void main(String[] args) {
final Thread3 myt3 = new Thread3();
final Inner inner = myt3.new Inner();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt3.m4t1(inner);
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt3.m4t2(inner);
}
}, "t2"
);
t1.start();
t2.start();
}
}

�l�果�Q?/p>

��管�U�程t1获得了对Inner的对象锁�Q�但�׃��U�程t2讉K��的是同一个Inner中的非同步部分。所以两个线�E�互不干扰�?/p>

t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized�Q?/p>

private synchronized void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}

�l�果�Q?/p>

��管�U�程t1与t2讉K��了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁�Q�所以t2对Inner.m4t2()的访问也被阻塞，因�ؓm4t2()是Inner中的一个同步方法�?/p>

t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0

赉|��?/a> 2007-10-16 10:43 发表评论

Java反射机制 (�?

Thu, 14 Jun 2007 08:52:00 GMT

摘要
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在�q�行旉��过Reflection APIs取得��M��一个已知名�U�的class的内部信息，包括其modifiers�Q�诸如public, static �{�等�Q�、superclass�Q�例如Object�Q�、实��C��interfaces�Q�例如Cloneable�Q�，也包括fields和methods的所有信息，�q�可于运行时改变fields内容或唤起methods。本文借由实例�Q�大面积�C��Reflection APIs�?br>
关键词：
Introspection�Q�内省、内观）
Reflection�Q�反��）
有时候我们说某个语言��h��很强的动态性，有时候我们会区分动态和静态的不同技术与作法。我们朗朗上口动态绑定（dynamic binding�Q�、动态链接（dynamic linking�Q�、动态加载（dynamic loading�Q�等。然�?#8220;动�?#8221;一词其实没有绝对而普遍适用的严格定义，有时候甚臛_��对象导向当初被导入编�E�领域一��P��一��Z��把号�Q�各吹各的调�?br>
一般而言�Q�开发者社��说到动态语�a��Q�大致认同的一个定义是�Q?#8220;�E�序�q�行�Ӟ��允许改变�E�序�l�构或变量类型，�q�种语言�U�Cؓ动态语�a�”。从�q�个观点看，Perl�Q�Python�Q�Ruby是动态语�a��Q�C++�Q�Java�Q�C#不是动态语�a��?br>
��管在这��L��定义与分�c�M��Java不是动态语�a��Q�它却有着一个非常突出的动态相��x��Ӟ��Reflection。这个字的意思是“反射、映象、倒媄”�Q�用在Java�w�上指的是我们可以于�q�行时加载、探知、��用编译期间完全未知的classes。换句话��_��Java�E�序可以加蝲一个运行时才得知名�U�的class�Q�获�(zh��n)�其完整构造（但不包括methods定义�Q�，�q�生成其对象实体、或对其fields讑ր�{��或唤�v其methods1。这�U?#8220;看透class”的能力（the ability of the program to examine itself�Q�被�U�Cؓintrospection�Q�内省、内观、反省）。Reflection和introspection是常被�ƈ提的两个术语�?br>
Java如何能够做出上述的动态特性呢�Q�这是一个深�q�话题，本文�Ҏ(gu��)��只简单介�l�一些概��c��整个篇�q�最主要�q�是介绍Reflection APIs�Q�也��是让读者知道如何探索class的结构、如何对某个“�q�行时才��L��名称的class”生成一份实体、�ؓ其fields讑ր�{��调用其methods。本文将谈到java.lang.Class�Q�以及java.lang.reflect中的Method、Field、Constructor�{�等classes�?br>
“Class”class
众所周知Java有个Object class�Q�是所有Java classes的��承根源，其内声明了数个应该在所有Java class中被改写的methods�Q�hashCode()、equals()、clone()、toString()、getClass()�{�。其中getClass()�q�回一个Class object�?br>
Class class十分�Ҏ(gu��)��。它和一般classes一��L��承自Object�Q�其实体用以表达Java�E�序�q�行时的classes和interfaces�Q�也用来表达enum、array、primitive Java types�Q�boolean, byte, char, short, int, long, float, double�Q�以及关键词void。当一个class被加载，或当加蝲器（class loader�Q�的defineClass()被JVM调用�Q�JVM 便自动��生一个Class object。如果�?zh��n)�惛_��由“修改Java标准库源�?#8221;来观察Class object的实际生成时机（例如在Class的constructor内添加一个println()�Q�，不能够！因�ؓClass�q�没有public constructor�Q�见�?�Q�。本文最后我会拨一��块��幅��带谈谈Java标准库源码的改动办法�?br>
Class是Reflection故事��h��。针对�Q何�?zh��n)��x��勘的class�Q�唯有先为它产生一个Class object�Q�接下来才能�l�由后者唤起�ؓ数十多个的Reflection APIs。这些APIs��在�E�后的探险活动中一一亮相�?br>
#001 public final
#002 class Class 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 }
...
�?�Q�Class class片段。注意它的private empty ctor�Q�意指不允许��M��人经��q��E�方式��生Class object。是的，其object 只能由JVM 产生�?br>
“Class” object的取得途径
Java允许我们从多�U�管道�ؓ一个class生成对应的Class object。图2是一份整理�?br>Class object 诞生��道 �C�Z��
�q�用getClass()
注：每个class 都有此函�?String str = "abc";
Class c1 = str.getClass();
�q�用
Class.getSuperclass()2 Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
�q�用static method
Class.forName()
�Q�最常被使用�Q?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;

�?�Q�Java 允许多种��道生成Class object�?br>
Java classes �l�成分析
首先�Ҏ(gu��)��以图3的java.util.LinkedList��Z��Q�将Java class的定义大卸八块，每一块分别对应图4所�C�的Reflection API。图5则是“获得class各区块信�?#8221;的程序示例及执行�l�果�Q�它们都取自本文�C�Z��E�序的对应片�D�c�?br>
package java.util;                      //(1)
import java.lang.*;                     //(2)
public class LinkedList              //(3)(4)(5)
extends AbstractSequentialList       //(6)
implements List, Queue,
Cloneable, java.io.Serializable         //(7)
{
private static class Entry { … }//(8)
public LinkedList() { … }           //(9)
public LinkedList(Collection c) { … }
public E getFirst() { … }           //(10)
public E getLast() { … }
private transient Entry header = …; //(11)
private transient int size = 0;
}
�?�Q�将一个Java class 大卸八块�Q�每块相应于一个或一�l�Reflection APIs�Q�图4�Q��?br>
Java classes 各成份所对应的Reflection APIs
�?的各个Java class成䆾�Q�分别对应于�?的Reflection API�Q�其中出现的Package、Method、Constructor、Field�{�等classes�Q�都定义于java.lang.reflect�?br>Java class 内部模块�Q�参见图3�Q?Java class 内部模块说明相应之Reflection API�Q�多半�ؓClass methods�?�q�回值类�?return type)
(1) package class隶属哪个package getPackage() Package
(2) import class导入哪些classes 无直接对应之API�?br>解决办法见图5-2�?nbsp;
(3) modifier class�Q�或methods, fields�Q�的属�?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 []
(6) base class base class�Q�只可能一个） getSuperClass() Class
(7) implemented interfaces 实现有哪些interfaces getInterfaces() Class[]

(8) inner classes 内部classes getDeclaredClasses() Class[]
(8') outer class 如果我们观察的class 本��n是inner classes�Q�那么相对它?y��u)�׃��有个outer class�?getDeclaringClass() Class
(9) constructors 构造函数getDeclaredConstructors() 不论 public 或private 或其它access level�Q�皆可获得。另有功能近��g��取得函数�?Constructor[]
(10) methods 操作函数getDeclaredMethods() 不论 public 或private 或其它access level�Q�皆可获得。另有功能近��g��取得函数�?Method[]
(11) fields 字段�Q�成员变量） getDeclaredFields()不论 public 或private 或其它access level�Q�皆可获得。另有功能近��g��取得函数�?Field[]

�?�Q�Java class大卸八块后（如图3�Q�，每一块所对应的Reflection API。本表�ƈ�?br>Reflection APIs 的全部�?br>
Java Reflection API �q�用�C�Z��
�?�C��?提过的每一个Reflection API�Q�及其执行结果。程序中出现的tName()是个辅助函数�Q�可��其�W�一自变量所代表�?#8220;Java class完整路径字符�?#8221;剥除路径部分�Q�留下class名称�Q�储存到�W�二自变量所代表的一个hashtable��dƈ�q�回�Q�如果第二自变量为null�Q�就不储存而只是返回）�?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�：
package java.util;
�?-1�Q�找出class 隶属的package。其中的c��l�沿用于以下各程序片�D�c�?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();
#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�：
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;
�?-2�Q�找出导入的classes�Q�动作细节详见内文说明�?br>
#001 int mod = c.getModifiers();
#002 System.out.print(Modifier.toString(mod)); //整个modifier
#003
#004 if (Modifier.isInterface(mod))
#005    System.out.print(" "); //关键�?"interface" 已含于modifier
#006 else
#007    System.out.print(" class "); //关键�?"class"
#008 System.out.print(tName(c.getName(), null)); //class 名称

执行�l�果�Q�例�Q�：
public class LinkedList
�?-3�Q�找出class或interface 的名�U�ͼ�及其属性（modifiers�Q��?br>
#001 TypeVariable[] 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�：
public abstract interface Map
或public class LinkedList
�?-4�Q�找出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�：
public class LinkedList
extends AbstractSequentialList,
�?-5�Q�找出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�：
public class LinkedList
extends AbstractSequentialList,
implements List, Queue, Cloneable, Serializable,
�?-6�Q�找出implemented interfaces。执行结果多��Z��个不该有的逗号于尾端。此非本处重点，为简化计�Q�不多做处理�?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�：
LinkedList$Entry
LinkedList$ListItr
�?-7�Q�找出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�：
public java.util.LinkedList(Collection)
public java.util.LinkedList()
�?-8a�Q�找出所有constructors

#004 System.out.println(cn[i].toGenericString());

执行�l�果�Q�例�Q�：
public java.util.LinkedList(java.util.Collection)
public java.util.LinkedList()
�?-8b�Q�找出所有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�：
public Object get(int)
public int size()
�?-9a�Q�找出所有methods

#004 System.out.println(mm[i].toGenericString());

public E java.util.LinkedList.get(int)
public int java.util.LinkedList.size()
�?-9b�Q�找出所有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�：
private transient LinkedList$Entry header;
private transient int size;
�?-10a�Q�找出所有fields

#004 System.out.println("G: " + ff[i].toGenericString());

private transient java.util.LinkedList.java.util.LinkedList$Entry ??
java.util.LinkedList.header
private transient int java.util.LinkedList.size
�?-10b�Q�找出所有fields。本例在for 循环内��用toGenericString()�Q�省事�?br>
扑և�class参用�Q�导入）的所有classes
没有直接可用的Reflection API可以为我们找出某个class参用的所有其它classes。要获得�q�项信息�Q�必��d��苦工�Q�一步一脚印逐一记录。我们必��观察所有fields的类型、所有methods�Q�包括constructors�Q�的参数�c�d��和回�q�类型，剔除重复�Q�留下唯一。这正是��Z��么图5-2�E�序代码要�ؓtName()指定一个hashtable�Q�而非一个null�Q�做为第二自变量的缘故：hashtable可�ؓ我们储存元素�Q�本例�ؓ字符�Ԍ��Q�又保证不重复�?br>
本文讨论��x��Q�几乎可以还原一个class的原貌（唯有methods 和ctors的定义无法取得）。接下来讨论Reflection 的另三个动态性质�Q?1) �q�行时生成instances�Q?2) �?br>行期唤�vmethods�Q?3) �q�行时改动fields�?br>
�q�行时生成instances
�Ʋ生成对象实体，在Reflection 动态机制中有两�U�作法，一个针�?#8220;无自变量ctor”�Q?br>一个针�?#8220;带参数ctor”。图6是面�?#8220;无自变量ctor”的例子。如果欲调用的是“带参数ctor“��比较麻烦些�Q�图7是个例子�Q�其中不再调用Class的newInstance()�Q�而是调用Constructor 的newInstance()。图7首先准备一个Class[]做�ؓctor的参数类型（本例指定��Z��个double和一个int�Q�，然后以此��变量调用getConstructor()�Q�获得一个专属ctor。接下来再准备一个Object[] 做�ؓctor实参��|��本例指定3.14159�?25�Q�，调用上述专属ctor的newInstance()�?br>
#001 Class c = Class.forName("DynTest");
#002 Object obj = null;
#003 obj = c.newInstance(); //不带自变�?br>#004 System.out.println(obj);
�?�Q�动态生�?#8220;Class object 所对应之class”的对象实体；无自变量�?br>
#001 Class c = Class.forName("DynTest");
#002 Class[] pTypes = new Class[] { double.class, int.class };
#003 Constructor ctor = c.getConstructor(pTypes);
#004 //指定parameter list�Q�便可获得特定之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�动态生�?#8220;Class object 对应之class”的对象实体；自变量以Object[]表示�?br>
�q�行时调用methods
�q�个动作和上�q�调�?#8220;带参��C��ctor”相当�c�M��。首先准备一个Class[]做�ؓctor的参数类型（本例指定其中一个是String�Q�另一个是Hashtable�Q�，然后以此��变量调用getMethod()�Q�获得特定的Method object。接下来准备一个Object[]攄��自变量，然后调用上述所得之特定Method object的invoke()�Q�如�?。知道�ؓ什么烦取Method object时不需指定回返�c�d��吗？因�ؓmethod overloading机制要求signature�Q��v名式�Q�必��d��一�Q�而回�q�类型�ƈ非signature的一个成份。换句话��_��只要指定了method名称和参数列�Q�就一定指��Z��一个独一无二的method�?br>
#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内容”��L��多了�Q�因为它不需要参数和自变量。首先调用Class的getField()�q�指定field名称。获得特定的Field object之后便可直接调用Field的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标准库源�?#8221;来测知Class object的生成，但由于其ctor原始设计为private�Q�也��是说不可能透过�q�个��道生成Class object�Q�而是由class loader负责生成�Q�，因此“在ctor中打印出某种信息”的企图也��失��M��意义�?br>
�q�里我要谈点题外话：如何修改Java标准库源码�ƈ让它反应到我们的应用�E�序来。假设我想修改java.lang.Class�Q�让它在某些情况下打印某�U�信息。首先必��L��出标准源码！当你下蝲JDK 套�g�q�安装妥当，你会发现jdk150\src\java\lang 目录�Q�见�?0�Q�之中有Class.java�Q�这��是我们此次行动的标准源码。备份后加以修改�Q�编译获得Class.class。接下来准备��?class 搬移到jdk150\jre\lib\endorsed�Q�见�?0�Q��?br>
�q�是一个十分特别的目录�Q�class loader��优先从该处��d��内含classes�?jar文�g——成功的条�g�?jar内的classes压羃路径必须和Java标准库的路径完全相同。�ؓ此，我们可以��刚才做出的Class.class先搬��C��个�ؓ此目的而刻意做出来的\java\lang目录中，压羃为foo.zip�Q��Q意命名，唯需夹带路径java\lang�Q�，再将�q�个foo.zip搬到jdk150\jre\lib\endorsed�q�改名�ؓfoo.jar。此后你的应用程序便会优先用上这里的java.lang.Class。整个过�E�可写成一个批处理文�g�Q�batch file�Q�，如图11�Q�在DOS Box中��用�?br>

�?0�Q�JDK1.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�序
�?1�Q�一个可在DOS Box中��用的批处理文�Ӟ��batch file�Q�，用以自动化java.lang.Class
的修改动作。Pkzipc(.exe)是个命��o列压�~�工��P��add和path都是其命令�?br>
更多信息
以下是视野所及与本文主题相关的更多讨论。这些信息可以��I补因文章��幅限制而带来的不��Q�或带给�(zh��n)�更多视野�?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。此��文章所附程序代码是本文�C�Z��E�序的主要依据（本文�C�Z��E�序�C��了更多Reflection APIs�Q��ƈ采用JDK1.5 新式的for-loop 写法�Q��?br>l

赉|��?/a> 2007-06-14 16:52 发表评论

Java1.5语言新特性简单�ȝ��(�?

Thu, 14 Jun 2007 06:38:00 GMT

1. 自动装箱与拆��?对应C#
　　
　　�?.1
　　Integer i = 10;
　　int j = i;
　　
　　2. 更优化的for循环对应��C#---foreach循环
　　
　　�?.1
　　String[] names = {"BadBoy","GoodBoy","HappyGirl","sadGirl"};
　　for(String option: names) {
　　System.out.println(option);
　　}
　　
　　�?.2 加泛�?对应C++模板
　　import java.util.*;
　　
　　ArrayList animals = new ArrayList();
　　animals.add("Dog");
　　animals.add("Cat");
　　animals.add("Chick");
　　animals.add("Cow");
　　for(String option : animals) {
　　System.out.println(option);
　　}
　　
　　3.参数可变的方法和printf
　　
　　�?.1
　　定义:
　　public int sum(int... n) {　//传过来n��Z��个int型数�l?br>　　int tempSum;
　　for(int option : n) {
　　tempSum+=option;
　　}
　　/*
　　for(int i = 0; i < n.length; i++) {
　　tempSum+=n[i];
　　}
　　*/
　　return tempSum;
　　}
　　调用1: sum(1);
　　调用2: sum(1,2);
　　调用3: sum(1,2,3,4);
　　
　　�?.2 printf�Ҏ(gu��)��,　对应c语言的printf
　　int x = 10;
　　int y = 20;
　　int sum = x + y;
　　System.out.printf("%d + %d = %d",x,y,sum);
　　
　　4. 枚�D
　　
　　�?.1
　　public enum MyColors {
　　red,
　　black,
　　blue,
　　green,
　　yellow
　　}
　　
　　MyColors color = MyColors.red;
　　for(MyColors option : color.values()) {
　　System.out.println(option);
　　}
　　
　　/**不能在switch语句里这样写case MyColors.red:
　　*�q�样�~�译器不会让你通过*/
　　switch(color) {
　　case red:
　　System.out.println("best color is "+red);
　　break;
　　case black:
　　System.out.println("NO " + black);
　　break;
　　default:
　　System.out.println("What");
　　break;
　　}
　　
　　5.静态引�?/strong>
　　
　　�?.1
　　1.5版本以前的写法是�Q?br>　　
　　import java.lang.Math; //�E�序开头处
　　
　　...
　　
　　double x = Math.random();
　　1.5版本中可以这样写
　　import static java.lang.Math.random; //�E�序开头处
　　
　　...
　　
　　double x = random();

赉|��?/a> 2007-06-14 14:38 发表评论

Mon, 26 Mar 2007 06:12:00 GMT

import java.util.*;
public class TokenTest2{

public static void main(String[] args){

StringTokenizer st=new StringTokenizer("this is a test","e",true);
while(st.hasMoreTokens()){
   System.out.println(st.nextToken());

}
}
}
�l�果 �Q?br />this is a t
e
st

public class StringTokenizer

extends Object
implements Enumeration
string tokenizer �c�d��许应用程序将字符串分解�ؓ标记。tokenization �Ҏ(gu��)��?StreamTokenizer �c�L��使用的方法更��单。StringTokenizer �Ҏ(gu��)��不区分标识符、数和带引号的字�W�串�Q�它们也不识别�ƈ跌��注释�?/p>
可以在创建时指定�Q�也可以�Ҏ(gu��)��每个标记来指定分隔符�Q�分隔标记的字符�Q�集合�?/p>
StringTokenizer 的实例有两种行�ؓ方式�Q�这取决于它在创建时使用�?returnDelims 标志的值是 true �q�是 false�Q?/p>
如果标志�?false�Q�则分隔�W�字�W�用来分隔标记。标记是�q�箋字符�Q�不是分隔符�Q�的最大序列�?
如果标志�?true�Q�则认�ؓ那些分隔�W�字�W�本�w�即为标记。因此标记要么是一个分隔符字符�Q�要么是那些�q�箋字符�Q�不是分隔符�Q�的最大序列�?
StringTokenizer 对象在内部维护字�W�串中要被标记的当前位置。某些操作将此当前位�|�移臛_��处理的字�W�后�?/p>
通过截取字符串的一个子串来�q�回标记�Q�该字符串用于创�?StringTokenizer 对象�?/p>
下面是一个��?tokenizer 的实例。代码如下：

     StringTokenizer st = new StringTokenizer("this is a test");
     while (st.hasMoreTokens()) {
         System.out.println(st.nextToken());
     }

输出以下字符�Ԍ��

     this
     is
     a
     test

StringTokenizer 是出于兼�Ҏ(gu��)��的原因而被保留的遗留类�Q�虽然在��C��码中�q�不鼓励使用它）。徏议所有寻求此功能的�h使用 String �?split �Ҏ(gu��)��?java.util.regex 包�?/p>
下面的示例阐明了如何使用 String.split �Ҏ(gu��)��字�W�串分解为基本标讎ͼ�

     String[] result = "this is a test".split("\\s");
     for (int x=0; x         System.out.println(result[x]);

输出以下字符�Ԍ��

     this
     is
     a
     test

赉|��?/a> 2007-03-26 14:12 发表评论

Thu, 01 Feb 2007 06:41:00 GMT

public class SysUtils{

Properties property = new Properties();
InputStream is = null;
try{
is = SysUtils.class.getClassLoader().getResourceAsStream("system.properties");
property.load(is);
String s = property.getProperty("CMS_URL");
}catch(Excption e){
System.out.println("hi"):
}

}

赉|��?/a> 2007-02-01 14:41 发表评论