欧美精品一区二区精品网,国产欧美一区二区三区久久,狠狠色香婷婷久久亚洲精品

java 提高性能

Snape — Wed, 11 Apr 2012 20:31:00 GMT

最�q�的机器内存又爆满了�Q�除了新增机器内存外�Q�还应该好好review一下我们的代码�Q�有很多代码�~�写�q�于随意化，�q�些不好的习惯或对程序语�a�的不了解是应该好好打压打压了�?/p>

下面是参考网�l�资源�ȝ��的一些在Java�~�程中尽可能要做到的一些地斏V�?br />

1. ��量在合适的场合使用单例

使用单例可以减轻加蝲的负担，�~�短加蝲的时��_��提高加蝲的效率，但�ƈ不是所有地斚w��适用于单例，��单来��_��单例主要适用于以下三个方面：

�W�一�Q�控制资源的使用�Q�通过�U�程同步来控制资源的�q�发讉K��Q?/div>

�W�二�Q�控制实例的产生�Q�以辑ֈ�节约资源的目的；

�W�三�Q�控制数据共享，在不建立直接兌��的条件下�Q�让多个不相关的�q�程或线�E�之间实现通信�?br />
2. ��量避免随意使用静态变�?/strong>

要知道，当某个对象被定义为stataic变量所引用�Q�那么gc通常是不会回收这个对象所占有的内存，�?/div>
Java代码
public class A{
static B b = new B();
}

此时静态变量b的生命周期与A�c�d��步，如果A�c�M��会卸载，那么b对象会常��d��存，直到�E�序�l�止�?br />
3. ��量避免�q�多�q�常的创建Java对象
��量避免在经常调用的�Ҏ��Q��@环中new对象�Q�由于系�l�不仅要��p��旉��来创建对象，而且�q�要花时间对�q�些对象�q�行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象�Q�最好能用基本的数据�c�d��或数�l�来替代对象�?/div>
4. ��量使用final修饰�W?/strong>
带有final修饰�W�的�c�L��不可�z��的。在Java核心API中，有许多应用final的例子，例如java.lang.String。�ؓString�c�L��定final防止了��用者覆盖length()�Ҏ��。另外，如果一个类是final的，则该�c�L��有方法都是final的。Java�~�译器会��L��Z��内联�Q�inline�Q�所有的final�Ҏ��Q�这和具体的�~�译器实现有养I��。此举能够��性能�q�_��提高50%�?br />
5. ��量使用局部变�?/strong>
调用�Ҏ��时传递的参数以及在调用中创徏的��时变量都保存在栈�Q�Stack�Q�中�Q�速度较快。其他变量，如静态变量、实例变量等�Q�都在堆�Q�Heap�Q�中创徏�Q�速度较慢�?br />
6. ��量处理好包装类型和基本�c�d��两者的使用场所
虽然包装�c�d��和基本类型在使用�q�程中是可以�怺�转换�Q�但它们两者所产生的内存区域是完全不同的，基本�c�d��数据产生和处理都在栈中处理，包装�c�d��是对象，是在堆中产生实例�?/div>
在集合类对象�Q�有对象斚w��需要的处理适用包装�c�d��Q�其他的处理提倡��用基本类型�?br />
7. 慎用synchronized�Q�尽量减��synchronize的方�?/strong>
都知道，实现同步是要很大的系�l�开销作�ؓ代�h的，甚至可能造成死锁�Q�所以尽量避免无谓的同步控制。synchronize�Ҏ��被调用时�Q�直接会把当前对象锁了，在方法执行完之前其他�U�程无法调用当前对象的其他方法。所以synchronize的方法尽量小�Q��ƈ且应��量使用�Ҏ��同步代替代码块同步�?br />
8. ��量使用StringBuilder和StringBuffer�q�行字符串连�?/strong>
�q�个��׃��多讲了�?br />
9. ��量不要使用finalize�Ҏ��
实际上，��资源清理放在finalize�Ҏ��中完成是非常不好的选择�Q�由于GC的工作量很大�Q�尤其是回收Young代内存时�Q�大都会引�v应用�E�序暂停�Q�所以再选择使用finalize�Ҏ��q�行资源清理�Q�会��D��GC负担更大�Q�程序运行效率更差�?br />
10. ��量使用基本数据�c�d��代替对象
String str = "hello";
上面�q�种方式会创��Z��?#8220;hello”字符�Ԍ��而且JVM的字�W�缓存池�q�会�~�存�q�个字符�Ԍ��
String str = new String("hello");
此时�E�序除创建字�W�串外，str所引用的String对象底层�q�包含一个char[]数组�Q�这个char[]数组依次存放了h,e,l,l,o
11. 单线�E�应��量使用HashMap、ArrayList
HashTable、Vector�{��用了同步机制�Q�降低了性能�?br />
12. ��量合理的创建HashMap
当你要创��Z��个比较大的hashMap�Ӟ��充分利用另一个构造函�?/div>
public HashMap(int initialCapacity, float loadFactor)
避免HashMap多次�q�行了hash重构,扩容是一件很耗费性能的事�Q�在默认中initialCapacity只有16�Q�而loadFactor�?0.75�Q�需要多大的定w��Q�你最好能准确的估计你所需要的最佛_��，同样的Hashtable�Q�Vectors也是一��L��道理�?br />
13. ��量减少对变量的重复计算
�?/div>
for(int i=0;i
应该改�ؓ
for(int i=0,len=list.size();i
�q�且在��@环中应该避免使用复杂的表辑ּ��Q�在循环中，循环条�g会被反复计算�Q�如果不使用复杂表达式，而��循环条�g��g��变的话，�E�序��会�q�行的更快�?nbsp;
14. ��量避免不必要的创徏
�?/div>
A a = new A();
if(i==1){list.add(a);}
应该改�ؓ
if(i==1){
A a = new A();
list.add(a);}
15. ��量在finally块中释放资源
�E�序中��用到的资源应当被释放�Q�以避免资源泄漏。这最好在finally块中��d��。不��程序执行的�l�果如何�Q�finally块��L��会执行的�Q�以��保资源的正��关闭�?nbsp;
16. ��量使用�U�M��来代�?a/b'的操�?/strong>
"/"是一个代价很高的操作�Q��用移位的操作��会更快和更有效
�?/div>
int num = a / 4;
int num = a / 8;
应该改�ؓ
int num = a >> 2;
int num = a >> 3;
但注意的是��用移位应��d��注释�Q�因为移位操作不直观�Q�比较难理解
17.��量使用�U�M��来代�?a*b'的操�?/strong>
同样的，对于'*'操作�Q��用移位的操作��会更快和更有效
�?/div>
int num = a * 4;
int num = a * 8;
应该改�ؓ
int num = a << 2;
int num = a << 3;
18. ��量��定StringBuffer的容�?/strong>
StringBuffer 的构造器会创��Z��个默认大��（通常�?6�Q�的字符数组。在使用中，如果��出�q�个大小�Q�就会重新分配内存，创徏一个更大的数组�Q��ƈ��原先的数组复制�q�来�Q�再丢弃旧的数组。在大多数情况下�Q�你可以在创�?StringBuffer的时候指定大��，�q�样��避免了在容量不够的时候自动增长，以提高性能�?nbsp;
如：StringBuffer buffer = new StringBuffer(1000);
19. ��量早释放无用对象的引用
大部分时�Q�方法局部引用变量所引用的对�?会随着�Ҏ��l�束而变成垃圾，因此�Q�大部分时候程序无需��局部，引用变量昑ּ�设�ؓnull�?/div>
例如�Q?/div>
Java代码
Public void test(){
Object obj = new Object();
……
Obj=null;
}

上面�q�个��没必要了，随着�Ҏ��test()的执行完成，�E�序中obj引用变量的作用域��q��束了。但是如果是�Ҏ��下面�Q?/div>
Java代码
Public void test(){
Object obj = new Object();
……
Obj=null;
//执行耗时�Q�耗内存操作；或调用耗时�Q�耗内存的�Ҏ��
……
}

�q�时候就有必要将obj赋��gؓnull�Q�可以尽早的释放对Object对象的引用�?br />
20. ��量避免使用二维数组
二维数据占用的内存空间比一�l�数�l�多得多�Q�大�?0倍以上�?br />
21. ��量避免使用split
除非是必��ȝ��Q�否则应该避免��用split�Q�split�׃��支持正则表达式，所以效率比较低�Q�如果是频繁的几十，几百万的调用��会耗费大量资源�Q�如果确实需要频�J�的调用split�Q�可以考虑使用apache的StringUtils.split(string,char)�Q�频�J�split的可以缓存结果�?br />
22. ArrayList & LinkedList
一个是�U�性表�Q�一个是链表�Q�一句话�Q�随机查询尽量��用ArrayList�Q�ArrayList优于LinkedList�Q�LinkedList�q�要�U�d��?针，��d��删除的操作LinkedList优于ArrayList�Q�ArrayList�q�要�U�d��数据�Q�不�q�这是理论性分析，事实未必如此�Q�重要的是理解好2 者得数据�l�构�Q�对症下药�?br />
23. ��量使用System.arraycopy ()代替通过来��@环复制数�l?/strong>
System.arraycopy() 要比通过循环来复制数�l�快的多
24. ��量�~�存�l�常使用的对�?/strong>
��可能将�l�常使用的对象进行缓存，可以使用数组�Q�或HashMap的容器来�q�行�~�存�Q�但�q�种方式可能��D��pȝ��占用�q�多的缓存，性能下降�Q�推荐可以��用一些第三方的开源工��P��如EhCache�Q�Oscache�q�行�~�存�Q�他们基本都实现了FIFO/FLU�{�缓存算法�?br />
25. ��量避免非常大的内存分配
有时候问题不是由当时的堆状态造成的，而是因�ؓ分配��p�|造成的。分配的内存块都必须是连�l�的�Q�而随着堆越来越满，扑ֈ�较大的连�l�块��来��困难�?br />
26. 慎用异常
当创��Z��个异常时�Q�需要收集一个栈跟踪(stack track)�Q�这个栈跟踪用于描述异常是在何处创徏的。构��些栈跟踪旉��要�ؓ�q�行时栈做一份快照，正是�q�一部分开销很大。当需要创��Z��?Exception �Ӟ��JVM 不得不说�Q�先别动�Q�我惛_��您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含�q�行时栈中的一两个元素�Q�而是包含�q�个栈中的每一个元素�?/div>
�?果您创徏一�?Exception �Q�就得付��Z��仗��好在捕获异常开销不大�Q�因此可以��?try-catch ��核心内容包��h��。从技术上�Ԍ��您甚臛_��以随意地抛出异常�Q�而不用花费很大的代�h。招致性能损失的�ƈ不是 throw 操作——��管在没有预先创建异常的情况下就抛出异常是有点不��d��。真正要�׃��L��是创建异常。幸�q�的是，好的�~�程习惯已教会我们，不应该不��三七二十一��?抛出异常。异常是为异常的情况而设计的�Q��用时也应该牢记这一原则�?/div>

Snape 2012-04-12 04:31 发表评论

java中clone�Q�）

Snape — Wed, 11 Apr 2012 06:08:00 GMT

目录

预备知识
��Z��么要clone
Object的clone以及��Z��么如此实�?nbsp;
如何clone
对clone的态度
其他的选择
和Serializable的比�?nbsp;
性能

预备知识

��Z��理解java的clone�Q�有必要先温习以下的知识�?nbsp;
java的类型，java的类型分��Z��大类�Q�一�c�Mؓprimitive�Q�如int�Q�另一�c�Mؓ引用�c�d��,如String,Object�{�等�?nbsp;
java引用�c�d��的存储，java的引用类型都是存储在堆上�?/span>
public class B { int a; String b; public B(int a, String b) { super(); this.a = a; this.b = b; } }

对这样一个引用类型的实例�Q�我们可以推��，在堆上它的内存存储�Ş式（除去指向class的引用，锁的��理�{�等内务事务所占内存）�Q�应该有一个int��D��C�a,以及一个引用，该引用指向b在堆上的存储�I�间�?nbsp;

��Z��么要clone

恩，因�ؓ需要。废话�?nbsp;
有名的GoF设计模式里有一个模式�ؓ原型模式�Q�用原型实例指定创徏对象的种�c?�q�且通过拯��q�些原型创徏新的对象.
��单的说就是clone一个对象实例。��得clone出来的copy和原有的对象一模一栗��?nbsp;

插一个简单��用clone的例子，如果一个对象内部有可变对象实例的话�Q�public API不应该直接返回该对象的引用，以防调用方的code改变该对象的内部状态。这个时候可以返回该对象的clone�?nbsp;

问题来了�Q�什么叫一模一栗��?nbsp;
一般来��_��?nbsp;
x.clone() != x
x.clone().getClass() == x.getClass()
x.clone().equals(x)
但是�q�些都不是强制的�?nbsp;
我们需要什么样的clone��搞��Z��么样的clone好了�?nbsp;
一般而言�Q�我们要的clone应该是这��L��。copy和原型的内容一��P��但是又是彼此隔离的。即在clone之后�Q�改变其中一个不影响另外一个�?nbsp;

Object的clone以及��Z��么如此实�?/strong>

Object的clone的行为是最��单的。以堆上的内存存储解释的话（不计内务内存�Q�，对一个对象a的clone��是在堆上分配一个和a在堆上所占存储空间一样大的一块地方，然后把a的堆上内存的内容复制到这个新分配的内存空间上�?nbsp;
看例子�?nbsp;
class User { String name; int age; } class Account implements Cloneable { User user; long balance; @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } }

// user. User user = new User(); user.name = "user"; user.age = 20; // account. Account account = new Account(); account.user = user; account.balance = 10000; // copy. Account copy = (Account) account.clone(); // balance因�ؓ是primitive�Q�所以copy和原型是相等且独立的�? Assert.assertEquals(copy.balance, account.balance); copy.balance = 20000; // 改变copy不媄响原型�? Assert.assertTrue(copy.balance != account.balance); // user因�ؓ是引用类型，所以copy和原型的引用是同一的�? Assert.assertTrue(copy.user == account.user); copy.user.name = "newName"; // 改变的是同一个东�ѝ�? Assert.assertEquals("newName", account.user.name);

恩，默认实现是帮了我们一些忙�Q�但是不是全部�?nbsp;
primitive的确做到了相�{�且隔离�?nbsp;
引用�c�d��仅仅是复制了一下引用，copy和原型引用的东西是一��L��?nbsp;
�q�个��是所谓的��copy了�?nbsp;
要实现深copy�Q�即复制原型中对象的内存copy�Q�而不仅仅是一个引用。只有自己动手了�?nbsp;
�{�等�Q�是不是所有的引用�c�d��都需要深copy呢？
不是�Q?nbsp;
我们之所以要深copy�Q�是因�ؓ默认的实现提供的��copy不是隔离的，换言之，改变copy的东西，会媄响到原型的内部。比如例子中�Q�改变copy的user的name�Q�媄响了原型�?nbsp;
如果我们要copy的类是不可变的呢�Q�如String�Q�没有方法可以改变它的内部状态呢�?nbsp;
class User implements Cloneable { String name; int age; @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } }

// user. User user = new User(); user.name = "user"; user.age = 20; // copy User copy = (User) user.clone(); // age因�ؓ是primitive�Q�所以copy和原型是相等且独立的�? Assert.assertEquals(copy.age, user.age); copy.age = 30; // 改变copy不媄响原型�? Assert.assertTrue(copy.age != user.age); // name因�ؓ是引用类型，所以copy和原型的引用是同一的�? Assert.assertTrue(copy.name == user.name); // String��Z��可变�c�R��没有办法可以通过对copy.name的字�W�串的操作改变这个字�W�串�? // 改变引用新的对象不会影响原型�? copy.name = "newname"; Assert.assertEquals("newname", copy.name); Assert.assertEquals("user", user.name);
可见�Q?/span>在考虑clone�Ӟ��primitive和不可变对象�c�d��是可以同�{�对待的�?nbsp;

java��Z��么如此实现clone呢？
也许有以下考虑�?nbsp;
1 效率和简单性，��单的copy一个对象在堆上的的内存比遍历一个对象网然后内存深copy明显效率高�ƈ且简单�?nbsp;
2 不给别的�c�d��加意义。如果A实现了Cloneable�Q�同时有一个引用指向B�Q�如果直接复制内存进行深copy的话�Q�意味着B在意义上也是支持Clone的，但是�q�个是在使用B的A中做的，B甚至都不知道。破坏了B原有的接口�?nbsp;
3 有可能破坏语义。如果A实现了Cloneable�Q�同时有一个引用指向B�Q�该B实现为单例模式，如果直接复制内存�q�行深copy的话�Q�破坏了B的单例模式�?nbsp;
4 方便且更灉|��Q�如果A引用一个不可变对象�Q�则内存deep copy是一�U�浪贏V��Shadow copy�l�了�E�序员更好的灉|��性�?nbsp;

如何clone
clone三部曌Ӏ?nbsp;
1 声明实现Cloneable接口�?nbsp;
2 调用super.clone拿到一个对象，如果父类的clone实现没有问题的话�Q�在该对象的内存存储中，所有父�c�d��义的field都已�l�clone好了�Q�该�c�M��的primitive和不可变�c�d��引用也克隆好了，可变�c�d��引用都是��copy�?nbsp;
3 把浅copy的引用指向原型对象新的克隆体�?nbsp;
�l�个例子�?nbsp;
class User implements Cloneable { String name; int age; @Override public User clone() throws CloneNotSupportedException { return (User) super.clone(); } } class Account implements Cloneable { User user; long balance; @Override public Account clone() throws CloneNotSupportedException { Account account = null; account = (Account) super.clone(); if (user != null) { account.user = user.clone(); } return account; } }

对clone的态度

clone嘛，我觉得是个好东西�Q�毕竟系�l�默认实现已�l�帮我们做了很多事情了�?nbsp;
但是它也是有�~�点的�?nbsp;
1 手工�l�护clone的调用链。这个问题不大，�E�序员有责�Q做好�?nbsp;
2 如果class的field是个final的可变类�Q�就不行了。三部曲的第三步没有办法做了�?nbsp;

考虑一个类对clone的态度�Q�有如下几种�?nbsp;
1 公开支持�Q�好吧，按照clone三部曲实现吧。前提是父类支持�Q�公开或者默默）�?nbsp;
2 默默支持�Q�不实现Cloneable接口�Q�但是在�c�里面有正确的protected的clone实现�Q�这��P��该类不支持clone�Q�但是它的子�c�d��果想支持的话也不妨碍�?nbsp;
3 不支持：好吧�Q��ؓ了明��该目的�Q�提供一个抛CloneNotSupportedException 异常的protected的clone实现�?nbsp;
4 看情冉|��持：该类内部可以保存其他�cȝ��实例�Q�如果其他类支持则该�c�L��持，如果其他�c�M��支持�Q�该�c�L��有办法，只有不支持�?nbsp;

其他的选择

可以用原型构造函敎ͼ�或者静态copy�Ҏ��来手工制作一个对象的copy�?nbsp;
好处是即使class的field为final�Q�也不会影响该方法的使用。不好的地方是所有的primitive赋值都得自��q��护�?nbsp;

和Serializable的比�?/strong>

使用Serializable同样可以做到对象的clone。但是：
Cloneable本��n��是为clone设计的，虽然有一些缺点，但是如果它可以clone的话无疑用它来做clone比较合适。如果不行的话用原型构造函敎ͼ�或者静态copy�Ҏ��也可以�?nbsp;

Serializable制作clone的话�Q�添加了太多其它的东西，增加了复杂性�?nbsp;
1 所有的相关的类都得支持Serializable。这个相比支持Cloneable只会工作量更�?nbsp;
2 Serializable��d��了更多的意义�Q�除了提供一个方法用Serializable制作Clone�Q�该�cȝ��于也��d��了其它的public API�Q�如果一个类实现了Serializable�Q�等于它�?�q�制形式��已�l�是其API的一部分了，不便于该�c�M��后内部的改动�?nbsp;
3 当类用Serializable来实现clone�Ӟ��用户如果保存了一个老版本的对象2�q�制�Q�该�c�d��U�，用户用新版本的类反系列化该对象，再调用该对象用Serializable实现的clone。这里�ؓ了一个clone的方法又引入了类版本兼容性的问题。不划算�?nbsp;

性能

不可否认�Q�JVM��来��快了�?nbsp;
但是�pȝ��默认的native实现�q�是挺快的�?nbsp;
clone一个有100个元素的int数组�Q�用�pȝ��默认的clone比静态copy�Ҏ��?倍左叟�?/span>

Snape 2012-04-11 14:08 发表评论

java instance�Q�）

Snape — Wed, 11 Apr 2012 06:07:00 GMT

java 中的instanceof �q�算�W�是用来在运行时指出对象是否是特定类的一个实例。instanceof通过�q�回一个布��值来指出�Q�这个对象是否是�q�个特定�c�L��者是它的子类的一个实例�?br /> 用法�Q?br />result = object instanceof class
参数�Q?br />Result�Q�布��类型�?br />Object�Q�必选项。�Q意对象表辑ּ��?br />Class�Q�必选项。�Q意已定义的对象类�?br />说明�Q?br />如果 object �?class 的一个实例，�?instanceof �q�算�W�返�?true。如�?object 不是指定�cȝ��一个实例，或�?object �?null�Q�则�q�回 false�?/p>
例子如下�Q?/p>

package com.instanceoftest;
interface A{}
class B implements A{

}
class C extends B {

}

class instanceoftest {
public static void main(String[] args){
     A a=null;
     B b=null;
     boolean res;

     System.out.println("instanceoftest test case 1: ------------------");
       res = a instanceof A;
       System.out.println("a instanceof A: " + res);

       res = b instanceof B;
       System.out.println("b instanceof B: " + res);

     System.out.println("\ninstanceoftest test case 2: ------------------");
     a=new B();
     b=new B();

     res = a instanceof A;
     System.out.println("a instanceof A: " + res);

     res = a instanceof B;
     System.out.println("a instanceof B: " + res);
     res = b instanceof A;
     System.out.println("b instanceof A: " + res);

     res = b instanceof B;
     System.out.println("b instanceof B: " + res);

     System.out.println("\ninstanceoftest test case 3: ------------------");
     B b2=(C)new C();

     res = b2 instanceof A;
     System.out.println("b2 instanceof A: " + res);

     res = b2 instanceof B;
     System.out.println("b2 instanceof B: " + res);

     res = b2 instanceof C;
     System.out.println("b2 instanceof C: " + res);
}
}

/*
result:

instanceoftest test case 1: ------------------
a instanceof A: false
b instanceof B: false
instanceoftest test case 2: ------------------
a instanceof A: true
a instanceof B: true
b instanceof A: true
b instanceof B: true
instanceoftest test case 3: ------------------
b2 instanceof A: true
b2 instanceof B: true
b2 instanceof C: true

Snape 2012-04-11 14:07 发表评论

Snape — Wed, 11 Apr 2012 06:06:00 GMT
     摘要: 对于JAVA�~�程和很多类似C、C++语言有一个巨大区别就是内存不需要自己去free或者delete�Q�而是由JVM垃圾回收机制��d��成的。对于这个过�E�很多�h一直比较茫然或者觉得很��Q��得在写程序的�q�程不太考虑它的感受�Q�其实知道一些内在的原理�Q�帮助我们编写更加优�U�的代码是非常有必要的。本文从以下几个斚w��q�行阐述�Q?、finalize()�Ҏ��2、System.gc()�Ҏ��及一些实用方�?�?..  阅读全文

Snape 2012-04-11 14:06 发表评论

Snape — Wed, 11 Apr 2012 06:05:00 GMT

1.Duplicated Code
　　代码重复几乎是最常见的异味了。他也是Refactoring的主要目标之一。代码重复往往来自于copy-and-paste的编�E�风根{��与他相对应OAOO是一个好�pȝ��的重要标志�?/p>
　　2.Long method
　　它是传统�l�构化的“遗毒”。一个方法应当具有自我独立的意图�Q�不要把几个意图攑֜�一赗��?/p>
　　3.Large Class
　　大类��是你把太多的责��M��l�了一个类。这里的规则是One Class One Responsibility.
　　4.Divergent Change
　　一个类里面的内容变化率不同。某些状态一个小时变一�ơ，某些则几个月一�q�才变一�ơ；某些状态因��斚w��的原因发生变化，而另一些则因�ؓ其他斚w��的原因变一�ơ。面向对象的抽象��是把相对不变的和相对变化相隔离。把问题变化的一斚w��和另一斚w��盔R��R��这使得�q�些相对不变的可以重用。问题变化的每个斚w��都可以单独重用。这�U�相异变化的共存使得重用非常困难�?/p>
　　5.Shotgun Surgery
　　�q�正好和上面相反。对�pȝ��一个地方的改变涉及到其他许多地方的相关改变。这些变化率和变化内容相似的状态和行�ؓ通常应当攑֜�同一个类中�?/p>
　　6.Feature Envy
　　对象的目的就是封装状态以及与�q�些状态紧密相关的行�ؓ。如果一个类的方法频�J�用get �Ҏ��存取其他�cȝ��状态进行计��，那么你要考虑把行为移到涉及状态数目最多的那个�c�R�?/p>
　　7.Data Clumps
　　某些数据通常像孩子一��h��玩耍：一起出现在很多�cȝ��成员变量中，一起出现在许多�Ҏ��的参��C��Q�这些数据或许应该自��q��立�Ş成对象�?/p>
　　8.Primitive Obsession
　　面向对象的新手通常习惯使用几个原始�c�d��的数据来表示一个概��c��譬如对于范��_��他们会��用两个数字。对于Money�Q�他们会用一个��Q�Ҏ��来表�C�。因��Z��没有使用对象来表��N��题中存在的概念，�q��得代码变的难以理解，解决问题的难度大大增加。好的习惯是扩充语言所能提供原始类型，用小对象来表�C��围、金额、�{化率、邮政编码等�{��?/p>
　　9.Switch Statement
　　��Z��帔R��的开兌��句是OO 的大敌，你应当把他变为子�c�R��state或strategy.
　　10. Parallel Inheritance Hierarchies
　　�q�行的��承层�ơ是shotgun surgery的特�D�情��c��因为当你改变一个层�ơ中的某一个类�Ӟ��你必��d��时改变另外一个层�ơ的�q�行子类�?/p>
　11. Lazy Class
　　一个干�z�M��多的�c�R��类的维护需要额外的开销�Q�如果一个类承担了太��的责�Q�Q�应当消除它�?/p>
　　12. Speculative Generality
　　一个类实现了从未用到的功能和通用性。通常�q�样的类或方法唯一的用��h��testcase.不要犹��U�Q�删除它�?/p>
　　13. Temporary Field
　　一个对象的属性可能只在某些情况下才有意义。这��L��代码��难以理解。专门徏立一个对象来持有�q�样的孤儿属性，把只和他相关的行为移到该�c�R��最常见的是一个特定的��法需要某些只有该��法才有用的变量�?/p>
　　14. Message Chain
　　消息铑֏�生于当一个客户向一个对象要求另一个对象，然后客户又向�q�另一对象要求另一个对象，再向�q�另一个对象要求另一个对象，如此如此。这�Ӟ��你需要隐藏分�z��?/p>
　　15. Middle Man
　　对象的基本特性之一��是��装�Q�而你�l�常会通过分派��d��现封装。但是这一步不能走得太�q�，如果你发��C��个类接口的一大半�Ҏ��都在做分�z�，你可能需要移去这个中间�h�?/p>
　　16. Inappropriate Intimacy
　　某些�cȝ��互之间太亲密�Q�它们花费了太多的时间去砖研别�h的私有部分。对人类而言�Q�我们也�怸�应该太假正经�Q�但我们应当让自��q��c�M��格遵守禁�Ʋ主义�?/p>
　　17. Alternative Classes with Different Interfaces
　　做相同事情的�Ҏ��有不同的函数signature�Q�一致把它们往�c�d��ơ上�U�，直至协议一致�?/p>
　　18. Incomplete Library Class
　　要徏立一个好的类库非常困难。我们大量的�E�序工作都基于类库实现。然而，如此�q�泛而又相异的目标对库构��提��Z��苛刻的要求。库构徏者也不是万能的。有时候我们会发现库类无法实现我们需要的功能。而直接对库类的修�Ҏ��非常困难。这时候就需要用各种手段�q�行Refactoring.
　　19. Data Class
　　对象包括状态和行�ؓ。如果一个类只有状态没有行为，那么肯定有什么地方出问题了�?/p>
　　20. Refused Bequest
　　��类传下来很多行为和状态，而子�c�d��是用了其中的很小一部分。这通常意味着你的�c�d��ơ有问题�?/p>
　　21. Comments
　　�l�常觉得要写很多注释表示你的代码难以理解。如果这�U�感觉太多，表示你需要Refactoring.

Snape 2012-04-11 14:05 发表评论

java启动方式

Snape — Wed, 11 Apr 2012 06:01:00 GMT

使用 -classpath 选项:
java -classpath C:\hello\build\classes test.HelloWorld
使用 -cp 选项,  -classpath 的简�?
java -cp C:\hello\build\classes test.HelloWorld
使用 -Djava.class.path 讄��pȝ��属�?
java -Djava.class.path=C:\hello\build\classes test.HelloWorld
使用 CLASSPATH 讄��环境变量:
set CLASSPATH=C:\hello\build\classes; java test.HelloWorld
使用当前目录为启动目�?
cd C:\hello\build\classes; java test.HelloWorld
打包所有类�q�入一个jar包中�Q��ƈ讄��对应�?code> META-INF/MANIFEST.MF 文�g
文�g内容�Q?span style="color: #ff0000; ">Main-Class: test.HelloWorld
java -jar hello-world.jar
注意�Q�当使用-jar选项�Ӟ��-classpath -cp�q�两个选项��被忽略�Q?/li>
写Bash文�g�q�行加蝲
如果你��用的是JDK6�Q�加载类路径�q�支�?通配�W�加载所有jar文�g�Q�java -cp ./lib/* test.HelloWorld

Snape 2012-04-11 14:01 发表评论

java启动方式

Snape — Wed, 11 Apr 2012 06:01:00 GMT

使用 -classpath 选项:
java -classpath C:\hello\build\classes test.HelloWorld
使用 -cp 选项,  -classpath 的简�?
java -cp C:\hello\build\classes test.HelloWorld
使用 -Djava.class.path 讄��pȝ��属�?
java -Djava.class.path=C:\hello\build\classes test.HelloWorld
使用 CLASSPATH 讄��环境变量:
set CLASSPATH=C:\hello\build\classes; java test.HelloWorld
使用当前目录为启动目�?
cd C:\hello\build\classes; java test.HelloWorld
打包所有类�q�入一个jar包中�Q��ƈ讄��对应�?code> META-INF/MANIFEST.MF 文�g
文�g内容�Q?span style="color: #ff0000; ">Main-Class: test.HelloWorld
java -jar hello-world.jar
注意�Q�当使用-jar选项�Ӟ��-classpath -cp�q�两个选项��被忽略�Q?/li>
写Bash文�g�q�行加蝲
如果你��用的是JDK6�Q�加载类路径�q�支�?通配�W�加载所有jar文�g�Q�java -cp ./lib/* test.HelloWorld

Snape 2012-04-11 14:01 发表评论

Snape — Wed, 11 Apr 2012 06:00:00 GMT

隐藏�Q�hide�Q�：子类的某个字�D�c��静态方法、成员内部类与其父类的具有相同名字（对于静态方法还需要相同的参数列表�Q�，此时父类对应的字�D�c��静态方法、成员内部类��p��隐藏了�?/p>
举个例子�Q�天鹅（Swan�Q�是会飞的，而丑��鸭�Q�UglyDuck�Q�小时候是不会飞的�Q�看看下面的代码�Q�看看能够打印出什么�?/p>
class Swan {
    public static void fly() {
        System.out.println("swan can fly ...");
    }
}

class UglyDuck extends Swan {
    public static void fly() {
        System.out.println("ugly duck can't fly ...");
    }
}

public class TestFly {
    public static void main(String [] args) {
        Swan swan = new Swan();
        Swan uglyDuck = new UglyDuck();
        swan.fly();
        uglyDuck.fly();
    }
}

按道理的话，我们认�ؓ应该是输��Z��句不同的�l�果�Q�因为我们可能认�?UglyDuck �l�承�?Swan �q�且“重写”�?fly() �Ҏ��Q�而且�?main() �Ҏ��?Swan uglyDuck = new UglyDuck(); 也表明了 uglyduck 实际上是 UglyDuck �c�d��的，因此构成了多态行为�?/p>
其实�Q�运行结果是两句“swan can fly ...”�Q��ؓ什么会�q�样子？原因有下�Q?/p>
1、父�c?Swan 中的 static 静态方�?fly() 是不能被重写的，上一�D�|��寚w��写二字用了双引号�Q?/p>
2、尽��子�c?UglyDuck 中的 fly() �Ҏ��与父�c�M��的有一致的参数列表�Q�但是对�?static �Ҏ��来说�Q�这叫隐藏（hide�Q�，而不是重写（override�Q�；
3、对�?static �Ҏ��Q�根本不存在像多态那��L��动态分�z�机�Ӟ��JVM 不会�Ҏ��对象引用的实际类型来调用对应的重写方法。这一点在个例子中是最重要的�?/p>
对于 static �Ҏ��Q�我们称之�ؓ�c�L��?/strong>�Q�不�?strong>实例�Ҏ���Q�对 static �Ҏ��的调用直接用所属类名加个点��p��Q�如 UglyDuck.fly() 。而实例方法就不得不��用对象引用来获得其可讉K��Ҏ��的调用权。在上面的例�?main() 中的 uglyDuck.fly() 语句�Q�JVM �Ҏ��据不会去判断 uglyDuck 引用的究竟是什么类型，既然调用的是 fly() �Ҏ��Q�那�?JVM 只会�Ҏ�� uglyDuck 的声明类型（�?Swan �c�）去获得该 static �Ҏ��的调用。根本就谈不上多�?#8230;
�q�就说明�Q?strong>最好避免用对象引用的方式来讉K��一�?static �Ҏ��。此外，别以为在�l�承关系上的父类、子�c�d��要方法名、参数列表一致就是重写（override�Q�而构成多态，其实�q�得看看父类中的�Ҏ��有没有被什么修饰符声明�Q�在�q�个例子中是 static 修饰的）。再�?final 修饰�W�的�Ҏ��则表明不可被子类重写�Q�即�Ҏ��名、参数列表不能和父类完全一致。在我看来，�q�一�c�M��饰符��p��明了�Ҏ��、变量、字�D늭��Ҏ��的性质�Q�或者是�w�䆾�?/p>
对于隐藏�Q�hide�Q�，实际上是��Z��使得父类中的该方法、字�D�c��内部类�{�不允许再被下一�U��承树的子子类所�l�承。说起隐藏，我想赗��代码大�?2》当中刚好看�q�的内容�Q�作者认为把握住信息隐藏的原则来思考��Y件构��优于面向对象原则。有�Ҏ��象难懂，书中�q�讲到封装、模块化和抽象等几个概念�Q�徏议看看，我也要回�q�头��d��啃啃�q�些抽象概念�?/p>
要修改上面代码，只需要去掉两�?static 则可�Q�那��构成多态了。《Java 解惑》中其他谜题�q�讲到多�U�该注意的地方，可以看看�?/p>
��结�Q?/strong>
1、注意掌握重写（override�Q�与隐藏�Q�hide�Q�的异同点：相同点就是两者都是相对于�l�承树中父类、子�c�L��_��而不同点��是其目的以及所造成的效果。别把重写和隐藏��h��在一起了�Q?/p>
2、对�?static �Ҏ��Q�要避免用具体的对象引用来调用，而应该简单的用其所属类名进行调用即可�?/p>
遮蔽�Q�shadow�Q�：其实��是�q�x��我们可能遇到的窄作用域的变量名、方法名、类名等��其他相同名字的变量、方法、类屏蔽掉的现象�?/p>
例如�Q�最常见的就是局部变量将�c�d��例变量屏蔽了。其实，遮蔽�q�个词我之前好像也没什么印象，不过作用域屏蔽这�U�情冉|��们大多应该会避免的了�Q�因��堂上、教材上对于变量作用域的内容已经讲解�q�了�Q�尽��没有这么一个术语。此时如果想要获得被遮蔽实体的引用、调用，则只能通过完整的限定名��d��C��。不�q�有一些情况可能是�Ҏ��引用不到的�Q�被屏蔽得太严密了�?/p>
遮掩�Q�obscure�Q�：一个变量可以遮掩具有相同名字的一个类�Q�只要它们都在同一个范围内�Q�如果这个名字被用于变量与类型都被许可的范围�Q�那么它��引用到变量上。相似地�Q�一个变量名或一个类名可以遮掩一个包。遮掩是唯一一�U�两个名字位于不同的名字�I�间的名字重用�Ş式，�q�些名字�I�间包括�Q�变量、包、方法或�c�R��如果一个类型或一个包被遮掩了�Q�那么你不能通过其简单名引用到它�Q�除非是在这样一个上下文环境中，卌��法只允许在其名字�I�间中出��C��U�名字。遵守命名习惯就可以极大地消除��生遮掩的可能性�?/p>
其实�Q�遮掩这个术语我更是完全没听�q�了�Q�上面这一�D�|��从《Java 解惑》中引用�q�来的。我觉得�Q�如果代码是一个�h所写，或者团队中大家都遵守了一定的命名规范�Q�而且也各自分配了一定职责，那么遮掩�q�种情况应该是可以避免的。同��P��需要��用完全限定名来引用被遮掩掉的实体�Q�如下：
用前面例子的代码大概��是�q�种情况�Q?br />
public class TestFly {
    // 如此变量�?
    static String System = "system";
    public static void main(String [] args) {

//      String System = "hao";
        // �~�译不通过
//      System.out.println("No");
        // �~�译通过
        java.lang.System.out.println("OK");
    }
}
��结�Q?/strong>
1、我觉得�Q�在文章标题当中的五个名词当中，��ؓ前面三个最为重要，陷阱炸弹也多多，而且文中所讲仅仅是那么一丁点儿相关的�Q�大量更�l�节的还得慢慢发玎ͼ�
2、就��后面两个名词，也就是这两种情况不常见，但了解一下记在脑里还是不错的�Q�毕竟�ؓ自己增加了专业词汇量�Q?/p>
3、最后，��是��各位也看看《Java 解惑》然后也告诉我一些炸弹型陷阱之类的，呵呵...学习快乐�Q�加油！
本文�� “蚂蚁” 博客�Q�请务必保留此出处http://haolloyin.blog.51cto.com/1177454/372911

Snape 2012-04-11 14:00 发表评论

java重蝲重写陷阱

Snape — Wed, 11 Apr 2012 05:59:00 GMT

看《重构（注释版）》中“��装集合�Q�Encapsulate Collection�Q?#8221;一节时�Q�由于该重构手法对于不同�?Java 版本会有相对应不同的处理方式�Q�于是注释者在旁边�l�出提示�Q�Java 2 中的�?Collections API 主要是由《Java 解惑》、《Effective Java》这两本书的作者开发改�q�的。我惻I��q�可真是一个大消息�Q�Java �c�d��的开发者所写的书一定得看，开发者肯定深入探寻过 Java 内部机制�Q�说不定能从书中获得未知的知识点呢�?/p>
好在我记得自��q��脑里下蝲�q�《Java 解惑�Q�中文版�Q�》的清晰电子版，于是改变路线�Q�看赯��本书来了。真是不看不知道�Q�一看吓一跻I��里面�?95 �?Java 谜题�Q�一点点地看了之后，我是既惭愧又兴奋�Q�因为里面的题真的是“莫名其妙”�Q�直白点��是�Q�十有八九是想都想不出来的，⊙�H?#8857;b…惌��真正掌握 Java �Q�我觉得《Java 解惑》是不得不看的。大多谜题可谓是前所未见的炸弹，一不小心就 over 了�?/p>
快点切入正题�Q�如文章标题所�C�，我从《Java 解惑》中��g��认识��C��几个名词�Q�之所以用��g��修饰�Q�因为重载、重写、隐藏这几个接触�q�了�Q�而遮蔽、遮掩或许是见过但也��忘光了。就整理一下文中的一些与此相关的 Java 谜题用自��q��理解描述一下吧�?/p>
重蝲�Q�overload�Q�：同一个类中名字相同但参数列表不同的多个方法之间的关系�?/p>
关于重蝲�Q�是我们比较熟悉的了�Q�最常见的就是运用在�cȝ��多个构造函��C��Q�看一�?Java 帮助文档�Q�就可以明白�q�一情况了。而在《Java 解惑》中�Q�作者给��Z��下面一个谜题：
public class Confusing {

    private Confusing(Object o) {
        System.out.println("Object");
    }

    private Confusing(double[] dArray) {
        System.out.println("double array");
    }

    public static void main(String[] args) {
        new Confusing(null);
    }
}

问此�?main() 中将会输��Z��么？初初一看，�q�没有多分析��p��得应该是输出“Object”�Q�虽然Java中的数组实际上也是引用类型，但毕竟Object 是所有类的最�l�父�c�，而且目前 JDK ��p��参数中的基本数据�c�d��变量也可以被自动想上转型成包装类而成�?Object 的子�c�R��于是我保守一点地��p��为参�?null 应该是匹配到 Object 那个重蝲�Ҏ��M��?/p>
可是�q�答案是错的�Q�JVM 对于重蝲�Ҏ��的解析是�q�样的：先找出方法名匚w��的所有可能的�Ҏ��Q�然后根据传�q�来的�Ş参再�ơ筛选出可能的重载方法；最后才是在�q�些�Ҏ��中匹配到一�?strong>最�_��的一个方法�?/span>于是�Q�上面的那个谜题��变成确定哪一个才是最�_��q�一点子上了�?/p>
而关于如何判断最�_��Q�有�q�样的机�Ӟ��如果某个重蝲�Ҏ��能够接收所有传递给另一个重载方法的实参�c�d��Q�那么对于参数列表来看，昄��后者至��是前者的子集�Q�当然也��更�_��了�?/span>
回到谜题上来�Q�Confusing(Object)可以接受��M��传递给 Confusing(double[ ])的参敎ͼ��M��数组引用最�l�能够都�?Object 对象�Q�，因此 main() 中的 null 应该是被 JVM 匚w��?Confusing(double[ ]) 中，也就有了与我所认�ؓ的结果相反的输出了�?/p>
��结�Q?/strong>�q�个谜题表明了我们在写重载方法时�Q�最好是明确地区分出各个�Ҏ��中的参数列表�Q�不要让彼此之间有互相包含、模�p�不清的关系。虽焉��载是��Z��在相同名字的�Ҏ��中传入实参，�?JVM 动态解析选择合适的�Ҏ��Q�但有时也很�Ҏ��陷入�q�种方便背后所带来的地雷区当中。其中一�U�可行的办法��是�Q?span style="background-color: #ffff00; ">提供不同的方法名。但是构造函数的名字一定得相同的啊�Q?/p>
实际上，在《重构与模式》第六章中，作者用他自�w�的��目�l�验�?#8220;创徏”�q�一话题展开了讲解，��q��是构造函敎ͼ�也有很好的重构手法将其清晰地区分开来，不��用重载而是用不同名�U�的�Ҏ��Q�将原本需要重载的构造函数委托给��h��最大完整参数列表的�U�有构造函��C��。又是一本经典，值得看哦…

重写�Q�override�Q�：父类中的实例�Ҏ��被其子类重新实现。既然是实例�Ҏ��Q�那��是�?static 修饰的了�Q�否则就�?static 静态方法了�Q�那叫做�c�L��?/strong>。在我看来，正是重写�q�一机制的存在，才�ؓ多态机制提供了基础。或�?implements �Q�实玎ͼ�一�?interface �Q�接口）中所声明的方法也能成为重写，因�ؓ interface 的一部分存在原因也是��Z��多态�?/p>
对于重写�Q�在《Java 解惑》中有下面这个谜题让我明白：�l�对不能在构造函��C��调用可能会被子类重写的方法�?/strong>
class Point {
    protected final int x, y;
    private final String name;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
        name = makeName();
    }

    protected String makeName() {
        return "[" + x + "," + y + "]";
    }

    public final String toString() {
        return name;
    }
}

public class ColorPoint extends Point {
    private final String color;

    ColorPoint(int x, int y, String color) {
        super(x, y);
        this.color = color;
    }

    protected String makeName() {
       return super.makeName() + ":" + color;
    }

    public static void main(String[] args) {
        System.out.println(new ColorPoint(4, 2, "purple"));
    }
}

此时�E�序�q�行�l�果�q�不是我们所想的 [4,2]:purple �Q�而是 [4,2]:null 。�ؓ什么会�q�样�Q�看看下面用��程标号注释�q�的代码�Q�就能理解了�?/p>
class Point {
    protected final int x, y;
    private final String name;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
        name = makeName();// 3. �׃��被子�c�重写过的makeName()
    }

    protected String makeName() {
        return "[" + x + "," + y + "]";
    }

    public final String toString() {
        return name;
    }
}

public class ColorPoint extends Point {
    private final String color;

    ColorPoint(int x, int y, String color) {
        super(x, y); // 2. 调用Point父类构造函�?
        this.color = color; // 5. 初始�?nbsp;color �Q�可是已�l�太晚了...
    }

    protected String makeName() {
        // 4. 问题来了�Q�它在子�c�L��造函��C��前调用了
        // 而此时的 color �?nbsp;null 的啊�Q�！�Q?
        return super.makeName() + ":" + color;
    }

    public static void main(String[] args) {
        // 1. 调用ColorPoint子类构造函�?
        System.out.println(new ColorPoint(4, 2, "purple"));
    }
}

思�\很清��C��Q�ColorPoint 子类中的构造函��C��?this.color = color; �q�未被执行到��将 null 作�ؓ String color 的��g��。正是因��U�来来回回的调用使得�E�序变得不正�怺��Q�在我看来，有那么一点类��g��“回调”的意思�?/p>
要去除这�U�代码结构的不合理，最好还是把 Point 父类构造函��C��调用 makeName() �Ҏ��一句去掉，然后�?toString 中判断�ƈ调用 makeName() 来�ؓ name 初始化，如下�Q?/p>
��结�Q?/strong>重写对于多态固焉��要，但是设计��Z��正确的代码结构的话，原本惌��的多态就会被扭曲甚至造成反效果。于是，�l�对不要在构造函��C��调用可能会被子类重写的方法�?/p>
好像文字太多的文章看了容易��人晕乎乎的，啰啰嗦嗦、模模糊�p�地才写了两个词儿，�q�是分开来写吧。其实，看了一部分《Java 解惑》才明白�q�有好多好多 Java 里面该注意的要点。要惛_��适当的时候��L清各�U�语法上、机制上的知识点�Q�难啊！
记得高中语文课上读过一片抒情的散文�Q�标题�ؓ“�?#8212;—香雪�Q?#8221;而我看了《Java 解惑》，惌��“�?#8212;—Java�Q?#8221;~~~~(>_<)~~~~
�ȝ��Q?/strong>
1、在我们�~�程领域�Q�好书真的是一大把�Q�就看自己有没时间、有没策略地��d��收了�Q?/p>
2、有时候看好书时留意作者对其他书籍�?#8220;友情链接”�Q�或者出版社推荐的相关书�c�，�q�样��p��够免去自己慢慢搜��d��书的�q�程了，O(∩_∩)O哈！
本文�� “蚂蚁” 博客�Q�请务必保留此出处http://haolloyin.blog.51cto.com/1177454/372691

Snape 2012-04-11 13:59 发表评论

Snape — Wed, 11 Apr 2012 05:57:00 GMT
前面讨论的this关键字，典型地反映了随着对象引用的不同，其变量和操作亦不同，体现了面向对象编�E�的内涵。但是，有时在程序中的要求正好与此相�?#8212;—需要代表整个类的数据。Java提供的静态数据（static data�Q�就是专门用来实现这一要求的�?/span>

二、类数据
   静态数据属于全体对象，是所有对象共享的数据�Q�或�c�L��据。静态常量也�U�Cؓ�c�d��量；静态变量也�U�类变量。在解决实际问题中经�怼�遇到�c�L��据。例如，Math.PI�Q�Math.E�Ҏ��有对象的��术�q�算都是一��L��Q�它们被定义为Math�cȝ��静态常量�?/span>

    再例如，�E�收比率在计��税�ƾ时�Ҏ��有定义的对象都适用�Q�也是静态数据的典型例子。有�Ӟ��我们需要统计创��Z��多少个对象，或者有多少个对象调用了某个�Ҏ��Q�或者应用了某个操作�{�等�Q�这需要在�E�序中��用静态数据来完成�q�些��d��。类数据可以是private或public�?/span>
如下是定义静态数据的典型例子�?/span>
�?�Q�定义静态变量�?/span>
private static double accountLimit; //定义一个双�_�ֺ�静态变�?nbsp;
private static int userCount = 0; //定义一个整数静态变量�ƈ赋�?/span>
public static String welcome = "Java is hot!"; //定义一个字�W�串静态变量�ƈ赋�?/span>

�?�Q�定义静态常量�?/span>
private static final float TAX_RATE = 0.0875f; //定义一个��Q炚w��态常�?/span>
public static final double EARTH_MASS = 5.972e24; //定义一个双�_�ֺ�静态常�?/span>
public static final int MONTH_IN_YEAR = 12; //定义一个整数静态常�?/span>
注意静态常量必��d��定义时赋倹{��否则�ؓ非法�?/span>

如下是��用静态数据的典型例子�Q?/span>

public FutureValue() { //构造器
  //对对象数据初始化的各语句
  ...
  userCount++�Q?//每创��Z��个对象，都对原来�l�计用户数目的静态变量userCount�?
}

public FutureValue(String name) {
  this.name = name;
  //对其他各变量初始化的语句
  ...
  userCount++; //同上
}

以上例子表示无论以哪个构造器创徏对象�Q�对静态变量userCount都执行加1�Q�达到统计对象的目的。如果执行下列输��句：

System.out.println(myFutureValue.getUserCount()); //用对象调�?/span>

其输出��g��Q?/span>

System.out.pritnln(FutureValue.getUserCount()); //用静态方法通过�cȝ��接调�?/span>

完全一栗��?/span>
静态数据通常由静态方法来调用�?/span>

三�?属于所有对�?/span>
   静态数据�ؓ什么属于整个类�Q�或�c�M��的所有对象呢�Q�这是因为它们被储存在特�D�指定的存储器中。进一步讲�Q�静态数据储存在�c�访问区的储存空间。这个储存空间是�q�个�c�M��表的所有对象共享的�Q�它的访问生命期和这个类相同�?/span>

    而实例数据分别储存在代表每个对象的一�D�存储区域中。假设我们创��Z��100个对象，那么��有100个这��L��储存区域存在。即每个对象都有它自��q��立存储区域，用来存储它所��h��的所有实例数据。这个存储区域的讉K��生命期和对象相同�?/span>

四、静态数据原�?/span>
   静态数据是�cȝ��l�成部分�Q�确定静态数据首先从�cȝ��设计入手�Q�分析和��定�cȝ��应用范畴�Q�它所执行的运��和操作�Q�包括确定数学公式以及运��逻辑�{�。由此来��定静态数据和实例数据。静态数据与实例数据本质的不同在于：

�Q?�Q?实例数据是在�q�个�cȝ��应用中，每个对象�Q�或大多数对象都��h��的、但各自有不同值的数据。例如，在计��投资回报的�E�序中，每个对象都有姓名�Q�name�Q�、月投资额（monthlyInvest�Q�，�q�投资回报率�Q�yearlyRate�Q�，以及投资�q�_��years�Q�，但这些数据的值对每个对象来说�Q�是完全由对象来��定的，与整个类无关�Q�与具体对象的�Ş态有兟�?/span>

�Q?�Q?静态数据是所有对象共享的数据。在�q�个�cȝ��应用中，无论哪一个对象，如果应用�q�个数据的话�Q�都必须��h��相同的��|��或者这个数据对所有对象都有意义，或者这个数据代表了所有对象的形态表征，与整个类有关�?/span>

�Ҏ��以上分析�Q�确定静态数据可�Ҏ��如下原则�Q?/span>
1�Q?对类中的对象�q�行�l�计的数据应该确定�ؓ静态数据�?/span>
2�Q?对类中所有对象，讄��上下限的数据�Q�应该确定�ؓ静态常量数据�?/span>
3�Q?在执行运��的公式和解决问题的逻辑中，某个帔R��对类中所有的对象�Q�如果有相同应用�Q�这个常量应该确定�ؓ静态常量数据�?/span>
4�Q?用来对类中所有对象进行提�C�、询问、问候以及其他与具体对象无关的信息或数据�Q�应该确定�ؓ静态常量数据�?/span>

Snape 2012-04-11 13:57 发表评论

Snape — Wed, 11 Apr 2012 05:55:00 GMT
若想实现一个合格重写方法，而不是重载，那么必须同时满��下面的要求！

A、重写规则之一�Q?/span>
    重写�Ҏ��不能比被重写�Ҏ��限制有更严格的访问��别�?nbsp;
�Q�但是可以更�q�泛�Q�比如父�c�L��法是包访问权限，子类的重写方法是public讉K��权限。）比如�Q�Object�c�L��个toString()�Ҏ��Q�开始重写这个方法的时候我们��d��易忘记public修饰�W�，�~�译器当然不会放�q��Q何教训我�?的机会。出错的原因��是�Q�没有加��M��讉K��修饰�W�的�Ҏ��h��包访问权限，包访问权限比public当然要严��g��Q�所以编译器会报错的�?nbsp;

B、重写规则之�?/span>�Q?/span>
   参数列表必须与被重写�Ҏ��的相同�?nbsp;
重写有个孪生的弟弟叫重蝲�Q�也��是后面要出场的。如果子�c�L��法的参数与父�c�d��应的�Ҏ��不同�Q�那么就是你认错��Z��Q�那是重载，不是重写�?/span>

C、重写规则之三：
   �q�回�c�d��必须与被重写�Ҏ��的返回类型相同�?br />父类�Ҏ��A�Q�void eat(){} 子类�Ҏ��B�Q�int eat(){} 两者虽然参数相同，可是�q�回�c�d��不同�Q�所以不是重写�?br />父类�Ҏ��A�Q�int eat(){} 子类�Ҏ��B�Q�long eat(){} �q�回�c�d��虽然兼容父类�Q�但是不同就是不同，所以不是重写�?/p>
D、重写规则之四：
   重写�Ҏ��不能抛出新的异常或者比被重写方法声明的��查异常更�q�的��查异常。但是可以抛出更��，更有限或者不抛出异常�?br />import java.io.*;
public class Test {
  public static void main (String[] args) {
   Animal h = new Horse();
   try {
     h.eat();
   }
   catch (Exception e) {
   }
}
}
class Animal {
  public void eat() throws Exception{
   System.out.println ("Animal is eating.");
   throw new Exception();
  }
}
class Horse extends Animal{
   public void eat() throws IOException{
    System.out.println ("Horse is eating.");
    throw new IOException();
  }
}

�q�个例子中，父类抛出了检查异常Exception�Q�子�c�L��出的IOException是Exception的子�c�，也即是比被重写的�Ҏ��抛出了更有限的异常，�q�是可以的。如果反�q�来�Q�父�c�L��出IOException�Q�子�c�L��出更为宽泛的Exception�Q�那么不会通过�~�译的�?br />注意�Q�这�U�限制只是针�Ҏ��查异常，至于�q�行时异常RuntimeException及其子类不再�q�个限制之中�?/p>
E、重写规则之五：
   不能重写被标识�ؓfinal的方法�?/p>
F、重写规则之六：
  如果一个方法不能被�l�承�Q�则不能重写它�?br />比较典型的就是父�cȝ��private�Ҏ��。下例会产生一个有��的现象�?br />public class Test {
  public static void main (String[] args) {
   //Animal h = new Horse();
   Horse h = new Horse();
    h.eat();
   }
}
class Animal {
   private void eat(){
    System.out.println ("Animal is eating.");
    }
}
class Horse extends Animal{
   public void eat(){
     System.out.println ("Horse is eating.");
   }
}
�q�段代码是能通过�~�译的。表面上看来�q�反了第六条规则�Q�但实际上那是一点��y合。Animal�cȝ��eat()�Ҏ��不能被��承，因此Horse�c�M��?eat()�Ҏ��是一个全新的�Ҏ��Q�不是重写也不是重蝲�Q�只是一个只属于Horse�cȝ��全新的方法！�q�点让很多�h�q�h��了，但是也不是那么难以理解�?br />main()�Ҏ��如果是这��P��
Animal h = new Horse();
//Horse h = new Horse();
h.eat();
�~�译器会报错�Q��ؓ什么呢�Q�Horse�cȝ��eat()�Ҏ��是public的啊�Q�应该可以调用啊�Q�请牢记�Q�多态只看父�c�d��用的�Ҏ��Q�而不看子�c�d��象的�Ҏ��Q?/p>

Snape 2012-04-11 13:55 发表评论

java的null

Snape — Wed, 11 Apr 2012 05:51:00 GMT

一、null是代表不��定的对�?/span>
    Java中，null是一个关键字�Q�用来标识一个不��定的对象。因此可以将null赋给引用�c�d��变量�Q�但不可以将null赋给基本�c�d��变量�?/span>

比如�Q�int a = null;是错误的。Ojbect o = null是正��的�?/span>

  Java中，变量都遵循一个原则，先定义，�q�且初始化后�Q�才可以使用。我们不能int a后，不给a指定��|��去打印a的倹{�?/span>
�q�条对对于引用类型变量也是适用的�?/span>

   有时候，我们定义一个引用类型变量，在刚开始的时候，无法�l�出一个确定的��|��但是不指定��|��E�序可能会在try语句块中初始化倹{�?/span>
    我们下面使用变量的时候就会报错。这时候，可以先给变量指定一个null��|��问题��p��决了。例如：
Connection conn = null;
try {
   conn = DriverManager.getConnection("url", "user", "password");
} catch (SQLException e) {
   e.printStackTrace();
}

String catalog = conn.getCatalog();

如果刚开始的时候不指定conn = null�Q�则最后一句就会报错�?br />
二、null本��n不是对象�Q�也不是Objcet的实�?br />
  null本��n虽然能代表一个不��定的对象，但就null本��n来说�Q�它不是对象�Q�也不知道什么类型，也不是java.lang.Object的实例�?br />可以做一个简单的例子�Q?br />
//null是对象吗? 属于Object�c�d��?
if (null instanceof java.lang.Object) {
  System.out.println("null属于java.lang.Object�c�d��");
} else {
  System.out.println("null不属于java.lang.Object�c�d��");
}

�l�果会输出：null不属于java.lang.Object�c�d��

三、Java默认�l�变量赋�?br />
在定义变量的时候，如果定义后没有给变量赋��|��则Java在运行时会自动给变量赋倹{�?br />赋值原则是整数�c�d��int、byte、short�?long的自动赋��gؓ0�Q�带��数点的float、double自动赋��gؓ0.0�Q?br />boolean的自动赋��gؓfalse�Q�其他各供引用类型变量自动赋��gؓ null�?br />�q�个具体可以通过调试来看�?br />
四、容器类型与null

List�Q�允讔R��复元素，可以加入��L��多个null�?br />Set�Q�不允许重复元素�Q�最多可以加入一个null�?br />Map�Q�Map的key最多可以加入一个null�Q�value字段没有限制�?br />数组�Q�基本类型数�l�，定义后，如果不给定初始��|��则java�q�行时会自动�l�定倹{�?br />引用�c�d��数组�Q�不�l�定初始��|��则所有的元素��gؓnull�?br />
五、null的其他作�?br />
1、判断一个引用类型数据是否null�?�?=来判断�?br />2、释攑ֆ�存，让一个非null的引用类型变量指向null。这栯��个对象就不再被�Q何对象应用了�?br />�{�待JVM垃圾回收机制��d��收�?br />
以下是我的一些想法：
package com.zac.expe1;
public class NullInDepth {
   public static void helloThere(){
    System.out.println("Hello from null?!");
   }

   public static void main(String[] args) {
     //((NullInDepth)null).helloThere();
     NullInDepth nullIn = null;
     nullIn.helloThere();
     Object nullStr = null;
     NullInDepth nullOut = (NullInDepth) nullStr;
     System.out.println(nullIn);
   }

}
�q�里Hello from null?!会被打印出来�Q�而后边一句会打印出null�Q?br />我们知道println一般是调用对象的toString来进行打华ͼ�但是null明显不是对象�Q?br />作�ؓ一个不��定引用它只是把自己的literal�l�打��C��出来�Q�因此我猜测null是预先存储在内存中的一个引用，
它是有值的�Q�可能根据不同的jvm有不同的实现�Q�但是jvm中会一致地��这个值打��Cؓnull�?/p>

另外按照我的猜测�Q�null应该是栈里边的一个引用，null type是可以�{换�ؓ所有其他type的引用，
所以我也猜��null type应该是所有其他引用类型的子类型�?nbsp;
静态方法（也许需要是public的）应该是由�c�d��来调用，但是也可以��?�c�d��(null).静态方法名的方式调用�?/p>

Snape 2012-04-11 13:51 发表评论

Snape — Wed, 11 Apr 2012 05:48:00 GMT

⑴��复�?��克�?
    被复制对象的所有变量都含有与原来的对象相同的��|��而所有的对其他对象的引用仍然指向原来的对象。换�a�之，��复制仅仅复制所考虑的对象，而不复制它所引用的对象�?/p>
⑵深复�?深克�?
   被复制对象的所有变量都含有与原来的对象相同的��|��除去那些引用其他对象的变量。那些引用其他对象的变量��指向被复制�q�的新对象，而不再是原有的那些被引用的对象。换�a�之，深复制把要复制的对象所引用的对象都复制了一遍�?/p>
Java的clone()�Ҏ��
⑴clone�Ҏ��对象复制了一份�ƈ�q�回�l�调用者。一般而言�Q�clone()�Ҏ��满��Q?/p>
①对�Q何的对象x�Q�都有x.clone() !=x//克隆对象与原对象不是同一个对�?/p>
②对�Q何的对象x�Q�都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一�?/p>
③如果对象x的equals()�Ҏ��定义恰当�Q�那么x.clone().equals(x)应该成立�?/p>
⑵Java中对象的克隆
①��Z��获取对象的一份拷贝，我们可以利用Object�cȝ��clone()�Ҏ��?/p>
②在派生类中覆盖基�cȝ��clone()�Ҏ��Q��ƈ声明为public�?/p>
③在派生类的clone()�Ҏ��中，调用super.clone()�?/p>
④在派生类中实现Cloneable接口�?/p>��L��如下代码�Q?/span>
class Student implements Cloneable { String name; int age; Student(String name,int age) { this.name=name; this.age=age; } public Object clone() { Object o=null; try { o=(Student)super.clone();//Object中的clone()识别��Z��要复制的是哪一 // 个对象�? } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } return o; } public static void main(String[] args) { Student s1=new Student("zhangsan",18); Student s2=(Student)s1.clone(); s2.name="lisi"; s2.age=20; System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后，不媄响学�?的倹{�? } }
�q�行�l�果�Q?br />C:\java>java Student
name=zhangsan,age=18

说明�Q?/pre>
①��Z��么我们在�z��c�M��覆盖Object的clone()�Ҏ��Ӟ��一定要调用super.clone()�?在运行时刻，Object中的 clone()识别��Z��要复制的是哪一个对象，然后为此对象分配�I�间�Q��ƈ�q�行对象的复�Ӟ��原始对象的内容一一复制到新对象的存储空间中�?/p>
②�l�承自java.lang.Object�cȝ��clone()�Ҏ��是浅复制。以下代码可以证明之�?/p>
class Professor { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } } public class Student implements Cloneable { String name;//帔R��对象�? int age; Professor p;//学生1和学�?的引用值都是一��L��? Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object clone() { Student o=null; try { o=(Student)super.clone(); } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } return o; } public static void main(String[] args) { Professor p=new Professor("wangwu",50); Student s1=new Student("zhangsan",18,p); Student s2=(Student)s1.clone(); s2.p.name="lisi"; s2.p.age=30; System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授成为lisi,age�?0�? } }
�q�行�l�果�Q?/span>
C:\java>java Student
name=lisi,age=30
那应该如何实现深层次的克隆，即修改s2的教授不会媄响s1的教授，代码改进如下�?/p>
改进使学�?的Professor不改�?深层�ơ的克隆)
class Professor implements Cloneable { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } public Object clone() { Object o=null; try { o=super.clone(); } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } return o; } } public class Student implements Cloneable { String name; int age; Professor p; Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object clone() { Student o=null; try { o=(Student)super.clone(); } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } o.p=(Professor)p.clone(); return o; } public static void main(String[] args) { Professor p=new Professor("wangwu",50); Student s1=new Student("zhangsan",18,p); Student s2=(Student)s1.clone(); s2.p.name="lisi"; s2.p.age=30; System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授不改变�? } }
3.利用串行化来做深复制
  把对象写到流里的�q�程是串行化(Serilization)�q�程�Q�但是在Java�E�序师圈子里又非常�Ş象地�U�Cؓ“冷冻”或�?#8220;腌咸�?(picking)”�q�程;而把对象从流中读出来的�ƈ行化(Deserialization)�q�程则叫�?#8220;解冻”或�?#8220;回鲜(depicking)”�q�程。应当指出的是，写在��里的是对象的一个拷贝，而原对象仍然存在于JVM里面�Q�因�?#8220;腌成咸菜”的只是对象的一个拷贝，Java咸菜�q�可以回鲜�?/p>
在Java语言里深复制一个对象，常常可以先��对象实现Serializable接口�Q�然后把对象(实际上只是对象的一个拷�?写到一个流�?腌成咸菜)�Q�再从流里读出来(把咸菜回�?�Q�便可以重徏对象�?/p>
如下为深复制源代码�?/p>
public Object deepClone()
{
  //��对象写到流�?nbsp;
  ByteArrayOutputStream bo=new ByteArrayOutputStream();
  ObjectOutputStream oo=new ObjectOutputStream(bo);
  oo.writeObject(this);

  //从流里读出来
  ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
  ObjectInputStream oi=new ObjectInputStream(bi);
  return(oi.readObject());
}
�q�样做的前提是对象以及对象内部所有引用到的对象都是可串行化的�Q�否则，��需要仔�l�考察那些不可串行化的对象可否设成transient�Q�从而将之排除在复制�q�程之外。上例代码改�q�如下�?br />
import java.io.*; class Professor implements Serializable { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } } public class Student implements Serializable { String name;//帔R��对象�? int age; Professor p;//学生1和学�?的引用值都是一��L��? Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object deepClone() throws IOException, OptionalDataException,ClassNotFoundException { //��对象写到流�? ByteArrayOutputStream bo=new ByteArrayOutputStream(); ObjectOutputStream oo=new ObjectOutputStream(bo); oo.writeObject(this); //从流里读出来 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); ObjectInputStream oi=new ObjectInputStream(bi); return(oi.readObject()); } public static void main(String[] args) throws IOException,ClassNotFoundException { Professor p=new Professor("wangwu",50); Student s1=new Student("zhangsan",18,p); Student s2=(Student)s1.deepClone(); s2.p.name="lisi"; s2.p.age=30; System.out.println("name="+s1.p.name+","+"age="+s1.p.age); //学生1的教授不改变�? } }
�q�行�l�果�Q?/span>
C:\java>java Student
name=wangwu,age=50

Snape 2012-04-11 13:48 发表评论

Snape — Wed, 11 Apr 2012 05:43:00 GMT

Java应用�E�序虽然能够“�~�写一�ơ，随处�q�行”�Q�Write Once, Run Anywhere�Q�是一个巨大的优势�Q�但�q�种环境的架构方式��其远比本机应用程序更�Ҏ��被黑客进行逆向工程。这意味着开发�h员面临着失去知识产权的非常真实的危险。基于应用程序的虚拟机比本机应用�E�序更容易逆向工程的原因有很多�Q?/div>
JVM是开源的
Sun已经免费提供JVM的源代码。这使得黑客只需查看代码卛_��弄清虚拟机的工作方式�?/div>
Java .class文�g格式是可公开获取�?br />如前所�q�ͼ�Java源代码被�~�译成字节码�Q�而字节码存储在Java .class文�g中。Java .class文�g格式的规范是可公开获取的，因此有技术背景的��M��人都能容易地�~�写可以处理、修�Ҏ��转换.class文�g的工兗��?/div>
JVM是��Y�Ӟ��而不是硬�?/span>
与需要理解特定处理器的专家��用的标准�~�程语言不同�Q�JVM是一个应用程序，它如同微处理器一栯��作，�q��用操作系�l�和计算机硬件提供的内置功能。由于黑客不必深入到��g�U�别�Q�因此更�Ҏ��取得对JVM的完全控制�?/div>
因此�Q�例如在使用标准本机�pȝ��开发语�a��q�行调试�Ӟ��暂停处理器极为困难，需要具备处理器、调试功能及可用环调试器的专家知识。但是，�׃��JVM �q�行环境的源代码是可公开获取的，因此开发�h员可以轻村֜�建立自己的虚拟机来完全控制虚拟处理器的各个方面。这样可以容易地分析�q�行环境中运行的每个应用�E�序�?/div>
Java的指令比本机代码��?/span>
然而，JVM代码易于�q�行反向工程的另一个原因是它具有比本地应用�E�序更少的指令。这是出于性能考虑。JVM的��用在应用�E�序和本机处理器之间增加了一个��Y件层�Q�这会对性能产生负面影响。虽然现代处理器不断提高的执行速度最�l�将�~�解�q�一问题�Q�但�q�一问题仍然很明显。虚拟机开发�h员提高执行速度的一�U�方法是使用比本机处理器汇编�E�序更小的字节码指��o集。本机应用程序可能包含多�?00条指令，而Java应用�E�序通常使用不超�q?00条的指��o。更��的指��o意味着黑客可以更快地分析代码以�q�行逆向工程。这些特性��得虚拟机�q�比其它�c�d��的应用程序更�Ҏ��遭受逆向工程��d��?/div>
�W�三方反汇编�E�序增加了漏�z?/span>
不仅是JVM本��n�Ҏ��遭受逆向工程��d��Q�商业和免费的Java字节码反汇编�E�序也越来越多，从而进一步简化了代码逆向工程的过�E�。IDA和Eclipse字节码插件是众多Java字节码反汇编�E�序中的两种。作为商业��品，IDA是一�U�普遍的反汇�~�程序，可用于许多不同的处理器，包括80x86和MIPS。Eclipse字节码插件是免费软�g。它能够反编译Java .class文�g的字节码�q�以适当的顺序显�C�所有操作码指��o�?nbsp;��管�q�些产品不大可能从字节码完美地恢复原始代码，但它们恢复的源代码将�{�同于原始代码，�q�且比字节码更具可读性。一旦恢复了源代码，��d��者可以容易地删除部分代码�q�将光��法地用于竞争�Ҏ��的应用程序中�Q�或�?class文�g中定位打补丁�?/div>
�?提供了黑客可能如何在.class文�g中打补丁的一个示例。屏�q�的上半部分昄��了一��段Java源代码。屏�q�的下半部分昄��了字节码反汇�~�的输出�Q�也��是一个字节码指��o列表。标��Cؓ�U�色的区域是源代码中IF�l�构的对应指令。字节码指��o“LCMP”的十六进制表�C�Zؓ0x94。该工具�q�指��Z��操作码在.class文�g中的位置。有了这些信息，黑客可以使用��单的十六�q�制�~�辑器来改变该IF分支�Q�而这只需不到一分钟的时间。假设该IF条�g用于许可证检查，黑客可倒置该条�Ӟ��指示即��在许可证被验证�ؓ无效�Q�如已过期）的情况下仍返�?#8220;True”�Q�从而突破许可证��查。在�q�种情况下，黑客使用一个字节的补丁卛_��完成所有工作。虽然大多数应用�E�序都比�q�个�C�Z��更加复杂�Q�但即��在复杂的应用�E�序中，字节码也非常��单�ƈ且容易理解�?/div>
Java应用�E�序虽然能够“�~�写一�ơ，随处�q�行”�Q�Write Once, Run Anywhere�Q�是一个巨大的优势�Q�但�q�种环境的架构方式��其远比本机应用程序更�Ҏ��被黑客进行逆向工程。这意味着开发�h员面临着失去知识产权的非常真实的危险。基于应用程序的虚拟机比本机应用�E�序更容易逆向工程的原因有很多�Q?/div>
�? - 用于字节码反汇编的Eclipse字节码插�?/p>

Snape 2012-04-11 13:43 发表评论

Java基本功——Reference

Snape — Wed, 11 Apr 2012 05:30:00 GMT

�q�是一��一�q�多之前便已写就的文章，那时�Q�因为很多Java�E�序员只求追随新生的事物�Q�却�q�基本的概念都没有，很多讨论中，很明显是基本功不�q�硬�Q�于是萌生写一个系列文章，讨论Java的基本功�Q�下面便是在�q�个��x��下催生出的第一��文章。可事实上，真正完成的也只有�q�一��。因为未能及时发布，它就被我遗忘在硬盘的角落中。今天，JavaEye上关于Java传��D��是传引用的论战让我记起了自己曄��写过的这��文章，愿与大家�׃�n�?/p>
Java基本�?#8212;—Reference
有这样一�U�说法，如今争锋于IT战场的两大势力，MS一族偏重于底层实现�Q�Java一族偏重于�pȝ��架构。说法根据无从考证�Q�但从两大势力各自的�C�֌�力量和图书市场已有佳作不隄��出，此说法不虚。于是，事情的另一面让人忽略了�?br />偏��y�Q�我是一个喜�Ƣ探�I�底层实现的Java�E�序员，虽然我的喜好�q��U�正咖啡�Q�剑走偏锋却别是一番风呟�?/p>
Reference
Java世界泰山北斗�U�大作《Thinking In Java》切入Java��提�?#8220;Everything is Object”。在Java�q�个充满Object的世界中�Q�reference是一切谜题的�Ҏ��Q�所有的故事都是从这里开始的�?/p>
Reference是什么？
如果你和我一样在�q�入Java世界之前曄��迹于C/C++世界�Q�就一定不会对指针陌生。谈到指针，往日种�U�不堪回首的�l�历一下子涌上心头�Q�这里不是抱怨的地方�Q�让我们暂时忘记指针的痛苦，回忆一下最初接触指针的甜蜜吧！�q�记得你看过的教�U�书中，如何讲解指针吗？留在我印象中的一�U�说法是�Q�指针就是地址�Q�如同门牌号码一��P��有了地址�Q�你可以轻而易举找��C��个�h�Ӟ��而不必费��心力的大�v捞针�?br />C++��M��历史舞台�Q�reference也随之而来�Q�容我问个小问题�Q�指针和reference区别何在�Q�我的答案来自于在C++世界享誉盛名的《More Effective C++》�?/p>
没有null reference�?/li>
reference必须有初倹{�?/li>
使用reference要比使用指针效率高。因为reference不需要测试其有效性�?/li>
指针可以重新赋��|��而reference��L��指向它最初获得的对象
设计选择�Q?/strong>
当你指向你需要指向的某个东西�Q�而且�l�不会改指向其它东西�Q�或是当你实作一个运��符而其语法需要无法有指针达成�Q�你��应该选择reference。其它�Q何时候，请采用指针�?/p>
�q�和Java有什么关�p�？
初学Java�Q�鉴于reference的名�U�ͼ�我毫不犹豫的��它和C++中的reference�{�同��h��。不�q�，我错了。在Java中，reference可以随心所�Ʋ的赋值置�I�，�Ҏ��一下上面列出的差异�Q�就不难发现�Q�Java的reference如果要与C/C++对应�Q�它不过是一个穿着reference外衣的指针而已�?br />于是�Q�所有关于C中关于指针的理解方式�Q�可以照搬到Java中，��而言之，reference��是一个地址。我们可以把它想象成一个把手，抓住它，��抓住了我们惌��操纵的数据。如同掌握C的关键在于掌握指针，探烦Java的钥匙就是reference�?/p>
一�D�小�E�序
我知道，太多的文字��L��令�h犯困�Q�那��来�D�代码吧�Q?br />public class ReferenceTricks {
  public static void main(String[] args) {
    ReferenceTricks r = new ReferenceTricks();
    // reset integer
  r.i = 0;
    System.out.println("Before changeInteger:" + r.i);
    changeInteger(r);
  System.out.println("After changeInteger:" + r.i);
    // just for format
  System.out.println();

    // reset integer
  r.i = 0;
    System.out.println("Before changeReference:" + r.i);
  changeReference(r);
    System.out.println("After changeReference:" + r.i);
}
  private static void changeReference(ReferenceTricks r) {
r = new ReferenceTricks();
   r.i = 5;
   System.out.println("In changeReference: " + r.i);
}
private static void changeInteger(ReferenceTricks r) {
   r.i = 5;
   System.out.println("In changeInteger:" + r.i);
}
public int i;
}

对不��P��我知道，把一个字�D�设成public是一�U�不好的�~�码习惯�Q�这里只是�ؓ了说明问题�?br />如果你有兴趣自己�q�行一下这个程序，我等你！
OK�Q�你已经�q�行�q�了吗？�l�果如何�Q�是否如你预期？下面是我在自��q��机器上运行的�l�果�Q?br />Before changeInteger:0
In changeInteger:5
After changeInteger:5
Before changeReference:0
In changeReference: 5
After changeReference:0
�q�里�Q�我们关注的是两个change——changeReference和changeInteger。从输出的内容中�Q�我们可以看出，两个�Ҏ��在调用前和调用中完全一��P��差异出现在调用后的结果�?/p>
�p�涂的讲�?br />先让我们来分析一下changeInteger的行为�?br />前面说过了，Java中的reference��是一个地址�Q�它指向了一个内存空��_��q�个�I�间存放着一个对象的相关信息。这里我们暂时不��d��心这个内存具体如何排布，只要知道�Q�通过地址�Q�我们可以找到r�q�个对象的i字段�Q�然后我们给它赋�?。既然这个字�D늚�内容得到了修改，从函��C��q�回之后�Q�它自然��是改动后的�l�果了，所以调用之后，r对象的i字段依然�?。下囑ֱ��C�Z��changeInteger调用前后内存变化�?/p>
     Reference +--------+                Reference +--------+
    ---------->| i = 0 |               ---------->| i = 5 |
               |--------|                          |--------|
               | Memory |                          | Memory |
               |        |                          |        |
               |        |                          |        |
               +--------+                          +--------+
    调用changeInteger之前               调用changeInteger之后
让我们把目光转向changeReference�?br />从代码上�Q�我们可以看出，同changeInteger之间的差别仅仅在于多了这么一句�?br />r = new ReferenceTricks();
�q�条语句的作用是分配一块新的内存，然后��r指向它�?br />执行完这条语句，r��׃��再是原来的r�Q�但它依然是一个ReferenceTricks的对象，所以我们依然可以对�q�个r的i字段赋倹{��到此�ؓ止，一切都是那么自然�?/p>
     Reference +--------+                          +--------+
    ---------->| i = 0 |                          | i = 0 |
               |--------|                          |--------|
               | Memory |                          | Memory |
               |        |                Reference |--------|
               |        |               ---------->| i = 5 |
               +--------+                          +--------+
    调用changeReference之前              调用changeReference之后
��着�q�个思�\�l�箋下去的话�Q�执行完changeReference�Q�输出的r的i字段�Q�那么应该是应该是新内存中的i�Q�所以应该是5。至于那块被我们抛弃的内存，Java的GC功能自然会替我们善后的�?br />事与愿违�?br />实际的结果我们已�l�看��C��Q�输出的�?�?br />肯定哪个地方错了�Q�究竟是哪个地方呢？
参数传递的�U�密
知道�Ҏ��参数如何传递吗�Q?br />记得刚开始学�~�程那会儿，老师教导�Q�所谓参敎ͼ�有�Ş式参数和实际参数之分�Q�参数列表中写的那些东西都叫形式参数�Q�在实际调用的时候，它们会被实际参数所替代�?br />�~�译�E�序不可能知道每�ơ调用的实际参数都是什么，于是写编译器的高手就��Z��办法�Q�让实际参数按照一定顺序放��C��个大安��可以扑־�到的地方�Q�以此作为方法调用的一�U�约定。所�?#8220;没有规矩�Q�不成方�?#8221;�Q�有了这个规矩，大家协作��h��容易多了。这个公共数据区�Q�现在编译器的选择通常�?#8220;�?#8221;�Q�而所谓的��序��是形式参数声明的顺序�?br />昄��Q�程序运行的�q�程中，作�ؓ实际参数的变量可能遍布于内存的各个位�|�，而�ƈ不一定要老老实实的呆在栈里。�ؓ了守“规矩”�Q�程序只好将变量复制一份到栈中�Q�也��是通常所说的��参数压入栈中�?br />打�v�_��Q�谜底就要揭晓了�?br />我刚才说什么来着�Q�将变量复制一份到栈中�Q�没错，“复制”�Q?br />�q�就是所谓的��g��递�?br />C语言的旷世经典《The C Programming Language》开��的�W�一章中�Q�谈到实际参数时��_��“在C中，所有函数的实际参数都是�?#8216;�?�?#8221;�?br />马上会有人站出来�Q?#8220;错了�Q�还有传地址�Q�比如以指针传递就是传地址”�?br />不错�Q�传指针��是传地址。在把指针视为地址的时候，是否考虑�q�这样一个问题，它也是一个变量。前面的讨论中说�q�了�Q�参��C��递必��要把参数压入栈中，作�ؓ地址的指针也不例外。所以，必须把这个指针也复制一份。函��C��对于指针操作实际上是对于�q�个指针副本的操作�?br />Java的reference�{�于C的指针。所以，在Java的方法调用中�Q�reference也要复制一份压入堆栈。在�Ҏ��中对reference的操作就是对�q�个reference副本的操作�?br />谜底揭晓
好，让我们回到最初的问题上�?br />在changeReference中对于reference的赋值实际上是对�q�个reference的副本进行赋��|��而对于reference的本��没有��生丝毫的影响�?br />回到调用点，本尊醒来�Q�它�q�不知道自己睡去的这�D�|��间内发生�q�什么，所以只好当作什么都没发生过一般。就�q�样�Q�副本消�׃��Q�在�Ҏ��中对它的修改也就烟消云散了�?br />
也许你会问出�q�样的问题，“听了你的解释�Q�我反而对changeInteger感到�q�h��了，既然是对于副本的操作�Q��ؓ什么changeInteger可以�q�作正常�Q?#8221;
呵呵�Q�很有趣的大脑短路现象�?br />好，那我��q��前面的说法解释一下changeInteger的运作�?br />所谓复�Ӟ��其结果必然是副本完全�{�同于本��。reference复制的结果必然是两个reference指向同一块内存空间�?br />虽然在方法中对于副本的操作�ƈ不会影响到本��，但对内存�I�间的修改确实实实在在的�?br />回到调用点，虽然本尊依然不知道曾�l�发生过的一切，但它按照原来的方式访问内存的时候，取到的确是经�q�方法修改之后的内容�?br />于是�Ҏ��可以把自��q��影响扩展到方法之外�?br />
多说几句
�q�个问题��h��于我对C/C++中同样问题的思考。同C/C++相比�Q�在changeReference中对reference赋值可能�ƈ不会造成什么很严重的后果，而在C/C++中，�q�么做却会造成臭名昭著�?#8220;内存泄漏”�Q�根本的原因在于Java拥有了可��q��GC功能。即便这��P��我仍不推荐��用这�U�的手法�Q�毕竟GC已经很忙了，我们怎么好意思再�ȝ��人家�?br />在C/C++中，�q�个问题�q�可以��l�引生뀂既然在函数中对于指针直接赋��D��不通，那么如何在函��C��修改指针呢？�{�案很简单，指针的指针，也就是把原来的指针看作一个普通的数据�Q�把一个指向它的指针传到函��C��可以了�?br />同样的问题到了Java中就没有那么��妙的解��x��案了�Q�因为Java中可没有reference的reference�q�样的语法。可能的变通就是将reference�q�行��装成类。至于��g��|��公道自在人心�?/p>

Snape 2012-04-11 13:30 发表评论

java中的多线�E?�?

Snape — Fri, 30 Mar 2012 19:19:00 GMT

java中的多线�E?/div>
在java中要惛_��现多�U�程�Q�有两种手段�Q�一�U�是�l�箋Thread�c�，另外一�U�是实现Runable接口�?/div>
对于直接�l�承Thread的类来说�Q�代码大致框架是�Q?/div>
class �c�d�� extends Thread{
�Ҏ��1;
�Ҏ��2�Q?/div>
…
public void run(){
// other code…
}
属�?�Q?/div>
属�?�Q?/div>
…

}
先看一个简单的例子�Q?/div>
/**
* @author Rollen-Holt �l�承Thread�c?直接调用run�Ҏ��
* */
class hello extends Thread {

public hello() {

}

public hello(String name) {
this.name = name;
}

public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "�q�行 " + i);
}
}

public static void main(String[] args) {
hello h1=new hello("A");
hello h2=new hello("B");
h1.run();
h2.run();
}

private String name;
}
【运行结果】：
A�q�行 0
A�q�行 1
A�q�行 2
A�q�行 3
A�q�行 4
B�q�行 0
B�q�行 1
B�q�行 2
B�q�行 3
B�q�行 4
我们会发现这些都是顺序执行的�Q�说明我们的调用�Ҏ��不对�Q�应该调用的是start�Q�）�Ҏ��?/div>
当我们把上面的主函数修改为如下所�C�的时候：
public static void main(String[] args) {
hello h1=new hello("A");
hello h2=new hello("B");
h1.start();
h2.start();
}
然后�q�行�E�序�Q�输出的可能的结果如下：
A�q�行 0
B�q�行 0
B�q�行 1
B�q�行 2
B�q�行 3
B�q�行 4
A�q�行 1
A�q�行 2
A�q�行 3
A�q�行 4
因�ؓ需要用到CPU的资源，所以每�ơ的�q�行�l�果基本是都不一��L��Q�呵��c�?/div>
注意�Q�虽然我们在�q�里调用的是start�Q�）�Ҏ��Q�但是实际上调用的还是run�Q�）�Ҏ��的主体�?/div>
那么�Q��ؓ什么我们不能直接调用run�Q�）�Ҏ��呢？
我的理解是：�U�程的运行需要本地操作系�l�的支持�?/div>
如果你查看start的源代码的时候，会发玎ͼ�
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0 || this != me)
throw new IllegalThreadStateException();
group.add(this);
start0();
if (stopBeforeStart) {
stop0(throwableFromStop);
}
}
private native void start0();
注意我用�U�色加粗的那一条语句，说明此处调用的是start0�Q�）。�ƈ且这个这个方法用了native关键字，�ơ关键字表示调用本地操作�pȝ��的函数。因为多�U�程的实现需要本地操作系�l�的支持�?/div>
但是start�Ҏ��重复调用的话�Q�会出现java.lang.IllegalThreadStateException异常�?/div>
通过实现Runnable接口�Q?/div>

大致框架是：
class �c�d�� implements Runnable{
�Ҏ��1;
�Ҏ��2�Q?/div>
…
public void run(){
// other code…
}
属�?�Q?/div>
属�?�Q?/div>
…

}
来先看一个小例子吧：
/**
* @author Rollen-Holt 实现Runnable接口
* */
class hello implements Runnable {

public hello() {

}

public hello(String name) {
this.name = name;
}

public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "�q�行 " + i);
}
}

public static void main(String[] args) {
hello h1=new hello("�U�程A");
Thread demo= new Thread(h1);
hello h2=new hello("�U�程�Q?);
Thread demo1=new Thread(h2);
demo.start();
demo1.start();
}

private String name;
}
【可能的�q�行�l�果】：
�U�程A�q�行 0
�U�程�Q�运�? 0
�U�程�Q�运�? 1
�U�程�Q�运�? 2
�U�程�Q�运�? 3
�U�程�Q�运�? 4
�U�程A�q�行 1
�U�程A�q�行 2
�U�程A�q�行 3
�U�程A�q�行 4

关于选择�l�承Thread�q�是实现Runnable接口�Q?/div>
其实Thread也是实现Runnable接口的：
?
1
2
3
4
5
6
7
8
class Thread implements Runnable {
//…
public void run() {
if (target != null) {
target.run();
}
}
}
其实Thread中的run�Ҏ��调用的是Runnable接口的run�Ҏ��。不知道大家发现没有�Q�Thread和Runnable都实��C��run�Ҏ��Q�这�U�操作模式其实就是代理模式。关于代理模式，我曾�l�写�q�一个小例子呵呵�Q�大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html
Thread和Runnable的区别：
如果一个类�l�承Thread�Q�则不适合资源�׃�n。但是如果实��C��Runable接口的话�Q�则很容易的实现资源�׃�n�?/div>
/**
* @author Rollen-Holt �l�承Thread�c�，不能资源�׃�n
* */
class hello extends Thread {
public void run() {
for (int i = 0; i < 7; i++) {
if (count > 0) {
System.out.println("count= " + count--);
}
}
}

public static void main(String[] args) {
hello h1 = new hello();
hello h2 = new hello();
hello h3 = new hello();
h1.start();
h2.start();
h3.start();
}

private int count = 5;
}
【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
大家可以惌��Q�如果这个是一个买��系�l�的话，如果count表示的是车票的数量的话，说明�q�没有实现资源的�׃�n�?/div>
我们换�ؓRunnable接口�Q?/div>
/**
* @author Rollen-Holt �l�承Thread�c�，不能资源�׃�n
* */
class hello implements Runnable {
public void run() {
for (int i = 0; i < 7; i++) {
if (count > 0) {
System.out.println("count= " + count--);
}
}
}

public static void main(String[] args) {
hello he=new hello();
new Thread(he).start();
}

private int count = 5;
}
【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1

�ȝ��一下吧�Q?/div>
实现Runnable接口比��承Thread�c�L��h��的优势：
1�Q�：适合多个相同的程序代码的�U�程��d��理同一个资�?/div>
2�Q�：可以避免java中的单��承的限制
3�Q�：增加�E�序的健壮性，代码可以被多个线�E�共享，代码和数据独立�?/div>
所以，本�h��大家劲量实现接口�?/div>
/**
* @author Rollen-Holt
* 取得�U�程的名�U?/div>
* */
class hello implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName());
}
}

public static void main(String[] args) {
hello he = new hello();
new Thread(he,"A").start();
new Thread(he,"B").start();
new Thread(he).start();
}
}
【运行结果】：
A
A
A
B
B
B
Thread-0
Thread-0
Thread-0
说明如果我们没有指定名字的话�Q�系�l�自动提供名字�?/div>
提醒一下大�Ӟ��main�Ҏ��其实也是一个线�E�。在java中所以的�U�程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源�?/div>

在java中，每次�E�序�q�行臛_��启动2个线�E�。一个是main�U�程�Q�一个是垃圾攉��U�程。因为每当��用java命��o执行一个类的时候，实际上都会启动一个Ｊ�QӞ݋�Q�每一个ｊ�QӞ݋实习在就是在操作�pȝ��中启动了一个进�E��?/div>
判断�U�程是否启动
/**
* @author Rollen-Holt 判断�U�程是否启动
* */
class hello implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName());
}
}

public static void main(String[] args) {
hello he = new hello();
Thread demo = new Thread(he);
System.out.println("�U�程启动之前---�? + demo.isAlive());
demo.start();
System.out.println("�U�程启动之后---�? + demo.isAlive());
}
}
【运行结果�?/div>
�U�程启动之前---》false
�U�程启动之后---》true
Thread-0
Thread-0
Thread-0
�ȝ��E�也有可能在子线�E�结束之前结束。�ƈ且子�U�程不受影响�Q�不会因��Z��U�程的结束而结束�?/div>

�U�程的强制执行：
/**
* @author Rollen-Holt �U�程的强制执�?/div>
* */
class hello implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName());
}
}

public static void main(String[] args) {
hello he = new hello();
Thread demo = new Thread(he,"�U�程");
demo.start();
for(int i=0;i<50;++i){
if(i>10){
try{
demo.join(); //强制执行demo
}catch (Exception e) {
e.printStackTrace();
}
}
System.out.println("main �U�程执行-->"+i);
}
}
}
【运行的�l�果】：
main �U�程执行-->0
main �U�程执行-->1
main �U�程执行-->2
main �U�程执行-->3
main �U�程执行-->4
main �U�程执行-->5
main �U�程执行-->6
main �U�程执行-->7
main �U�程执行-->8
main �U�程执行-->9
main �U�程执行-->10
�U�程
�U�程
�U�程
main �U�程执行-->11
main �U�程执行-->12
main �U�程执行-->13
�Q�．�Q?/div>

�U�程的休眠：
/**
* @author Rollen-Holt �U�程的休�?/div>
* */
class hello implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + i);
}
}

public static void main(String[] args) {
hello he = new hello();
Thread demo = new Thread(he, "�U�程");
demo.start();
}
}
【运行结果】：�Q�结果每�?s输出一个）
�U�程0
�U�程1
�U�程2

�U�程的中断：
/**
* @author Rollen-Holt �U�程的中�?/div>
* */
class hello implements Runnable {
public void run() {
System.out.println("执行run�Ҏ��");
try {
Thread.sleep(10000);
System.out.println("�U�程完成休眠");
} catch (Exception e) {
System.out.println("休眠被打�?);
return; //�q�回到程序的调用�?/div>
}
System.out.println("�U�程正常�l�止");
}

public static void main(String[] args) {
hello he = new hello();
Thread demo = new Thread(he, "�U�程");
demo.start();
try{
Thread.sleep(2000);
}catch (Exception e) {
e.printStackTrace();
}
demo.interrupt(); //2s后中断线�E?/div>
}
}
【运行结果】：
执行run�Ҏ��
休眠被打�?/div>

在java�E�序中，只要前台有一个线�E�在�q�行�Q�整个java�E�序�q�程不会��时�Q�所以此时可以设�|�一个后台线�E�，�q�样即��java�q�程��时了，此后台线�E�依然能够��l�运行�?/div>
/**
* @author Rollen-Holt �U�程的优先��
* */
class hello implements Runnable {
public void run() {
for(int i=0;i<5;++i){
System.out.println(Thread.currentThread().getName()+"�q�行"+i);
}
}

public static void main(String[] args) {
Thread h1=new Thread(new hello(),"A");
Thread h2=new Thread(new hello(),"B");
Thread h3=new Thread(new hello(),"C");
h1.setPriority(8);
h2.setPriority(2);
h3.setPriority(6);
h1.start();
h2.start();
h3.start();

}
}
【运行结果】：
A�q�行0
A�q�行1
A�q�行2
A�q�行3
A�q�行4
B�q�行0
C�q�行0
C�q�行1
C�q�行2
C�q�行3
C�q�行4
B�q�行1
B�q�行2
B�q�行3
B�q�行4
。但是请读者不要误以�ؓ优先�U�越高就先执行。谁先执行还是取决于谁先�ȝ��CPU的资源�?/div>

另外�Q�主�U�程的优先��?.
�U�程的礼让�?/div>
在线�E�操作中�Q�也可以使用yield�Q�）�Ҏ��Q�将一个线�E�的操作暂时交给其他�U�程执行�?/div>
/**
* @author Rollen-Holt �U�程的优先��
* */
class hello implements Runnable {
public void run() {
for(int i=0;i<5;++i){
System.out.println(Thread.currentThread().getName()+"�q�行"+i);
if(i==3){
System.out.println("�U�程的礼�?);
Thread.currentThread().yield();
}
}
}

public static void main(String[] args) {
Thread h1=new Thread(new hello(),"A");
Thread h2=new Thread(new hello(),"B");
h1.start();
h2.start();

}
}
A�q�行0
A�q�行1
A�q�行2
A�q�行3
�U�程的礼�?/div>
A�q�行4
B�q�行0
B�q�行1
B�q�行2
B�q�行3
�U�程的礼�?/div>
B�q�行4

同步和死锁：
【问题引出�?比如说对于买��系�l�，有下面的代码�Q?/div>
/**
* @author Rollen-Holt
* */
class hello implements Runnable {
public void run() {
for(int i=0;i<10;++i){
if(count>0){
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(count--);
}
}
}

public static void main(String[] args) {
hello he=new hello();
Thread h1=new Thread(he);
Thread h2=new Thread(he);
Thread h3=new Thread(he);
h1.start();
h2.start();
h3.start();
}
private int count=5;
}
【运行结果】：
5
4
3
2
1
0
-1
�q�里出现�?1�Q�显然这个是错的。，应该��数不能��倹{�?/div>
如果惌��册��U�问题，��需要��用同步。所谓同步就是在�l�一旉��D�中只有有一个线�E�运行，
其他的线�E�必��ȝ��到这个线�E�结束之后才能��l�执行�?/div>
【��用线�E�同步解决问题�?/div>
采用同步的话�Q�可以��用同步代码块和同步方法两�U�来完成�?/div>

【同步代码块】：
语法格式�Q?/div>
synchronized�Q�同步对象）{
//需要同步的代码
}
但是一般都把当前对象this作�ؓ同步对象�?/div>
比如对于上面的买��的问题�Q�如下：
/**
* @author Rollen-Holt
* */
class hello implements Runnable {
public void run() {
for(int i=0;i<10;++i){
synchronized (this) {
if(count>0){
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(count--);
}
}
}
}

public static void main(String[] args) {
hello he=new hello();
Thread h1=new Thread(he);
Thread h2=new Thread(he);
Thread h3=new Thread(he);
h1.start();
h2.start();
h3.start();
}
private int count=5;
}
【运行结果】：�Q�每一�U�输��Z��个结果）
5
4
3
2
1
【同步方法�?/div>
也可以采用同步方法�?/div>
语法格式为synchronized �Ҏ��q�回�c�d�� Ҏ��名（参数列表�Q�{
// 其他代码
}
现在�Q�我们采用同步方法解决上面的问题�?/div>
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
* @author Rollen-Holt
* */
class hello implements Runnable {
public void run() {
for (int i = 0; i < 10; ++i) {
sale();
}
}

public synchronized void sale() {
if (count > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count--);
}
}

public static void main(String[] args) {
hello he = new hello();
Thread h1 = new Thread(he);
Thread h2 = new Thread(he);
Thread h3 = new Thread(he);
h1.start();
h2.start();
h3.start();
}

private int count = 5;
}
【运行结果】（每秒输出一个）
5
4
3
2
1
提醒一下，当多个线�E�共享一个资源的时候需要进行同步，但是�q�多的同步可能导致死锁�?/div>
此处列�D�l�典的生产者和消费者问题�?/div>
【生产者和消费者问题�?/div>
先看一�D�|��问题的代码�?/div>
class Info {

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

private String name = "Rollen";
private int age = 20;
}

/**
* 生��?/div>
* */
class Producer implements Runnable{
private Info info=null;
Producer(Info info){
this.info=info;
}

public void run(){
boolean flag=false;
for(int i=0;i<25;++i){
if(flag){
this.info.setName("Rollen");
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
this.info.setAge(20);
flag=false;
}else{
this.info.setName("chunGe");
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
this.info.setAge(100);
flag=true;
}
}
}
}
/**
* 消费者类
* */
class Consumer implements Runnable{
private Info info=null;
public Consumer(Info info){
this.info=info;
}

public void run(){
for(int i=0;i<25;++i){
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
System.out.println(this.info.getName()+"<---->"+this.info.getAge());
}
}
}

/**
* ��试�c?/div>
* */
class hello{
public static void main(String[] args) {
Info info=new Info();
Producer pro=new Producer(info);
Consumer con=new Consumer(info);
new Thread(pro).start();
new Thread(con).start();
}
}
【运行结果】：
Rollen<---->100
chunGe<---->20
chunGe<---->100
Rollen<---->100
chunGe<---->20
Rollen<---->100
Rollen<---->100
Rollen<---->100
chunGe<---->20
chunGe<---->20
chunGe<---->20
Rollen<---->100
chunGe<---->20
Rollen<---->100
chunGe<---->20
Rollen<---->100
chunGe<---->20
Rollen<---->100
chunGe<---->20
Rollen<---->100
chunGe<---->20
Rollen<---->100
chunGe<---->20
Rollen<---->100
chunGe<---->20
大家可以从结果中看到�Q�名字和�q�龄�q�没有对于�?/div>

那么如何解决呢？
1�Q?加入同步
2�Q?加入�{�待和唤�?/div>
先来看看加入同步会是如何�?/div>
class Info {

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public synchronized void set(String name, int age){
this.name=name;
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
this.age=age;
}

public synchronized void get(){
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
System.out.println(this.getName()+"<===>"+this.getAge());
}
private String name = "Rollen";
private int age = 20;
}

/**
* 生��?/div>
* */
class Producer implements Runnable {
private Info info = null;

Producer(Info info) {
this.info = info;
}

public void run() {
boolean flag = false;
for (int i = 0; i < 25; ++i) {
if (flag) {

this.info.set("Rollen", 20);
flag = false;
} else {
this.info.set("ChunGe", 100);
flag = true;
}
}
}
}

/**
* 消费者类
* */
class Consumer implements Runnable {
private Info info = null;

public Consumer(Info info) {
this.info = info;
}

public void run() {
for (int i = 0; i < 25; ++i) {
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
this.info.get();
}
}
}

/**
* ��试�c?/div>
* */
class hello {
public static void main(String[] args) {
Info info = new Info();
Producer pro = new Producer(info);
Consumer con = new Consumer(info);
new Thread(pro).start();
new Thread(con).start();
}
}
【运行结果】：
Rollen<===>20
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
ChunGe<===>100
从运行结果来看，错�ؕ的问题解决了�Q�现在是Rollen 对应20�Q�ChunGe对于100
�Q�但是还是出��C��重复��d��的问题，也肯定有重复覆盖的问题。如果想解决�q�个问题�Q�就需要��用Object�c�d��忙了�?/div>
�Q�我们可以��用其中的�{�待和唤醒操作�?/div>
要完成上面的功能�Q�我们只需要修改Info�c�饥��_��在其中加上标志位�Q��ƈ且通过判断标志位完成等待和唤醒的操作，代码如下�Q?/div>
class Info {

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public synchronized void set(String name, int age){
if(!flag){
try{
super.wait();
}catch (Exception e) {
e.printStackTrace();
}
}
this.name=name;
try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
this.age=age;
flag=false;
super.notify();
}

public synchronized void get(){
if(flag){
try{
super.wait();
}catch (Exception e) {
e.printStackTrace();
}
}

try{
Thread.sleep(100);
}catch (Exception e) {
e.printStackTrace();
}
System.out.println(this.getName()+"<===>"+this.getAge());
flag=true;
super.notify();
}
private String name = "Rollen";
private int age = 20;
private boolean flag=false;
}

/**
* 生��?/div>
* */
class Producer implements Runnable {
private Info info = null;

Producer(Info info) {
this.info = info;
}

public void run() {
boolean flag = false;
for (int i = 0; i < 25; ++i) {
if (flag) {

this.info.set("Rollen", 20);
flag = false;
} else {
this.info.set("ChunGe", 100);
flag = true;
}
}
}
}

/**
* 消费者类
* */
class Consumer implements Runnable {
private Info info = null;

public Consumer(Info info) {
this.info = info;
}

public void run() {
for (int i = 0; i < 25; ++i) {
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
this.info.get();
}
}
}

/**
* ��试�c?/div>
* */
class hello {
public static void main(String[] args) {
Info info = new Info();
Producer pro = new Producer(info);
Consumer con = new Consumer(info);
new Thread(pro).start();
new Thread(con).start();
}
}
【程序运行结果】：
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
先在看结果就可以知道�Q�之前的问题完全解决�?/div>

Snape 2012-03-31 03:19 发表评论