在线91精品亚洲网站精品成人,亚洲精品动漫在线,4338×亚洲全国最大色成网站

newInstance() �?new 有什么区别？(�?

lau — Thu, 14 Apr 2011 09:37:00 GMT

在初始化一个类�Q�生成一个实例的时候；newInstance() �?new 有什么区别？
用newInstance与用new是区别的�Q�区别在于创建对象的方式不一��P��前者是使用�c�d��载机�Ӟ��那么��Z��么会(x��)有两�U�创建对象方式？�q�个��p��从可伸羃、可扩展�Q�可重用�{��Y件思想上解释了�?
Java中工厂模式经�怋�用newInstance来创建对象，因此从�ؓ(f��)什么要使用工厂模式上也可以扑ֈ�具体�{�案�?
例如�Q?
Class c = Class.forName(“A”);factory = (AInterface)c.newInstance();
其中AInterface是A的接口，如果下面�q�样写，你可能会(x��)理解�Q?
String className = "A";Class c = Class.forName(className);factory = (AInterface)c.newInstance();
�q�一步，如果下面写，你可能会(x��)理解�Q?
String className = readfromXMlConfig;//从xml 配置文�g中获得字�W�串Class c = Class.forName(className);factory = (AInterface)c.newInstance();
上面代码��消灭了A�c�d��U�ͼ�优点�Q�无论A�c�L��么变化�Q�上�q�C��码不变，甚至可以更换A的兄弟类B , C , D....�{�，只要他们�l�承Ainterface��可以�?
从jvm的角度看�Q�我们��用new的时候，�q�个要new的类可以没有加蝲�Q?
但是使用newInstance时候，��必��M��证：(x��)1、这个类已经加蝲�Q?、这个类已经�q�接了。而完成上面两个步骤的正是class的静态方法forName�Q�）�Ҏ(gu��)��Q�这个静态方法调用了启动�c�d��载器�Q�就是加载j(lu��)ava API的那个加载器�Q?/span>�?
有了上面jvm上的理解�Q�那么我们可以这栯��Q�newInstance实际上是把new�q�个方式分解��Z��?卻I��首先调用class的加载方法加载某个类�Q�然后实例化�?
�q�样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灉|��性，提供�l�了我们降耦的手段�?

[补充:]
newInstance: ��q��型。低效率。只能调用无参构造�?
new: 强类型。相寚w��效。能调用��M��public构造�?
newInstance()是实现IOC、反��、面�Ҏ(gu��)��口编�E?�?依赖倒置 �{�技术方法的必然选择�Q�new 只能实现具体�cȝ��实例化，不适合于接口编�E��?
里面��是通过�q�个�cȝ��默认构造函数构��Z��一个对象，如果没有默认构造函数就抛出InstantiationException, 如果没有讉K��默认构造函数的权限��抛出IllegalAccessException

lau 2011-04-14 17:37 发表评论

lau — Mon, 11 Oct 2010 08:41:00 GMT

��知识：(x��){}　定义了一个范围　 [] 定义了一个字�W�类　() 定义了一个组
*前面出现0�ơ以�?nbsp; +　前面匚w��一�ơ以上　?前面出现0�ơ或一��?/p>

1).字符�Q?/span>
x------字符x
""-----反斜�?
"0n----十进制数 (0 <= n <= 7)
"0nn---十进制数0nn (0 <= n <= 7)
"0mnn--十进制数0mnn (0 <= m <= 3,0 <= n <= 7)
"xhh---十六�q�制�?0xhh
""uhhh-十六�q�制�?0uhhh
"t-----制表�W?('"u0009') 2)
"n-----换行�W?('"u000A')
"r----- 回�R�W?('"u000D')
"e----- esc�W�号 ('"u001B')
"cx---- x 对应的控制符
2).字符�c�：(x��)
[abc] a, b, �?c (��单字�W�串)
[^abc] 除了 a, b, �?c 之外的�Q意字�W?否定)
[a-zA-Z] 从a �?z �?从A �?Z�Q�包括a,z,A,Z�Q?范围)
[a-d[m-p]] 从a �?d, �?从m �?p: [a-dm-p] (�q��)
[a-z&&[def]] d, e, �?f (交集)
[a-z&&[^bc]] 从a �?z, �?b �?c 除外: [ad-z] (子集)
[a-z&&[^m-p]] 从a �?z, 不包括从 m �?p: [a-lq-z](子集)
3).预定义字�W�序�?:
. ��L��字符 (也可能不包括行结束符)
"d 数字: [0-9]
"D 非数�? [^0-9]
"s �I�字�W? [ "t"n"x0B"f"r](A whitespace character)
"S 非空字符: [^"s]
"w 单字字符: [a-zA-Z_0-9]
"W 非单字字�W? [^"w]
4).POSIX 字符�c?(US-ASCII only) :
"p{Lower} ��写字母字符: [a-z]
"p{Upper} 大写字母字符:[A-Z]
"p{ASCII} 所�?ASCII:["x00-"x7F]
"p{Alpha} 单个字母字符:["p{Lower}"p{Upper}]
"p{Digit} 十进制数: [0-9]
"p{Alnum} 单个字符:["p{Alpha}"p{Digit}]
"p{Punct} 标点�W�号: 包括 !"#$%&'()*+,-./:;<=>?@["]^_`{|}~
"p{Graph} 可视字符: ["p{Alnum}"p{Punct}]
"p{Print} 可打印字�W? ["p{Graph}]
"p{Blank} �I�格或制表符: [ "t]
"p{Cntrl} 控制字符: ["x00-"x1F"x7F]
"p{XDigit} 十六�q�制�? [0-9a-fA-F]
"p{Space} �I�字�W? [ "t"n"x0B"f"r]
5). Unicode 字符�c?
"p{InGreek} 希腊语种的字�W?(simple block)
"p{Lu} 大写字母 (simple category)
"p{Sc} 货币�W�号
"P{InGreek} 除希腊语�U�字�W�外的�Q意字�W?(negation)
["p{L}&&[^"p{Lu}]] 除大写字母外的�Q意字�W?(subtraction)
6). 边界匚w��?
^ 一行的开�?
$ 一行的�l�束
"b 单词边界
"B 非单词边�?
"A 输入的开�?
"G 当前匚w��的结�?
"Z The end of the input but for the final terminator, if any
"z 输入的结�?
6).Greedy quantifiers 贪婪匚w��量词:
X? X不出现或出现一��?(�Ҏ(gu��)��字符"?"与{0,1}是相�{�的)
X* X不出现或出现多次 (�Ҏ(gu��)��字符"*"与{0,}是相�{�的)
X+ X臛_��出现一��?(�Ҏ(gu��)��字符"+"�?{1,}是相�{�的)
X{n} X出现n��?
X{n,} X臛_��出现n��?
X{n,m} X臛_��出现n�ơ，但不�?x��)超�q�m��?
7).Reluctant quantifiers:
X?? X, 不出现或出现一��?
X*? X, 不出现或出现多次
X+? X, 臛_��出现一��?
X{n}? X, 出现n��?
X{n,}? X, 臛_��出现n��?
X{n,m}? X, 臛_��出现n�ơ，但不�?x��)超�q�m��?
8).Possessive quantifiers:
X?+ X, 不出现或出现一��?
X*+ X, 不出现或出现多次
X++ X, 臛_��出现一��?
X{n}+ X, 出现n��?
X{n,}+ X, 臛_��出现n��?
X{n,m}+ X, 臛_��出现n�ơ，但不�?x��)超�q�m��?
9).逻辑�q�算�W?
XY Y跟在X后面
X|Y X �?Y
(X) X, as a capturing group
10).反向引用:
"n Whatever the nth capturing group matched
11).Quotation:
" 引用后面的字�W?
"Q 引用所有的字符直到 "E 出现
"E �l�束�?"Q 开始的引用
12).Special constructs (non-capturing):
(?:X) X, as a non-capturing group
(?idmsux-idmsux) 匚w��标志开�?
(?idmsux-idmsux:X) X, as a non-capturing group with the given flags on
(?=X) X, via zero-width positive lookahead - off
(?!X) X, via zero-width negative lookahead
(? <=X) X, via zero-width positive lookbehind
(?(? > X) X, as an independent, non-capturing group

1).Backslashes, escapes, and quoting
�? 斜杠字符('"')用来转义�Q�就像上面的表中定义的那��P��如果不这样做的话可能�?x��)��?歧义。因此，表达�?"匚w�� 单个反斜杠，表达�?{匚w��单个左花括号�?如果把反斜杠攑֜�没有定义转移构造的��M��字母�W�号前面都会(x��)发生错误�Q�这些将被保�? ��C��后的正则表达式中扩展。反斜杠可以攑֜��M�� 非字母符号前面，即��它没有定义�{义构造也不会(x��)发生错误�? 在java语言规范中指出，在java代码中自�W�串中的反斜杠是必要的，不管用于Unicode�?义，�q�是用于普通的字符转义。因此， ��Z��保持正则表达式的完整性，在java字符串中要写两个反斜杠。例如，在正则表辑ּ� 中字�W?"b'代表退��|��'""b'则代表单词边界�?"(hello")'是无效的�Q��ƈ且会(x��)产生�~�译旉��误，你必��ȝ�� '""(hello"")'来匹�?hello)�?
2).Character Classes
字符�c�d��以出现在其他字符�c�d��部，�q�且可以由�ƈ操作�W�和与操作符(&&)�l�成。�ƈ集操作结果是�Q�其中的��L��字符�Q�肯定在臛_��其中操作��C��臛_��出现�q�一�ơ�?交集的结果包括各个操作数中同时出现的��L��字符�?
字符�c�L��作符的优先��如下�Q�（从高��C��Q?
1 文字转义 "x
2 集合 [...]
3 范围 a-z
4 �q�� [a-e][i-u]
5 交集 [a-z&&[aeiou]]
��h��意各个字�W�类的有效字�W�集。例如，在字�W�类中，正则表达�?失去了它的特别含�?�Q��?变成了元字符的范围指�C��?
3).Line terminators
行结束符是一个或两个字符序列�Q�用来标识输入字�W�序列的一行的�l�束。下列都被认�?是行�l�束�W�：(x��)
换行�W?('"n'),
回�R换行�W?(""r"n"),
回�R�W?('"r'),
下一�?('"u0085'),
行分隔符 ('"u2028'), 或段分隔�W?('"u2029).
如果�Ȁ�z�M�� UNIX_LINES 模式�Q�唯一的行�l�束�W�就是换行符�?
除非你指定了 DOTALL 标志�Q�否则正则表辑ּ�.匚w��M��字符�Q�只有行�l�束�W�除外�?
��省情况�Ӟ��在整个输入队列中�Q�正则表辑ּ�^�?忽略行结束符�Q�只匚w��开始和�l�束�?
如果�Ȁ�z�M�� MULTILINE 模式�Q�则^匚w��输入的开始和所有行�l�束�W�之后，除了整个输入的结束�?
在MULTILINE 模式下，$匚w��所有行�l�束�W�之前，和整个输入的�l�束�?

4).Groups and capturing
分组捕获通过从左到右的顺序，�Ҏ(gu��)��括号的数量类排序。例如，在表辑ּ�((A)(B(C)))中，有四个组�Q?
1     ((A)(B(C)))
2     (A)
3     (B(C))
4     (C)
0�l�代表整个表辑ּ��?
�? �l�捕获之所以如此命名，是因为在匚w��q�程中，输入序列的每一个与分组匚w��的子�? 列都�?x��)被保存��h��。通过向后引用�Q�被捕获的子序列可以在后面的表达式中被再�ơ��用。而且�Q�在匚w��操作�l�束以后�q�可以通过匚w��器重新找到。与一个分�l�关联的被捕获到的输入通常是被保存的最�q�与�q�个分组相匹配的队列的子队列。如果一个分�l�被�W�二�ơ求��|��即��p�|�Q�它的上一�ơ被捕获的��g��?x��)被保存��h��?
例如�Q�表辑ּ�(a(b)?)+匚w��"aba"�Q?b"设�ؓ(f��)子分�l�。在开始匹配的时候，以前被捕��L(f��ng)��输入都将被清除。以(?开始的分组是完全的�Q�无需捕获的分�l�不�?x��)捕获�Q何文本，也不�?x��)计��分�l��L��?/p>

5).Unicode support

Unicode Technical Report #18: Unicode Regular Expression Guidelines通过��d��的语法改变实��C��更深层次的支持�?
在java代码中，�?u2014 �q�样的�{义序列，java语言规范中？3.3提供了处理方�?�?
��Z��便于使用从文件或键盘��d��的unicode转义字符�Q�正则表辑ּ�解析器也直接实现了这�U��{�U�R��因此，字符�?"u2014"�?""u2014"虽然不相�{�，但是�~�译�q�同一�U�模式，可以匚w��十六�q�制�?x2014�?
�? Perl中，unicode块和分类被写�?p,"P。如果输入有prop属性，"p{prop}��会(x��)匚w��Q? �?P{prop}��不�?x��)匹配。块通过前缀In指定�Q�作为在nMongolian之中。分�c�通过��L��的前�~�Is指定�Q?"p{L} �?"p{IsL} 都引�?Unicode 字母。块和分�c�d��?被��用在字符�cȝ��内部或外部�?

The Unicode Standard, Version 3.0指出了支持的块和分类。块的名字在�W?4章和 Unicode CharacterDatabase中的 Blocks-3.txt 文�g定义�Q�但�I�格被剔除了。例如Basic Latin"变成�?nbsp; "BasicLatin"。分�cȝ��名字被定义在88��，�?-5�?/p>

lau 2010-10-11 16:41 发表评论

lau — Fri, 02 Apr 2010 03:24:00 GMT

关于数组和List之间�怺�转换的方�?/a>

1.List转换成�ؓ(f��)数组。（�q�里的List是实体是ArrayList)

调用ArrayList的toArray�Ҏ(gu��)��?

toArray

public T[] toArray(T[] a)�q�回一个按照正��的��序包含此列表中所有元素的数组�Q�返回数�l�的�q�行时类型就是指定数�l�的�q�行时类型。如果列表能攑օ�指定的数�l�，则返回放入此列表�? 素的数组。否则，��根据指定数�l�的�q�行时类型和此列表的大小分配一个新的数�l��?

如果指定的数�l�能容纳列表�q�有剩余�I�间�Q�即数组的元素比列表的多�Q�，那么�?x��)将数组中紧跟在集合末尾的元素设�|��ؓ(f��) null。这对确定列表的长度很有用，但只在调用方知道列表中不包含��M�� null 元素时才有用�?

指定者：(x��)

接口 Collection 中的 toArray

指定者：(x��)

接口 List 中的 toArray

覆盖�Q?

�c?AbstractCollection 中的 toArray

参数�Q?

a - 要存储列表元素的数组�Q�如果它��_��大的话；否则�Q�它是一个�ؓ(f��)存储列表元素而分配的、具有相同运行时�c�d��的新数组�?

�q�回�Q?

包含列表元素的数�l��?

抛出�Q?

ArrayStoreException - 如果 a 的运行时�c�d��不是此列表中每个元素的运行时�c�d��的超�c�d��?

具体用法�Q?

List list = new ArrayList();

list.add("1");

list.add("2");

final int size = list.size();

String[] arr = (String[])list.toArray(new String[size]);

2.数组转换成�ؓ(f��)List�?

调用Arrays的asList�Ҏ(gu��)��.

asList

public static List asList(T... a)�q�回一个受指定数组支持的固定大��的列表。（对返回列表的更改�?#8220;直写”到数�l�。）此方法同 Collection.toArray 一��P��充当了基于数�l�的 API 与基�?collection �?API 之间的桥梁。返回的列表是可序列化的�Q��ƈ且实��C�� RandomAccess�?

此方法还提供了一个创建固定长度的列表的便��h��法，该列表被初始化�ؓ(f��)包含多个元素�Q?

List stooges = Arrays.asList("Larry", "Moe", "Curly");

参数�Q?

a - 支持列表的数�l��?

�q�回�Q?

指定数组的列表视图�?

另请参见�Q?

Collection.toArray()

具体用法:

String[] arr = new String[] {"1", "2"};

List list = Arrays.asList(arr);

-------------------------------------------------------------------------------------------------------------------------------

Arrays.asList is a feature every Java developer should know about. It'll save you from writing code like:

List foolist = new ArrayList();
foolist.add(foo);
return foolist;

or maybe

if(map.containsKey(id)){
      map.get(id).add(foo);
}else{
      List foolist = new ArrayList();
      foolist.add(foo);
      map.put(id, foo);
}

and allow you to write code like:

return Arrays.asList(foo);

and

if(map.containsKey(id))
map.get(id).add(foo);
else
map.put(id, Arrays.asList(foo));

Update: I didn't notice that Arrays.asList returns a List that can't be added too. When you try to call add on the returned List, you'll get an UnsupportedOperationException in AbstractList.add. That seemed lame to me, but the List interface does say that add is an "optional operation". For the lists to be mutable, the above code snippets have to be changed to something like:

return new ArrayList(Arrays.asList(foo));

and

if(map.containsKey(id))
map.get(id).add(foo);
else
map.put(id, new ArrayList(Arrays.asList(foo)));

Update: Of course, the more pathalogical example of what Arrays.asList saves you from is:

List foolist = new ArrayList(fooarray.length);
for(int i=0,n=fooarray.length; i foolist.add(fooarray[i]);
}

List foolist = new ArrayList(fooarray.length);
for(Foo f : fooarray){
foolist.add(f);
}

because that becomes just:

List foolist = Arrays.asList(fooarray);

lau 2010-04-02 11:24 发表评论

lau — Wed, 31 Mar 2010 14:11:00 GMT

4.5. 错误

java.lang.AbstractMethodError

抽象�Ҏ(gu��)��错误。当应用试图调用抽象�Ҏ(gu��)��时抛出�?br />
java.lang.AssertionError

断言错。用来指�C�Z��个断�a��p�|的情��c(di��n)�?br />
java.lang.ClassCircularityError

�c�d�@环依赖错误。在初始化一个类�Ӟ��若检��到�c�M��间��@环依赖则抛出该异常�?br />
java.lang.ClassFormatError

�c�L��式错误。当Java虚拟��图从一个文件中��d��Java�c�，而检��到该文件的内容不符合类的有效格式时抛出�?br />
java.lang.Error

错误。是所有错误的基类�Q�用于标识严重的�E�序�q�行问题。这些问题通常描述一些不应被应用�E�序捕获的反常情��c(di��n)�?br />
java.lang.ExceptionInInitializerError

初始化程序错误。当执行一个类的静态初始化�E�序的过�E�中�Q�发生了异常时抛出。静态初始化�E�序是指直接包含于类中的static语句�D�c(di��n)�?br />
java.lang.IllegalAccessError

�q�法讉K��错误。当一个应用试图访问、修�Ҏ(gu��)��个类的域�Q�F(tu��n)ield�Q�或者调用其�Ҏ(gu��)��Q�但是又�q�反域或�Ҏ(gu��)��的可见性声明，则抛��异常�?br />
java.lang.IncompatibleClassChangeError

不兼容的�c�d��化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时�Q�抛��异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新�~�译而直接运行的情况下，�Ҏ(gu��)��引发该错误�?br />
java.lang.InstantiationError

实例化错误。当一个应用试��N��过Java的new操作�W�构造一个抽象类或者接口时抛出该异�?

java.lang.InternalError

内部错误。用于指�C�Java虚拟机发生了内部错误�?br />
java.lang.LinkageError

链接错误。该错误�?qi��ng)其所有子�c�L��C�某个类依赖于另外一些类�Q�在该类�~�译之后�Q�被依赖的类改变了其�c�d��义而没有重新编译所有的�c�，�q�而引发错误的情况�?br />
java.lang.NoClassDefFoundError

未找到类定义错误。当Java虚拟机或者类装蝲器试囑֮�例化某个�c�，而找不到该类的定义时抛出该错误�?br />
java.lang.NoSuchFieldError

域不存在错误。当应用试图讉K��或者修�Ҏ(gu��)��cȝ��某个域，而该�cȝ��定义中没有该域的定义时抛��错误�?br />
java.lang.NoSuchMethodError

�Ҏ(gu��)��不存在错误。当应用试图调用某类的某个方法，而该�cȝ��定义中没有该�Ҏ(gu��)��的定义时抛出该错误�?br />
java.lang.OutOfMemoryError

内存不��错误。当可用内存不��以让Java虚拟机分配给一个对象时抛出该错误�?br />
java.lang.StackOverflowError

堆栈溢出错误。当一个应用递归调用的层�ơ太��p��导致堆栈溢出时抛出该错误�?br />
java.lang.ThreadDeath

�U�程�l�束。当调用Thread�cȝ��stop�Ҏ(gu��)��时抛��错误�Q�用于指�C�线�E�结束�?br />
java.lang.UnknownError

未知错误。用于指�C�Java虚拟机发生了未知严重错误的情��c(di��n)�?br />
java.lang.UnsatisfiedLinkError

未满��的链接错误。当Java虚拟机未扑ֈ�某个�cȝ��声明为native�Ҏ(gu��)��的本��a�定义时抛出�?br />
java.lang.UnsupportedClassVersionError

不支持的�cȝ��本错误。当Java虚拟��图从��d��某个�c�L��Ӟ��但是发现该文件的丅R��次版本号不被当前Java虚拟机支持的时候，抛出该错误�?br />
java.lang.VerifyError

验证错误。当验证器检��到某个�c�L��件中存在内部不兼�Ҏ(gu��)��者安全问题时抛出该错误�?br />
java.lang.VirtualMachineError

虚拟机错误。用于指�C��拟机被破坏或者��l�执行操作所需的资源不��的情况�?br /> 4.6. 注解�W�号�c�d��

java.lang.Deprecated

被废弃。用于指�C�出于安全或者有了更好的替代�Ҏ(gu��)��{�原因而不鼓励再��用的�E�序元素。当使用或者在未废弃的代码中覆盖被声明为Deprecated的程序元素时�Q�编译器�?x��)发��告�?br />
java.lang.Override

覆盖。用于指�C�某个类的方法被声明��求覆盖其父类的同一�Ҏ(gu��)��的情��c(di��n)��如果一个方法被声明覆盖�c�d��Q�而没有真正覆盖其父类的同一�Ҏ(gu��)��Q�那么编译器必须产生一个错误信息�?br />
java.lang.SuppressWarnings

消除警告。用于指�C�在被注解的�E�序元素中消除某些特定的命名警告。该注解大多用于深深地被嵌套的元素上�?

lau 2010-03-31 22:11 发表评论

java enum 学习(f��n)

lau — Mon, 21 Dec 2009 08:41:00 GMT

摘要: 关键�? java enum 在像C�q�样��数据�l�构的语�a�里，枚�D是必不可��的一�U�数据类型。然而在java的早期版本中�Q�是没有一�U�叫做enum的独立数据结构的。所以在以前的java版本中，我们�l�常使用interface来simulate一个enum�? java 代码 public interface Color { &nbs... 阅读全文

lau 2009-12-21 16:41 发表评论

lau — Thu, 11 Jun 2009 03:26:00 GMT

�{�案一�Q?br /> 1.异步传输

通常�Q�异步传输是以字�W��ؓ(f��)传输单位�Q�每个字 �W�都要附�?1 位�v始位�?1 位停止位�Q�以标记一个字�W�的开始和�l�束�Q��ƈ以此实现数据传输同步。所谓异步传输是指字�W�与字符(一个字�W�结束到下一个字�W�开�?之间的时间间隔是可变的， �q�不需要严格地限制它们的时间关�p�R��v始位对应于二�q�制�?0�Q�以低电(sh��)�q��C�，占用 1 位宽度。停止位对应于二�q�制�?1�Q�以高电(sh��)�q��C�，占用 1~2 位宽度。一个字�W�占�?5~8位，具体取决于数据所采用的字�W�集。例如，甉|��码字�W��ؓ(f��) 5 位、ASCII码字�W��ؓ(f��) 7 位、汉字码则�ؓ(f��)8 位。此外，�q�要附加 1 位奇偶校验位�Q�可以选择奇校验或偶校验方式对该字�W�实施简单的差错控制。发送端与接收端除了采用相同的数据格�?字符的位数、停止位的位数、有无校验位�? 校验方式�{?外，�q�应当采用相同的传输速率。典型的速率有：(x��)9 600 b/s�?9.2kb/s�?6kb/s�{��?

异步传输又称�? ��h��式异步通信方式�Q�其优点是简单、可靠，适用于面向字�W�的、低速的异步通信场合。例如，计算��Z��Modem之间的通信��是采用�q�种方式。它的缺�Ҏ(gu��)��通信开销大，每传输一个字�W�都要额外附�?�?位，通信效率比较低。例如，在��用Modem上网�Ӟ��普遍感觉速度很慢�Q�除了传输速率低之外，与通信开销大、�? 信效率低也密切相兟�?

--------------------------------------------------------------------------------

2. 同步传输

�? 常，同步传输是以数据块�ؓ(f��)传输单位。每个数据块的头部和��N��都要附加一个特�D�的字符或比特序列，标记一个数据块的开始和�l�束�Q�一般还要附加一个校验序�? (�?6位或32位CRC校验�?�Q�以便对数据块进行差错控制。所谓同步传输是指数据块与数据块之间的时间间隔是固定的，必须严格地规定它们的旉��? �p�R�?nbsp;

�{�案二：(x��)
误��详细一些，本�h比较弱智�Q�谢谢各�?
---------------------------------------------------------------

同步是阻塞模式，异步是非��d��模式�?
---------------------------------------------------------------

我的理解�Q�同步是指两个线�E�的�q�行是相关的�Q�其中一个线�E�要��d��{�待另外一个线�E�的�q�行。异步的意思是两个�U�程毫无相关�Q�自��p��行自��q��?

不知寚w��Q�楼下说
---------------------------------------------------------------

同步是指�Q�发送方发出数据后，�{�接收方发回响应以后才发下一个数据包的通讯方式�?
异步是指�Q�发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式�?

CSDN上有讨论�q?
http://expert.csdn.net/Expert/topic/2646/2646592.xml?temp=.3842584
http://expert.csdn.net/Expert/topic/2659/2659726.xml?temp=.1480219
---------------------------------------------------------------

举个不太恰当的例�?��像:
SendMessage(...)
TRACE0("just like send");

PostMessage(...)
TRACE0("just like WSASend using overlapped");

SendMessage是调用的时候不�q�回,�{�消息响应后才执行TRACE0,�q�就是同�?
PostMessage是调用后马上�q�回,不用消息响应��执行TRACE0,�q�就是异�?

�{�案三：(x��)

同步和异步的区别

举个例子�Q�普通B/S模式�Q�同步）AJAX技术（异步�Q?br /> 同步�Q�提交请�?>�{�待服务器处�?>处理完毕�q�回 �q�个期间客户端浏览器不能�q��Q何事
异步: ��h��通过事�g触发->服务器处理（�q�是��览器仍然可以作其他事情�Q?>处理完毕
--------------------------------------------------------------------------------------------------------------------
同步��是你叫我去吃饭�Q�我听到了就和你��d��饭；如果没有听到�Q�你��׃��停的叫，直到我告诉你听到了，才一起去吃饭�?br /> 异步��是你叫我，然后自己��d��饭，我得到消息后可能立即赎ͼ�也可能等��C��班才��d��饭�?/font>

所以，要我请你吃饭��q��同步的方法，要请我吃饭就用异步的�Ҏ(gu��)��Q�这样你可以省钱�?br /> --------------------------------------------------------------------------------------------------------------------
举个例子打电(sh��)话时同步发消息是异步

同步�Q�函数没有执行完不返回，�U�程被挂�?

��d��Q�没有收完数据函��C��q�回�Q�线�E�也被挂�?/p>

异步�Q�函数立卌��回，通过事�g或是信号通知调用�?/p>

非阻塞：(x��)函数立即�q�回�Q�通过select通知调用�?/p>

�q�样看来异步和非��d��有什么区别呢�Q?/p>

异步=非阻塞？

同步是在操作�pȝ��层面上，��d��是在套接字上�Q?/p>

Reactor是同�?Proactor是异步？

回答�Q?/strong>

同步、异步、阻塞和非阻塞的概念

　　在进行网�l�编�E�时�Q�我们常常见到同步、异步、阻塞和非阻塞四�U�调用方式。这些方式彼此概念�ƈ不好理解。下面是我对�q�些术语的理解�?/p>
同步
所谓同步，��是在发��Z��个功能调用时�Q�在没有得到�l�果之前�Q�该调用��׃��q�回。按照这个定义，�? 实绝大多数函数都是同步调用（例如sin, isdigit�{�）。但是一般而言�Q�我们在说同步、异步的时候，�Ҏ(gu��)��那些需要其他部件协作或者需要一定时间完成的��d��。最常见的例子就�? SendMessage。该函数发送一个消息给某个�H�口�Q�在�Ҏ(gu��)��处理完消息之前，�q�个函数不返回。当�Ҏ(gu��)��处理完毕以后�Q�该函数才把消息处理函数所�q�回�? LRESULT��D��回给调用者�?/p>
异步
异步的概念和同步相对。当一个异步过�E�调用发出后�Q�调用者不能立��d��到结果。实际处理这个调�? 的部件在完成后，通过状态、通知和回调来通知调用者。以 CAsycSocket�c�Mؓ(f��)例（注意�Q�CSocket从CAsyncSocket�z��Q�但是�v功能已经由异步�{化�ؓ(f��)同步�Q�，当一个客��L(f��ng)��通过调用 Connect函数发出一个连接请求后�Q�调用者线�E�立��d��以朝下运行。当�q�接真正建立��h��以后�Q�socket底层�?x��)发送一个消息通知该对象。这里提到执�? 部�g和调用者通过三种途径�q�回�l�果�Q�状态、通知和回调。可以��用哪一�U�依赖于执行部�g的实玎ͼ�除非执行部�g提供多种选择�Q�否则不受调用者控制。如果执行部件用状态来通知�Q�那么调用者就需要每隔一定时间检查一�ơ，效率��很低（有些初学多线�E�编�E�的人，��d��Ƣ用一个��@环去��查某个变量的��|��q�其实是一�U�很严重的错误）。如果是使用通知的方式，效率则很高，因�ؓ(f��)执行部�g几乎不需要做额外的操作。至于回调函敎ͼ�其实和通知没太多区别�?/p>
��d��
��d��调用是指调用�l�果�q�回之前�Q�当前线�E�会(x��)被挂赗��函数只有在得到�l�果之后才会(x��)�q�回。有��Z��? �?x��)把��d��调用和同步调用等同�v来，实际上他是不同的。对于同步调用来��_(d��)��很多时候当前线�E�还是激�zȝ��Q�只是从逻辑上当前函数没有返回而已。例如，我们在CSocket中调用Receive函数�Q�如果缓冲区中没有数据，�q�个函数��׃��(x��)一直等待，直到有数据才�q�回。而此�Ӟ��当前�U�程�q�会(x��)�l�箋处理各种各样的消息。如果主�H�口和调用函数在同一个线�E�中�Q�除非你在特�D�的界面�? 作函��C��调用�Q�其实主界面�q�是应该可以��h��。socket接收数据的另外一个函数recv则是一个阻塞调用的例子。当socket工作在阻塞模式的时候，如果没有数据的情况下调用该函敎ͼ�则当前线�E�就�?x��)被挂�v�Q�直到有数据为止�?/p>
非阻�?/strong>
非阻塞和��d��的概�늛�对应�Q�指在不能立��d��到结果之前，该函��C��?x��)阻塞当前线�E�，而会(x��)立刻�q�回�?/p>
　　对象的阻塞模式和��d��函数调用
对象是否处于��d��模式和函数是不是��d��调用有很强的相关性，但是�q�不是一一对应的。阻塞对象上可以�? 非阻塞的调用方式�Q�我们可以通过一定的API去轮询状态，在适当的时候调用阻塞函敎ͼ��可以避免阻塞。而对于非��d��对象�Q�调用特�D�的函数也可以进入阻塞调用。函数select��是�q�样的一个例子�?/p>

lau 2009-06-11 11:26 发表评论

StringUtils工具�cȝ��常用�Ҏ(gu��)��

lau — Fri, 10 Apr 2009 09:03:00 GMT

StringUtils工具�cȝ��常用�Ҏ(gu��)��
关键�? stringutils

StringUtils �Ҏ(gu��)��的操作对象是 java.lang.String �c�d��的对象，�?JDK 提供�?String �c�d��操作�Ҏ(gu��)��的补充，�q�且�?null 安全�?卛_��果输入参�?String �?null 则不�?x��)抛�?nbsp; NullPointerException �Q�而是做了相应处理�Q�例如，如果输入�?null 则返回也�? null �{�，具体可以查看源代�?�?br />
除了构造器�Q?span style="font-family: verdana,geneva;">StringUtils 中一共有130多个�Ҏ(gu��)��Q��ƈ且都�?static 的，所以我们可以这栯��?StringUtils.xxx()

下面分别对一些常用方法做��要介�l�：(x��)

1. public static boolean isEmpty(String str)
   判断某字�W�串是否为空�Q��ؓ(f��)�I�的标准�?str==null �?str.length()==0
   下面�?StringUtils 判断是否为空的示例：(x��)

StringUtils.isEmpty(null) = true
StringUtils.isEmpty("") = true
StringUtils.isEmpty(" ") = false //注意�?StringUtils 中空��g��非空处理
StringUtils.isEmpty("   ") = false
StringUtils.isEmpty("bob") = false
StringUtils.isEmpty(" bob ") = false

2. public static boolean isNotEmpty(String str)
   判断某字�W�串是否非空�Q�等�?!isEmpty(String str)
   下面是示例：(x��)

      StringUtils.isNotEmpty(null) = false
      StringUtils.isNotEmpty("") = false
      StringUtils.isNotEmpty(" ") = true
      StringUtils.isNotEmpty("         ") = true
      StringUtils.isNotEmpty("bob") = true
      StringUtils.isNotEmpty(" bob ") = true

3. public static boolean isBlank(String str)
   判断某字�W�串是否为空或长度�ؓ(f��)0或由�I�白�W?span style="font-family: verdana,geneva;">(whitespace) 构成
   下面是示例：(x��)
      StringUtils.isBlank(null) = true
      StringUtils.isBlank("") = true
      StringUtils.isBlank(" ") = true
      StringUtils.isBlank("        ") = true
      StringUtils.isBlank(""t "n "f "r") = true //对于制表�W�、换行符、换��늬�和回车符

      StringUtils.isBlank() //均识为空白符
      StringUtils.isBlank(""b") = false //""b"为单词边界符
      StringUtils.isBlank("bob") = false
      StringUtils.isBlank(" bob ") = false

4. public static boolean isNotBlank(String str)
   判断某字�W�串是否不�ؓ(f��)�I�Z��长度不�ؓ(f��)0且不��q��白符(whitespace) 构成�Q�等�?!isBlank(String str)
   下面是示例：(x��)

      StringUtils.isNotBlank(null) = false
      StringUtils.isNotBlank("") = false
      StringUtils.isNotBlank(" ") = false
      StringUtils.isNotBlank("         ") = false
      StringUtils.isNotBlank(""t "n "f "r") = false
      StringUtils.isNotBlank(""b") = true
      StringUtils.isNotBlank("bob") = true
      StringUtils.isNotBlank(" bob ") = true

5. public static String trim(String str)
   ��L��字符串两端的控制�W?span style="font-family: verdana,geneva;">(control characters, char <= 32) , 如果输入�?null 则返�?span style="font-family: verdana,geneva;">null
   下面是示例：(x��)
      StringUtils.trim(null) = null
      StringUtils.trim("") = ""
      StringUtils.trim(" ") = ""
      StringUtils.trim(" "b "t "n "f "r    ") = ""
      StringUtils.trim("     "n"tss   "b") = "ss"
      StringUtils.trim(" d   d dd     ") = "d   d dd"
      StringUtils.trim("dd     ") = "dd"
      StringUtils.trim("     dd       ") = "dd"

6. public static String trimToNull(String str)
   ��L��字符串两端的控制�W?span style="font-family: verdana,geneva;">(control characters, char <= 32) ,如果变�ؓ(f��) null �?"�Q�则�q�回 null
   下面是示例：(x��)
      StringUtils.trimToNull(null) = null
      StringUtils.trimToNull("") = null
      StringUtils.trimToNull(" ") = null
      StringUtils.trimToNull("     "b "t "n "f "r    ") = null
      StringUtils.trimToNull("     "n"tss   "b") = "ss"
      StringUtils.trimToNull(" d   d dd     ") = "d   d dd"
      StringUtils.trimToNull("dd     ") = "dd"
      StringUtils.trimToNull("     dd       ") = "dd"

7. public static String trimToEmpty(String str)
   ��L��字符串两端的控制�W?span style="font-family: verdana,geneva;">(control characters, char <= 32) ,如果变�ؓ(f��) null �?"" �Q�则�q�回 ""
   下面是示例：(x��)
      StringUtils.trimToEmpty(null) = ""
      StringUtils.trimToEmpty("") = ""
      StringUtils.trimToEmpty(" ") = ""
      StringUtils.trimToEmpty("     "b "t "n "f "r    ") = ""
      StringUtils.trimToEmpty("     "n"tss   "b") = "ss"
      StringUtils.trimToEmpty(" d   d dd     ") = "d   d dd"
      StringUtils.trimToEmpty("dd     ") = "dd"
      StringUtils.trimToEmpty("     dd       ") = "dd"

8. public static String strip(String str)
   ��L��字符串两端的�I�白�W?span style="color: #0000ff; font-family: verdana,geneva;">(whitespace) �Q�如果输入�ؓ(f��) null 则返�?null
   下面是示�?注意�?span style="color: #0000ff; font-family: verdana,geneva;"> trim() 的区�?�Q?br />       StringUtils.strip(null) = null
      StringUtils.strip("") = ""
      StringUtils.strip(" ") = ""
      StringUtils.strip("     "b "t "n "f "r    ") = ""b"
      StringUtils.strip("     "n"tss   "b") = "ss   "b"
      StringUtils.strip(" d   d dd     ") = "d   d dd"
      StringUtils.strip("dd     ") = "dd"
      StringUtils.strip("     dd       ") = "dd"

9. public static String stripToNull(String str)
   ��L��字符串两端的�I�白�W?span style="color: #0000ff; font-family: verdana,geneva;">(whitespace) �Q�如果变�? null �?"�Q�则�q�回 null
   下面是示�?注意�?trimToNull() 的区�?�Q?br />       StringUtils.stripToNull(null) = null
      StringUtils.stripToNull("") = null
      StringUtils.stripToNull(" ") = null
      StringUtils.stripToNull("     "b "t "n "f "r    ") = ""b"
      StringUtils.stripToNull("     "n"tss   "b") = "ss   "b"
      StringUtils.stripToNull(" d   d dd     ") = "d   d dd"
      StringUtils.stripToNull("dd     ") = "dd"
      StringUtils.stripToNull("     dd       ") = "dd"

10. public static String stripToEmpty(String str)
    ��L��字符串两端的�I�白�W?span style="color: #0000ff; font-family: verdana,geneva;">(whitespace) �Q�如果变�?span style="font-family: verdana,geneva;"> null �?span style="font-family: verdana,geneva;">"" �Q�则�q�回""
    下面是示�?注意�?trimToEmpty() 的区�?�Q?br />       StringUtils.stripToNull(null) = ""
      StringUtils.stripToNull("") = ""
      StringUtils.stripToNull(" ") = ""
      StringUtils.stripToNull("     "b "t "n "f "r    ") = ""b"
      StringUtils.stripToNull("     "n"tss   "b") = "ss   "b"
      StringUtils.stripToNull(" d   d dd     ") = "d   d dd"
      StringUtils.stripToNull("dd     ") = "dd"
      StringUtils.stripToNull("     dd       ") = "dd"

以下�Ҏ(gu��)��只介�l�其功能�Q�不再�D例：(x��)
11. public static String strip(String str, String stripChars)
   ��L�� str 两端的在 stripChars 中的字符�?br />    如果 str �?null 或等�?span style="font-family: verdana,geneva;">"" �Q�则�q�回它本�w�；
   如果 stripChars �?null �?span style="font-family: verdana,geneva;">"" �Q�则�q�回 strip(String str) �?br />
12. public static String stripStart(String str, String stripChars)
    �?1�怼��Q�去�?span style="font-family: verdana,geneva;"> str 前端的在 stripChars 中的字符�?br />
13. public static String stripEnd(String str, String stripChars)
    �?1�怼��Q�去�?str 末端的在 stripChars 中的字符�?br />
14. public static String[] stripAll(String[] strs)
    对字�W�串数组中的每个字符串进�? strip(String str) �Q�然后返回�?br />     如果 strs �?null �?strs 长度�?�Q�则�q�回 strs 本��n

15. public static String[] stripAll(String[] strs, String stripChars)
    对字�W�串数组中的每个字符串进�?strip(String str, String stripChars) �Q�然后返回�?br />     如果 strs �?null �?strs 长度�?�Q�则�q�回 strs 本��n

16. public static boolean equals(String str1, String str2)
    比较两个字符串是否相�{�，如果两个均�ؓ(f��)�I�则也认为相�{��?br />
17. public static boolean equalsIgnoreCase(String str1, String str2)
    比较两个字符串是否相�{�，不区分大��写�Q�如果两个均为空则也认�ؓ(f��)相等�?br />
18. public static int indexOf(String str, char searchChar)
    �q�回字符 searchChar 在字�W�串 str 中第一�ơ出现的位置�?br />     如果 searchChar 没有�?str 中出现则�q�回-1�Q?br />     如果 str �?null �?"" �Q�则也返�?1

19. public static int indexOf(String str, char searchChar, int startPos)
    �q�回字符 searchChar �?startPos 开始在字符�?str 中第一�ơ出现的位置�?br />     如果�?startPos 开�?searchChar 没有�?span style="font-family: verdana,geneva;"> str 中出现则�q�回-1�Q?br />     如果 str �?null �?"" �Q�则也返�?1

20. public static int indexOf(String str, String searchStr)
    �q�回字符�? searchStr 在字�W�串 str 中第一�ơ出现的位置�?br />     如果 str �?null �?searchStr �?null 则返�?1�Q?br />     如果 searchStr �?"" ,�?span style="font-family: verdana,geneva;"> str ��Z��?null �Q�则�q�回0�Q?br />     如果 searchStr 不在 str 中，则返�?1

21. public static int ordinalIndexOf(String str, String searchStr, int ordinal)
    �q�回字符�?searchStr 在字�W�串 str 中第 ordinal �ơ出现的位置�?br />     如果 str=null �?searchStr=null �?ordinal<=0 则返�?1
    举例(*代表��L��字符�?�Q?br />       StringUtils.ordinalIndexOf(null, *, *) = -1
      StringUtils.ordinalIndexOf(*, null, *) = -1
      StringUtils.ordinalIndexOf("", "", *) = 0
      StringUtils.ordinalIndexOf("aabaabaa", "a", 1) = 0
      StringUtils.ordinalIndexOf("aabaabaa", "a", 2) = 1
      StringUtils.ordinalIndexOf("aabaabaa", "b", 1) = 2
      StringUtils.ordinalIndexOf("aabaabaa", "b", 2) = 5
      StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
      StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
      StringUtils.ordinalIndexOf("aabaabaa", "bc", 1) = -1
      StringUtils.ordinalIndexOf("aabaabaa", "", 1) = 0
      StringUtils.ordinalIndexOf("aabaabaa", "", 2) = 0

22. public static int indexOf(String str, String searchStr, int startPos)
    �q�回字符�?searchStr �?startPos 开始在字符�?str 中第一�ơ出现的位置�?br />     举例(*代表��L��字符�?�Q?br />       StringUtils.indexOf(null, *, *) = -1
      StringUtils.indexOf(*, null, *) = -1
      StringUtils.indexOf("", "", 0) = 0
      StringUtils.indexOf("aabaabaa", "a", 0) = 0
      StringUtils.indexOf("aabaabaa", "b", 0) = 2
      StringUtils.indexOf("aabaabaa", "ab", 0) = 1
      StringUtils.indexOf("aabaabaa", "b", 3) = 5
      StringUtils.indexOf("aabaabaa", "b", 9) = -1
      StringUtils.indexOf("aabaabaa", "b", -1) = 2
      StringUtils.indexOf("aabaabaa", "", 2) = 2
      StringUtils.indexOf("abc", "", 9) = 3

23. public static int lastIndexOf(String str, char searchChar)
    基本原理�?8

24. public static int lastIndexOf(String str, char searchChar, int startPos)
    基本原理�?9

25. public static int lastIndexOf(String str, String searchStr)
    基本原理�?0

26. public static int lastIndexOf(String str, String searchStr, int startPos)
    基本原理�?2

另附�Q?br />
String �?split(String regex) �Ҏ(gu��)��的用�?br /> 如果我们需要把某个字符串拆分�ؓ(f��)字符串数�l�，则通常�?span style="font-family: verdana,geneva;"> split(String regex) 来实现�?br />
例如�Q?br />

Java代码

String str = "aa,bb,cc,dd";

String[] strArray = str.split(",");

System.out.println(strArray.length);

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

       System.out.println(strArray[i]);

}

String str = "aa,bb,cc,dd"; String[] strArray = str.split(","); System.out.println(strArray.length); for (int i = 0; i < strArray.length; i++) { System.out.println(strArray[i]); }

�l�果为：(x��)
4
aa
bb
cc
dd

如果�Q?br /> String str = "aa.bb.cc.dd";
String[] strArray = str.split(".");

则结果�ؓ(f��)�Q?

��Z��么结果不是我们所想的呢，原因是参�?span style="font-family: verdana,geneva;"> String regex 是正则表辑ּ� (regular expression) 而不是普通字�W�串�Q��?"." 在正则表辑ּ�中有�Ҏ(gu��)��含义�Q�表�C�匹配所有单个字�W�。如果要那样拆分�Q�我们必��ȝ�� "." �q�行转义�Q?span style="font-family: verdana,geneva;">String[] strArray = str.split(".") 修改�?String[] strArray = str.split(""".") 卛_��?br /> 另外有关 StringUtils 的详�l?API 请参见官方网�?span style="font-family: arial,helvetica,sans-serif;">: http://commons.apache.org/lang/api/org/apache/commons/lang/StringUtils.html

lau 2009-04-10 17:03 发表评论

java�l�典基础

lau — Mon, 30 Mar 2009 06:55:00 GMT

对于�q�个�p�d��里的问题�Q�每个学Java的�h都应该搞懂。当�Ӟ��如果只是学Java玩玩��无所谓了。如果你认�ؓ(f��)自己已经��越初学者了�Q�却不很懂这些问题，请将你自己重归初学者行列。内容均来自于CSDN的经典老脓(chu��ng)�?/font>

        问题一�Q�我声明了什么！

       String s = "Hello world!";

       许多人都做过�q�样的事情，但是�Q�我们到底声明了什么？回答通常是：(x��)一个String�Q�内�Ҏ(gu��)��“Hello world!”。这��h��p�的回答通常是概念不清的�Ҏ(gu��)��。如果要准确的回�{�，一半的人大概会(x��)回答错误�?br /> �q�个语句声明的是一个指向对象的引用�Q�名�?#8220;s”�Q�可以指向类型�ؓ(f��)String的�Q何对象，目前指向"Hello world!"�q�个String�c�d��的对�?/strong>�?/font>�q�就是真正发生的事情。我们�ƈ没有声明一个String对象�Q�我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：(x��)

      String string = s;

      我们是声明了另外一个只能指向String对象的引用，名�ؓ(f��)string�Q��ƈ没有�W�二个对象��生，string�q�是指向原来那个对象�Q�也��是�Q�和s指向同一个对象�?br />
      问题二：(x��)"=="和equals�Ҏ(gu��)��I�竟有什么区别？

      ==操作�W�专门用来比较变量的值是否相�{�。比较好理解的一�Ҏ(gu��)��Q?br />       int a=10;
      int b=10;
      则a==b��是true�?br />       但不好理解的地方是：(x��)
      String a=new String("foo");
      String b=new String("foo");
      则a==b��返回false�?br />
      �Ҏ(gu��)��前一帖说�q�，对象变量其实是一个引用，它们的值是指向对象所在的内存地址�Q�而不是对象本�w�。a和b都��用了new操作�W�，意味着��在内存中��生两个内容�ؓ(f��)"foo"的字�W�串�Q�既然是“两个”�Q�它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的��|��所以��?=="操作�W�，�l�果�?x��)是false。诚�Ӟ��a和b所指的对象�Q�它们的内容都是"foo"�Q�应该是“相等”�Q?font color="#ff0000">但是==操作�W��ƈ不涉�?qi��ng)到对象内容的比较�?/strong>对象内容的比较，正是equals�Ҏ(gu��)��做的事�?/strong>

      看一下Object对象的equals�Ҏ(gu��)��是如何实现的�Q?br />       boolean equals(Object o){

      return this==o;

      }
      Object对象默认使用�?=操作�W�。所以如果你自创的类没有覆盖equals�Ҏ(gu��)��Q�那你的�c�M��用equals和��?=�?x��)得到同��L(f��ng)��l�果。同样也可以看出�Q�Object的equals�Ҏ(gu��)��没有辑ֈ�equals�Ҏ(gu��)��应该辑ֈ�的目标：(x��)比较两个对象内容是否相等。因为答案应该由�cȝ��创徏者决定，所以Object把这个�Q务留�l�了�cȝ��创徏者�?br />
      看一下一个极端的�c�：(x��)
      Class Monster{
      private String content;
      ...
      boolean equals(Object another){ return true;}

      }
      我覆盖了equals�Ҏ(gu��)��。这个实��C��(x��)��D��无论Monster实例内容如何�Q�它们之间的比较永远�q�回true�?br />
所以当你是用equals�Ҏ(gu��)��判断对象的内�Ҏ(gu��)��否相�{�，请不要想当然。因为可能你认�ؓ(f��)相等�Q�而这个类的作者不�q�样认�ؓ(f��)�Q�而类的equals�Ҏ(gu��)��的实现是�׃��掌握的。如果你需要��用equals�Ҏ(gu��)��Q�或者��用�Q何基于散列码的集合（HashSet,HashMap,HashTable�Q�，请察看一下java doc以确认这个类的equals逻辑是如何实现的�?br />
      问题三：(x��)String到底变了没有�Q?/strong>

      没有。因为String被设计成不可�?immutable)�c�，所以它的所有对象都是不可变对象。请看下列代码：(x��)

      String s = "Hello";
      s = s + " world!";

      s所指向的对象是否改变了呢？从本�p�d��W�一��的�l�论很容易导��个结论。我们来看看发生了什么事情。在�q�段代码中，s原先指向一个String对象�Q�内�Ҏ(gu��)��"Hello"�Q�然后我们对s�q�行�?操作�Q�那么s所指向的那个对象是否发生了改变呢？�{�案是没有。这�Ӟ��s不指向原来那个对象了�Q�而指向了另一个String对象�Q�内容�ؓ(f��)"Hello world!"�Q�原来那个对象还存在于内存之中，只是s�q�个引用变量不再指向它了�?br /> 通过上面的说明，我们很容易导出另一个结论，如果�l�常对字�W�串�q�行各种各样的修改，或者说�Q�不可预见的修改�Q�那么��用String来代表字�W�串的话�?x��)引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符�Ԍ��都需要一个String对象来表�C�。这�Ӟ��应该考虑使用StringBuffer�c�，它允�怿�改，而不是每个不同的字符串都要生成一个新的对象。�ƈ且，�q�两�U�类的对象�{换十分容易�?br /> 同时�Q�我们还可以知道�Q�如果要使用内容相同的字�W�串�Q�不必每�ơ都new一个String。例如我们要在构造器中对一个名叫s的String引用变量�q�行初始化，把它讄��为初始��|��应当�q�样做：(x��)
      public class Demo {
         private String s;
         ...
         public Demo {
           s = "Initial Value";
         }
         ...
      }
      而非 s = new String("Initial Value");
      后者每�ơ都�?x��)调用构造器�Q�生成新对象�Q�性能低下且内存开销大，�q�且没有意义�Q�因为String对象不可改变�Q�所以对于内容相同的字符�Ԍ��只要一个String对象来表�C�就可以了。也��p��Q�多�ơ调用上面的构造器创徏多个对象�Q�他们的String�c�d��属性s都指向同一个对象�?br /> 上面的结��Z��q�样一个事实：(x��)对于字符串常量，如果内容相同�Q�Java认�ؓ(f��)它们代表同一个String对象。而用关键字new调用构造器�Q��L��?x��)创��Z��个新的对象，无论内容是否相同�?br /> 至于��Z��么要把String�c�设计成不可变类�Q�是它的用途决定的。其实不只String�Q�很多Java标准�c�d��中的�c�都是不可变的。在开发一个系�l�的时候，我们有时候也需要设计不可变�c�，来传递一�l�相关的��|��q�也是面向对象思想的体现。不可变�c�L��一些优点，比如因�ؓ(f��)它的对象是只�ȝ��Q�所以多�U�程�q�发讉K��也不�?x��)有��M��问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表�Q�可能会(x��)造成性能上的问题。所以Java标准�c�d��q�提供了一个可变版本，即StringBuffer�?br />
      问题四：(x��)final关键字到底修��C��什么？

      final使得被修饰的变量"不变"�Q�但是由于对象型变量的本质是“引用”�Q��?#8220;不变”也有了两�U�含义：(x��)引用本��n的不变，和引用指向的对象不变�?br />
      引用本��n的不变：(x��)
      final StringBuffer a=new StringBuffer("immutable");
      final StringBuffer b=new StringBuffer("not immutable");
      a=b;//�~�译期错�?br />
      引用指向的对象不变：(x��)
      final StringBuffer a=new StringBuffer("immutable");
      a.append(" broken!"); //�~�译通过

      可见�Q?font color="#ff0000">final只对引用�?#8220;�?#8221;(也即它所指向的那个对象的内存地址)有效�Q�它�q��引用只能指向初始指向的那个对象，改变它的指向�?x��)导致编译期错误。至于它所指向的对象的变化�Q�final是不负责的。这很类�?=操作�W�：(x��)==操作�W�只负责引用�?#8220;�?#8221;相等�Q�至于这个地址所指向的对象内�Ҏ(gu��)��否相�{�，==操作�W�是不管的�?br />
      理解final问题有很重要的含义。许多程序漏�z�都��Z��?---final只能保证引用永远指向固定对象�Q�不能保证那个对象的状态不变。在多线�E�的操作�?一个对象会(x��)被多个线�E�共享或修改�Q�一个线�E�对对象无意识的修改可能�?x��)导致另一个��用此对象的线�E�崩溃。一个错误的解决�Ҏ(gu��)��是在此对象新徏的时候把它声明�ؓ(f��)final�Q�意图��得它“永远不变”。其实那是徒劳的�?br />
      问题五：(x��)到底要怎么样初始化�Q?/strong>

      本问题讨论变量的初始化，所以先来看一下Java中有哪些�U�类的变量�?br />       1. �cȝ��属性，或者叫值域
      2. �Ҏ(gu��)��里的局部变�?br />       3. �Ҏ(gu��)��的参�?br />
      对于�W�一�U�变量，Java虚拟��Z��(x��)自动�q�行初始化。如果给��Z��初始��|��则初始化��初始倹{��如果没有给出，则把它初始化��c�d��变量的默认初始倹{�?br />
      int�c�d��变量默认初始��gؓ(f��)0
      float�c�d��变量默认初始��gؓ(f��)0.0f
      double�c�d��变量默认初始��gؓ(f��)0.0
      boolean�c�d��变量默认初始��gؓ(f��)false
      char�c�d��变量默认初始��gؓ(f��)0(ASCII�?
      long�c�d��变量默认初始��gؓ(f��)0
      所有对象引用类型变量默认初始��gؓ(f��)null�Q�即不指向�Q何对象。注意数�l�本�w�也是对象，所以没有初始化的数�l�引用在自动初始化后其��g��是null�?br />
      对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创徏实例的时候初始化�Q�static属性在�c�d��载，也就是第一�ơ用到这个类的时候初始化�Q�对于后来的实例的创建，不再�ơ进行初始化�?/font>�q�个问题�?x��)在以后的系列中�q�行详细讨论�?br />
      对于�W�二�U�变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，�~�译器会(x��)抗议。如果初始化的语句在try块中或if块中�Q�也必须要让它在�W�一�ơ��用前一定能够得到赋倹{��也��是��_(d��)��把初始化语句攑֜�只有if块的条�g判断语句中编译器也会(x��)抗议�Q�因为执行的时候可能不�W�合if后面的判断条�Ӟ��如此一来初始化语句��׃��?x��)被执行了，�q�就�q�反了局部变量��用前必须初始化的规定。但如果在else块中也有初始化语句，��可以通过�~�译�Q�因为无论如何，��L��臛_��一条初始化语句�?x��)被执行�Q�不�?x��)发生��用前未被初始化的事情。对于try-catch也是一��P��如果只有在try块里才有初始化语句，�~�译部通过。如果在catch或finally里也有，则可以通过�~�译。��M��Q�要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要��Z��化成什么值好�Q�就用上面的默认值吧�Q?br />
      其实�W�三�U�变量和�W�二�U�本质上是一��L(f��ng)��Q�都是方法中的局部变量。只不过作�ؓ(f��)参数�Q�肯定是被初始化�q�的�Q�传入的值就是初始��|��所以不需要初始化�?br />
      问题六：(x��)instanceof是什么东东？

      instanceof是Java的一个二元操作符�Q�和==�Q?gt;�Q?lt;是同一�c�M��东。由于它是由字母�l�成的，所以也是Java的保留关键字。它的作用是��试它左边的对象是否是它双��的类的实例，�q�回boolean�c�d��的数据。�D个例子：(x��)

      String s = "I AM an Object!";
      boolean isObject = s instanceof Object;

      我们声明了一个String对象引用�Q�指向一个String对象�Q�然后用instancof来测试它所指向的对象是否是Object�cȝ��一个实例，昄��Q�这是真的，所以返回true�Q�也��是isObject的��gؓ(f��)True�?br /> instanceof有一些用处。比如我们写了一个处理�̎单的�pȝ��Q�其中有�q�样三个�c�：(x��)

      public class Bill {//省略�l�节}
      public class PhoneBill extends Bill {//省略�l�节}
      public class GasBill extends Bill {//省略�l�节}

      在处理程序里有一个方法，接受一个Bill�c�d��的对象，计算金额。假设两�U��̎单计��方法不同，而传入的Bill对象可能是两�U�中的�Q何一�U�，所以要用instanceof来判断：(x��)

      public double calculate(Bill bill) {
         if (bill instanceof PhoneBill) {
           //计算�?sh��)话账�?br />          }
         if (bill instanceof GasBill) {
           //计算燃气账单
         }
         ...
      }
      �q�样��可以用一个方法处理两�U�子�c�R�?br />
      然而，�q�种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实玎ͼ��q�是面向对象变成应有的做法，避免回到�l�构化编�E�模式。只要提供两个名字和�q�回值都相同�Q�接受参数类型不同的�Ҏ(gu��)��可以了�Q?br />
      public double calculate(PhoneBill bill) {
         //计算�?sh��)话账�?br />       }

      public double calculate(GasBill bill) {
         //计算燃气账单
      }

      所以，使用instanceof在绝大多数情况下�q�不是推荐的做法�Q�应当好好利用多态�?/font>

lau 2009-03-30 14:55 发表评论

语言深入:java中究竟是传��D��是传引用

lau — Tue, 24 Mar 2009 10:21:00 GMT

首先�Q�推荐对Java有一定理解的同仁一本书《Practical Java》。在《Practical Java》中也有一个章节介�l�Java中关于传值和传引用的问题�Q�堪�U�经典。《Practical Java》在Java中，事实上底层工作原理不存在传引用的概念�Q�这也象《Practical Java》中所说的那样�Q�Java中只有传倹{��这句话理解��h��需要费一定的周折�?/font>

      熟�?zh��n)�C的程序员都用�q�指针，�Ҏ(gu��)��针可谓爱之深恨之切。指针是指向一块内存地址的内存数据（有些拗口�Q�，也就是说指针本��n是一个占�?字节内存的int�Q?2 位系�l�内�Q�，而这个int值恰恰又是另一块内存的地址。比�?hello"�q�个字串�Q�存攑֜�@0x0000F000�q�个地址到@0x0000F005�q�段内存区域内（包括0x00的结束字节）。而在@0x0000FFF0到@0x0000FFF03�q�四个字节内存放着一个int�Q�这个int的值是 @0x0000F000。这样就形成了一个指�?hello"字串的指针�?/font>

      在Java中，很多��没有指针�Q�事实上�Q�在Java更深层次里，到处都是大师��装好的�_��l��u的指针�?/font>��Z��更容易的讲解Java中关于类和类型的调用�Q�Java中出��C��g��引用的说法。浅昄��来说�Q�我们可以认为Java中的引用与C中的指针�{�效�Q�其实差别非帔R��常大�Q�但是�ؓ(f��)了说明我们今天的问题�Q�把他们理解为等效是没有��M��问题的）�?/font>

      所谓传引用的说法是��Z��更好的讲解调用方式。基于上面对指针的理解，我们不难看出�Q�指针其实也是一个int��|��所谓传引用�Q�我们是复制了复制了指针的int��D��行传递。�ؓ(f��)了便于理解，我们可以姑且把指针看作一�U�数据类型，透明化指针的int�Ҏ(gu��)��，从而提��Z��引用的概��c(di��n)�?/font>

      重申一遍：(x��)Java中只有传倹{�?/strong>

      1所谓传值和传引�?/strong>

      传值和传引用的问题一直是Java里争论的话题。与C++不同的，Java里面没有指针的概念，Java的设计者��y妙的�Ҏ(gu��)��针的操作�q�行了管理。事实上�Q�在懂C++的Java�E�序员眼中，Java到处都是�_��l��u的指针�?br /> 下面举个��单的例子�Q�说明什么是传��|��什么是传引用�?br /> //�?
void method1(){
int x=0;
this.change(x);
System.out.println(x);
}

void change(int i){
i=1;
}

      很显然的�Q�在mothod1中执行了change(x)后，x的值�ƈ不会(x��)因�ؓ(f��)change�Ҏ(gu��)��中将输入参数赋��gؓ(f��)1而变�?�Q�也��是说在执行change(x)后，x的值z依然�?。这是因为x传递给change(int i)的是倹{��这��是最��单的传倹{�?br /> 同样的，�q�行一点简单的变化�?br /> //�?
void method1(){
StringBuffer x=new StringBuffer("Hello");
this.change(x);
System.out.println(x);
}

void change(StringBuffer i){
i.append(" world!");
}
      看�v来没什么变化，但是�q�次mothed1中执行了change (x)后，x的��g��再是"Hello"了，而是变成�?Hello world!"。这是因为x传递给change(i)的是x的引用。这是最�l�典的传引用�?br /> ��g��有些奇怪了�Q�两�D늨�序没有特别的不同�Q�可是�ؓ(f��)什么一个传的是��D��另一个传的是引用呢？......

      2非要搞清楚传��D��是传引用的问题吗�Q?/strong>

      搞清楚这自然是有必要的，不然我也不需要写�q�么多了�Q�不�q�的��没有到"非要"的地步�?/font>

      首先�Q�如果我们不太关心什么是传��g��么是传引用，我们一栯��写出漂亮的代码，但是�q�些代码在运行过�E�中可能�?x��)存在着极大的隐�(zh��n)�。全局变量是让大家深恶痛绝�Q�又难以割舍�Q�的东西�Q�原因就是��用全局变量要特别注意数据的保护。如果在多线�E�的�E�序里��用全局变量��直就�{�于跟自��p��不去。不了解传值和传引用的问题�Q�跟使用全局变量不考虑数据保护的罪�q�是不相上下下的�Q�甚��x��时候比它还要糟。你�?x��)莫名其妙，��Z��么我的返回参数没有�v作用�Q��ؓ(f��)什么我传进�ȝ��参数变成了这�?.....�Q?br /> 一个例子：(x��)
//�?
void mothed1(){
int x=0;
int y=1;
switchValue(x,y);
System.out.println("x="+x);
System.out.println("y="+y);
}
void switchValue(int a,int b){

int c=a;
a=b;
b=c;
}
      上面是一个交换a,b值的函数�Q�看��h��g��蛮正��的�Q�但是这个函数永�q�也不会(x��)完成你想要的工作�?br />       �q�有一个例子：(x��)
//�?
StringBuffer a=new StringBuffer("I am a ");
StringBuffer b=a;
a.append("after append");
a=b;
System.out.println("a="+a);
在编�E�过�E�中�Q�经�怼�(x��)遇到�q�种情况�Q�一个变量的��D��被��(f��)时改变一下，�{�用完之后再恢复到开始的倹{��就好像上面的例子，a��Z��保持它的��|��使用b=a做赋��|��之后a被改变，再之后a把暂存在b里面的值取回来。这是我们一厢情愿的��x��Q�而事实上�Q�这�D�代码执行后�Q�你�?x��)发现a的值已�l�改变了�?br /> 以上是两个最��单的例子�Q�真正的�E�序开发过�E�中�Q�比�q�要复杂的情冉|��天都�?x��)遇到�?/font>

      3�c�d��和类

      Java 提出的思想�Q�在Java里面��M��东西都是�c�R��但是Java里面同时�q�有��单数据类型int,byte,char,boolean�Q�与�q�些数据�c�d��相对应的�c�L��Integer�Q�Byte�Q�Character�Q�Boolean�Q�这样做依然不会(x��)破坏Java关于��M��东西都是�cȝ��提法。这里提到数据类型和�c�M��乎和我们要说的传值和传引用的问题无关�Q�但�q�是我们分��L传值和传引用的基础�?/font>

      4试图分��L传��D��是传引用

      ��Z��么是"试图分��L"呢？很简单，传值和传引用的问题无处不在�Q�但是似乎还没有��正统的给出标准，怎样的就是值拷贝调用，怎样的就是引用调用。面对这个问题，我们更多的应该是来自�q�x��U�篏对Java的理解�?br />       回过头来�Q�我们分析一下上面的几个例子�Q?br />       先看�?�Q�即使你不明白�ؓ(f��)什么，但是你应该知道这样做肯定不会(x��)改变x的倹{��ؓ(f��)了方便说明，我们�l�例子都加上行号�?br /> //�?
1 void method1(){
2   int x=0;
3   this.change(x);
4 }
5
6 void change(int i){
7 i=7;
8}
      让我们从内存的存储方式看一下x和I之间到底是什么关�p�R�?br />       在执行到�W?行的时候，变量x指向一个存攄��int 0的内存地址�?/font>

      变量x---->[存放�?]

      执行�W?行调用change(x)�Ҏ(gu��)��的时候，内存中是�q�样的情形：(x��)x把自己值在内存中复制一份，然后变量i指向�q�个被复制出来的0�?/font>

      变量x---->[存放�?]
                        ↓�q�行了一�ơ值复�?br />       变量x---->[存放�?]

      �q�时候再执行到第7行的时候，变量i的被赋��gؓ(f��)7�Q�而这一步的操作已经跟x没有��M��关系了�?/font>

      变量x---->[存放�?]

      变量x---->[存放�?]

      说到�q�里应该已经理解��Z��么change(x)不能改变x的��g��吧？因�ؓ(f��)�q�个例子是传值的�?br /> 那么�Q�试着分析一下�ؓ(f��)什么例三中的switchValue()�Ҏ(gu��)��不能完成变量��g��换的工作�Q?br /> 再看�?�?br /> //�?
1void method1(){
2 StringBuffer x=new StringBuffer("Hello");
3 this.change(x);
4}
5
6void change(StringBuffer i){
7 i.append(" world!");
8}
      �?��g��和例1从代码上看不��Z��么差别，但是执行�l�果却是change(x)能改变x的倹{��依然才从内存的存储角度来看看例2的蹊跷在哪里�?br /> 在执行到�W?行时候，同例1一��P��x指向一个存�?Hello"的内存空间�?/font>

      变量x---->[存放�?Hello"]

      接下来执行第三行change(x)�Q�注意，�q�里��׃��?有了本质的不同：(x��)调用change(x)�Ӟ��变量i也指向了x指向的内存空��_(d��)��而不是指向x的一个拷贝�?/font>

      变量x "
              -->[存放�?Hello"]
      变量x /

      于是�Q�第7行对i调用append�Ҏ(gu��)��Q�改变i指向的内存空间的��|��x的��g��随之改变了�?/font>

      变量x "
              -->[�q�加�?Hello World!"]
      变量x /

      ��Z��么x��D��改变呢？因�ؓ(f��)�q�个例子是传引用的�?br /> �q�几个例子是明白了，可是很多��Z��(x��)开始有另一个疑问了�Q�这��L(f��ng)��来，到底什么时候是传的��g��么时候是传得引用呢？于是�Q�我们前面讲到的�c�d��和类在这里就�z�上了用�?strong>�Q?font color="#ff0000">对于参数传递，如果是简单数据类型，那么它传递的是值拷贝，对于�cȝ��实例它传递的是类的引用。需要注意的是，�q�条规则只适用于参��C��递�?/font>��Z��么这么说呢？我们看看�q�样一个例子：(x��)
//�?
String str="abcdefghijk";
str.replaceAll("b","B");
      �q�两句执行后�Q�str的内容依然是"abcdefghijk"�Q�但是我们明明是对str操作的，��Z��么是�q�样的呢�Q�因为str的值究竟会(x��)不会(x��)被改变完全取决于replaceAll�q�个�Ҏ(gu��)��是怎么实现的。类似的�Q�有�q�样一个例子：(x��)
//�?
1 void method1() {
2 StringBuffer x = new StringBuffer("Hello");
3 change1(x);
4 System.out.println(x);
5 }
6
7 void method2() {
8 StringBuffer x = new StringBuffer("Hello");
9 change2(x);
10 System.out.println(x);
11 }
12
13 void change1(StringBuffer sb) {
14 sb.append(" world!");
15 }
16
17 void change2(StringBuffer sb) {
18 sb = new StringBuffer("hi");
19 sb.append(" world!");
20 }
      调用method1()�Q�屏�q�打印结果�ؓ(f��)�Q?Hello world!"
调用method2()�Q�我们认为结果应该是"hi world"�Q�因为sb传进来的是引用。可是实际执行的�l�果�?Hello"�Q?br /> ��N��change2()又变成传��g��Q�！其实change1()和change2()的确都是通过参数传入引用�Q�但是在�Ҏ(gu��)��内部因�ؓ(f��)处理�Ҏ(gu��)��的不同而�ɾl�果大相径庭。我们还是从内存的角度分析：(x��)
执行method1()和change1()不用再多说了�Q�上面的例子已经讲解�q�，�q�里我们分析一下method2()和change2()�?br />       �E�序执行到第8行，x指向一个存攄��"Hello"的内存空间�?/font>

      变量x---->[存放�?Hello"]

      �W?行调用change2�Q�将sb指向x指向的内存空��_(d��)��也就是传入x的引用�?/font>

      变量x "
              -->[存放�?Hello"]
      变量x /

      到这里�ؓ(f��)止还没有什么异��P��接下来执�?8行，�q�里��出��C��c�M��传入值拷贝的变化�Q�new �Ҏ(gu��)��q�没有改变sb指向内存的内容，而是在内从中开辟了一块新的空间存放串"hi"�Q�同时sb指向了这块空间�?/font>

      变量x---->[存放�?Hello"]
            ×原有的引用被切断
      变量x---->[另一块存�?hi"的空间]

      接下来再对sb�q�行append已经和x没有��M��关系了�?br /> 所以，�q�有一条不成规则的规则�Q�对于函数调用，最�l�效果是什么完全看函数内部的实现。比较标准的做法是如果会(x��)改变引用的内容，则��用void作�ؓ(f��)�Ҏ(gu��)��q�回��|��而不�?x��)改变引用内容的则在�q�回��g��q�回新的倹{�?br /> 虽然已经说了�q�么多，但是感觉传��D��是传引用的问题依然没有完全说清楚。因��个问题本�w�就是很隑ֽ��U�x�ȝ��的问题，所以更多的理解要靠�q�x��的积累和形成。下面几个例子，�l�大家尝试进行分析�?br /> //�?�Q�打印结果是什么？
public static void main(String[] args) {
int a;
int b;
StringBuffer c;
StringBuffer d;
a = 0;
b = a;
c = new StringBuffer("This is c");
d = c;

a = 2;
c.append("!!");

System.out.println("a=" + a);
System.out.println("b=" + b);
System.out.println("c=" + c);
System.out.println("d=" + d);
}

//�?�Q�打印结果是什么？
public class Test{

        public static void main(String[] args) {

         StringBuffer sb = new StringBuffer("Hello ");

         System.out.println("Before change, sb = " + sb);

         changeData(sb);

         System.out.println("After changeData(n), sb = " + sb);

     }



        public static void changeData(StringBuffer strBuf) {

            StringBuffer sb2 = new StringBuffer("Hi ");

            strBuf = sb2;

            sb2.append("World!");

     }

}

如果本文�Ҏ(gu��)��有帮助�ƈ且要鼓励我的话，��h��描如下二�l�码支持本�h的劳动成果，多谢了！

lau 2009-03-24 18:21 发表评论

System.getProperty()

lau — Mon, 16 Mar 2009 06:54:00 GMT

System.getProperty()

1public class Information {
2    public static void main(String args[]) {
3        System.out.println("java_vendor:" + System.getProperty("java.vendor"));
4        System.out.println("java_vendor_url:"
5                + System.getProperty("java.vendor.url"));
6        System.out.println("java_home:" + System.getProperty("java.home"));
7        System.out.println("java_class_version:"
8                + System.getProperty("java.class.version"));
9        System.out.println("java_class_path:"
10                + System.getProperty("java.class.path"));
11        System.out.println("os_name:" + System.getProperty("os.name"));
12        System.out.println("os_arch:" + System.getProperty("os.arch"));
13        System.out.println("os_version:" + System.getProperty("os.version"));
14        System.out.println("user_name:" + System.getProperty("user.name"));
15        System.out.println("user_home:" + System.getProperty("user.home"));
16        System.out.println("user_dir:" + System.getProperty("user.dir"));
17        System.out.println("java_vm_specification_version:"
18                + System.getProperty("java.vm.specification.version"));
19        System.out.println("java_vm_specification_vendor:"
20                + System.getProperty("java.vm.specification.vendor"));
21        System.out.println("java_vm_specification_name:"
22                + System.getProperty("java.vm.specification.name"));
23        System.out.println("java_vm_version:"
24                + System.getProperty("java.vm.version"));
25        System.out.println("java_vm_vendor:"
26                + System.getProperty("java.vm.vendor"));
27        System.out
28                .println("java_vm_name:" + System.getProperty("java.vm.name"));
29        System.out.println("java_ext_dirs:"
30                + System.getProperty("java.ext.dirs"));
31        System.out.println("file_separator:"
32                + System.getProperty("file.separator"));
33        System.out.println("path_separator:"
34                + System.getProperty("path.separator"));
35        System.out.println("line_separator:"
36                + System.getProperty("line.separator"));
37    }
38}
39
常用的System.getProperty()�Q�这里脓(chu��ng)一下，省得下次�ȝ��.

From jdk 1.5.0 documents

java.version

Java �q�行时环境版�?/span>

java.vendor

Java �q�行时环境供应商

java.vendor.url

Java 供应商的 URL

java.home

Java 安装目录

java.vm.specification.version

Java 虚拟��范版�?/span>

java.vm.specification.vendor

Java 虚拟��范供应商

java.vm.specification.name

Java 虚拟��范名�U?/span>

java.vm.version

Java 虚拟机实现版�?/span>

java.vm.vendor

Java 虚拟机实��C��应商

java.vm.name

Java 虚拟机实现名�U?/span>

java.specification.version

Java �q�行时环境规范版�?/span>

java.specification.vendor

Java �q�行时环境规范供应商

java.specification.name

Java �q�行时环境规范名�U?/span>

java.class.version

Java �c�L��式版本号

java.class.path

Java �c��\�?/span>

java.library.path

加蝲库时搜烦的�\径列�?/span>

java.io.tmpdir

默认的��(f��)时文件�\�?/span>

java.compiler

要��用的 JIT �~�译器的名称

java.ext.dirs

一个或多个扩展目录的�\�?/span>

os.name

操作�pȝ��的名�U?/span>

os.arch

操作�pȝ��的架�?/span>

os.version

操作�pȝ��的版�?/span>

file.separator

文�g分隔�W�（�?UNIX �pȝ��中是“/”�Q?/span>

path.separator

路径分隔�W�（�?UNIX �pȝ��中是“:”�Q?/span>

line.separator

行分隔符�Q�在 UNIX �pȝ��中是“/n”�Q?/span>

user.name

用户的�̎户名�U?/span>

user.home

用户的主目录

user.dir

用户的当前工作目�?/span>

�pȝ��属性��g��的多个�\径是用��^台的路径分隔�W�分隔的

lau 2009-03-16 14:54 发表评论

java需要了解的东西

lau — Mon, 02 Mar 2009 06:32:00 GMT
     摘要: 1、forward 和redirect的区�?�{�：(x��)1.forward是服务器��h��资源�Q�服务器直接讉K��目标地址的URL�Q�把那个URL的响应内容读取过来，然后把这些内容再发给��览器，��览器根本不知道服务器发送的内容是从哪儿来的�Q�所以它的地址栏中�q�是原来的地址�?    redirect��是服务端根据逻辑,发送一个状态码,告诉��览器重新去��h��那个地址...  阅读全文

lau 2009-03-02 14:32 发表评论

java中static的作�?

lau — Mon, 02 Mar 2009 04:03:00 GMT
java中static的作�?
有时你希望定义一个类成员�Q��它的使用完全独立于该�cȝ��M��对象。通常情况下，�c�L��员必��通过它的�cȝ��对象讉K��Q�但是可以创��样一个成员，它能�? 被它自己使用�Q�而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)��p��创徏�q�样的成员。如果一个成员被声明为static�Q�它?y��u)��p�� 够在它的�cȝ��M��对象创徏之前被访问，而不必引用�Q何对象。你可以��方法和变量都声明�ؓ(f��)static。static 成员的最常见的例子是main( ) 。因为在�E�序开始执行时必须调用main() �Q�所以它被声明�ؓ(f��)static�?

声明为static的变量实质上��是全局变量。当声明一个对象时�Q��ƈ不��生static变量的拷贝，而是该类所有的实例变量��q��同一个static变量。声明�ؓ(f��)static的方法有以下几条限制�Q?
·
它们仅能调用其他的static �Ҏ(gu��)��?
·
它们只能讉K��static数据�?
·
它们不能以�Q何方式引用this 或super�Q�关键字super 与��承有养I��在下一章中描述�Q��?
如果你需要通过计算来初始化你的static变量�Q�你可以声明一个static块，Static 块仅在该�c�被加蝲时执行一�ơ。下面的例子昄��的类有一个static�Ҏ(gu��)��Q�一些static变量�Q�以�?qi��ng)一个static 初始化块�Q?
// Demonstrate static variables�Q�methods�Q�and blocks.

class UseStatic {
static int a = 3;
static int b;

static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);

}

static {
System.out.println("Static block initialized.");
b = a * 4;

}

public static void main(String args[]) {
meth(42);
}
}

一旦UseStatic �c�被装蝲�Q�所有的static语句被运行。首先，a被设�|��ؓ(f��)3�Q�接着static 块执�?打印一条消�?�Q�最后，b被初始化为a*4 �?2。然后调用main()�Q�main() 调用meth() �Q�把�?2传递给x�?个println ( ) 语句引用两个static变量a和b�Q�以�?qi��ng)局部变量x �?

注意�Q�在一个static �Ҏ(gu��)��中引用�Q何实例变量都是非法的�?

下面是该�E�序的输出：(x��)

Static block initialized.
x = 42
a = 3
b = 12
在定义它们的�cȝ��外面�Q�static �Ҏ(gu��)��和变量能独立于�Q何对象而被使用。这��P��你只要在�cȝ��名字后面加点可��符卛_��。例如，如果你希望从�c�d��面调用一个static�Ҏ(gu��)��Q�你可以使用下面通用的格式：(x��)

classname.method( )

�q�里�Q�classname 是类的名字，在该�c�M��定义static�Ҏ(gu��)��。可以看刎ͼ��q�种格式与通过对象引用变量调用非static�Ҏ(gu��)��的格式类伹{��一个static变量可以以同��L(f��ng)�� 格式来访问——类名加点号�q�算�W�。这��是Java 如何实现全局功能和全局变量的一个控制版本�?

下面是一个例子。在main() 中，static�Ҏ(gu��)��callme() 和static 变量b在它们的�c�M��外被讉K��?

class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {

System.out.println("a = " + a);
}
}

class StaticByName {

public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);

}
}

下面是该�E�序的输出：(x��)

a = 42
b = 99

static成员是不能被其所在class创徏的实例访问的�?/p>
如果不加static修饰的成员是对象成员�Q�也��是归每个对象所有的�?
加static修饰的成员是�c�L��员，��是可以�׃��个类直接调用�Q��ؓ(f��)所有对象共有的

lau 2009-03-02 12:03 发表评论

如何避免在Java中��用Checked Exception

lau — Tue, 17 Feb 2009 03:18:00 GMT

如何避免在Java中��用Checked Exception

发布旉��Q?007.08.20 08:52     来源�Q�赛�q�网    作者：(x��)dxaw

�q? ��文章指��Z��Java中checked Exception的一些缺点，提出应该在程序设计中避免使用checked Exception,对于需要处理checked Exception的代码，可以使用ExceptionAdapter�q�个�c�d��checked Exception�q�行包装。这��文章的概念和ExceptionAdapter�q�个�c�d��源自Bruce Eckel的Does Java need Checked Exception�?

Java的Exception分�ؓ(f��)两类�Q�一�c�L��RuntimeException�? 其子�c�，另外一�c�d��是checked Exception。Java要求函数�Ҏ(gu��)��有被catch处理掉的checked Exception�Q�需要将其写在函数的声明部分。然而，�q�一要求常常�l�程序员带来一些不必要的负担�?

��Z��避免在函数声明中写throws部分�Q�在Java��目里面常常可以看到以下代码用来‘吞掉’Exception�Q?

try {

// ...

} catch (Exception ex) {

ex.printStackTrace();

}

�q�显然不是一个好的处理Exception办法�Q�事实上�Q�catch�q�处理一个Exception意味着让程序从发生的错�?Exception)中恢复过来。从�q�种意义上说�Q�已上的代码只可能在一些很��单的情况下工作而不带来问题�?

对于很多Exception�Q�往往没有��d��理它�q�让�E�序从错误中恢复出来的办法，�q? 时唯一能做的事情可能就是在界面上显�C�Z��些提�C�Z��息给用户。这�U�情况下让程序抛出遇到的Exception是更为合理的做法。然而，�q�样做会(x��)使得一些函�? 的声明急剧膨胀。一个函数可能需要声明会(x��)抛出�?�?个checked Exception�Q�而且每个调用它的函数也需要同��L(f��ng)��声明�?

比这更糟�p�的是，�q�有可能破坏�c�设计的open-close原则。简单来 ��_(d��)��open-close原则是指当扩展一个模块的时候，可以不媄响其现有的client。open-close原则是通过�l�承来实现的�Q�当�l�承一个类�? 时候，我们既扩展了�q�个�c�，也不�?x��)媄响原有的client�Q�因为对�q�个�c�L��有改动）�?

现在考虑下面�q�种情况�Q�有一个父�c�Base�Q?

public class Base {

public void foo() throws ExceptionA {

// ...

}

}

现在需要��承Base�q�个�c�dƈ重蝲foo�q�个�Ҏ(gu��)��Q�在新的实现中，foo可能抛出ExceptionB�Q?

public class Extend extends Base {

public void foo() throws ExceptionB {

// ...

}

}

然而，�q�样写在Java里面是不合法的，因�ؓ(f��)Java把可能会(x��)抛出的Exception看作函数特征的一部分�Q�子�c�d��明抛出的Exception必须是父�cȝ��子集�?

可以在Base�cȝ��foo�Ҏ(gu��)��中加入抛出ExceptionB的声明，然而，�q�样��q��坏了open-close原则。而且�Q�有时我们没有办法去修改父类�Q�比如当重蝲一个Jdk里的�cȝ��时候�?

另一个可能的做法是在Extend的foo�Ҏ(gu��)��中catch住ExceptionB�Q�然后构造一个ExceptionA�q�抛出。这是个可行的办法但也只是一个权宜之计�?

如果使用RuntimeException�Q�这些问题都不会(x��)存在。这说明 checked Exception�q�不是一个很实用的概念，也意味着在程序设计的时候，我们应该让自��q��Exception�cȝ��承RuntimeException而不是Exception。（�q�和JDK的徏议正好相反，但实践证明这样做代码的质量更好。）

对于那些需要处理checked Exception的代码，可以利用一个ExceptionAdapter的类把checked Exception包装成一个RuntimeException抛出。ExceptionAdapter来自Bruce Eckel的Does Java need Checked Exception�q�篇文章�Q�在�q�里的ExceptionAdapter是我�Ҏ(gu��)��JDK 1.4修改�q�的�Q?

public class ExceptionAdapter extends RuntimeException {

public ExceptionAdapter(Exception ex) {

super(ex);

}

public void printStackTrace(java.io.PrintStream s) {

getCause().printStackTrace(s);

}

public void printStackTrace(java.io.PrintWriter s) {

getCause().printStackTrace(s);

}

// rethrow()的作用是把被包装的Exception再次抛出�?br />

public void rethrow()

throws Exception

{

throw (Exception) getCause();

}

}

�Q�责�ȝ��辑：(x��)�~�辑龚勋�Q?

lau 2009-02-17 11:18 发表评论

java.version	Java �q�行时环境版�?/span>
java.vendor	Java �q�行时环境供应商
java.vendor.url	Java 供应商的 URL
java.home	Java 安装目录
java.vm.specification.version	Java 虚拟��范版�?/span>
java.vm.specification.vendor	Java 虚拟��范供应商
java.vm.specification.name	Java 虚拟��范名�U?/span>
java.vm.version	Java 虚拟机实现版�?/span>
java.vm.vendor	Java 虚拟机实��C��应商
java.vm.name	Java 虚拟机实现名�U?/span>
java.specification.version	Java �q�行时环境规范版�?/span>
java.specification.vendor	Java �q�行时环境规范供应商
java.specification.name	Java �q�行时环境规范名�U?/span>
java.class.version	Java �c�L��式版本号
java.class.path	Java �c��\�?/span>
java.library.path	加蝲库时搜烦的�\径列�?/span>
java.io.tmpdir	默认的��(f��)时文件�\�?/span>
java.compiler	要��用的 JIT �~�译器的名称
java.ext.dirs	一个或多个扩展目录的�\�?/span>
os.name	操作�pȝ��的名�U?/span>
os.arch	操作�pȝ��的架�?/span>
os.version	操作�pȝ��的版�?/span>
file.separator	文�g分隔�W�（�?UNIX �pȝ��中是“/”�Q?/span>
path.separator	路径分隔�W�（�?UNIX �pȝ��中是“:”�Q?/span>
line.separator	行分隔符�Q�在 UNIX �pȝ��中是“/n”�Q?/span>
user.name	用户的�̎户名�U?/span>
user.home	用户的主目录
user.dir	用户的当前工作目�?/span>