发布一篇“刻舟求剑”的坏处(java)

在ruby里才是一切皆对象。当然我不并不是很了解ruby，但是ruby确实是将语法简化得很好。
从外表看，稳定类的创建仿佛是一个好计划。可是，一旦真的必要那种新范例的一个修正的对象，就必需辛劳地举行新对象的创立事情，同时另有大概触及更频仍的渣滓搜集。对有些类来讲，这个成绩并非很年夜。但对其他类来讲（好比String类），这一计划的价值显得太高了。
为办理这个成绩，我们能够创立一个“同道”类，并使其可以修正。今后只需触及大批的修正事情，便可换为利用能修正的同道类。完事今后，再切换回不成变的类。
因而，上例可改成上面这个模样：

1. //:Immutable2.java
2. //Acompanionclassformakingchanges
3. //toimmutableobjects.
5. classMutable{
6. privateintdata;
7. publicMutable(intinitVal){
8. data=initVal;
9. }
10. publicMutableadd(intx){
11. data+=x;
12. returnthis;
13. }
14. publicMutablemultiply(intx){
15. data*=x;
16. returnthis;
17. }
18. publicImmutable2makeImmutable2(){
19. returnnewImmutable2(data);
20. }
21. }
23. publicclassImmutable2{
24. privateintdata;
25. publicImmutable2(intinitVal){
26. data=initVal;
27. }
28. publicintread(){returndata;}
29. publicbooleannonzero(){returndata!=0;}
30. publicImmutable2add(intx){
31. returnnewImmutable2(data+x);
32. }
33. publicImmutable2multiply(intx){
34. returnnewImmutable2(data*x);
35. }
36. publicMutablemakeMutable(){
37. returnnewMutable(data);
38. }
39. publicstaticImmutable2modify1(Immutable2y){
40. Immutable2val=y.add(12);
41. val=val.multiply(3);
42. val=val.add(11);
43. val=val.multiply(2);
44. returnval;
45. }
46. //Thisproducesthesameresult:
47. publicstaticImmutable2modify2(Immutable2y){
48. Mutablem=y.makeMutable();
49. m.add(12).multiply(3).add(11).multiply(2);
50. returnm.makeImmutable2();
51. }
52. publicstaticvoidmain(String[]args){
53. Immutable2i2=newImmutable2(47);
54. Immutable2r1=modify1(i2);
55. Immutable2r2=modify2(i2);
56. System.out.println("i2="+i2.read());
57. System.out.println("r1="+r1.read());
58. System.out.println("r2="+r2.read());
59. }
60. }///:~

复制代码

和平常一样，Immutable2包括的办法保存了对象不成变的特性，只需触及修正，就创立新的对象。完成这些操纵的是add()和multiply()办法。同道类叫作Mutable，它也含有add()和multiply()办法。但这些办法可以修正Mutable对象，而不是新建一个。除此之外，Mutable的一个办法可用它的数据发生一个Immutable2对象，反之亦然。
两个静态办法modify1()和modify2()展现出取得一样了局的两种分歧办法。在modify1()中，一切事情都是在Immutable2类中完成的，我们可看到在历程中创立了四个新的Immutable2对象（并且每次从头分派了val，前一个对象就成为渣滓）。
在办法modify2()中，可看到它的第一个举动是猎取Immutable2y，然后从中天生一个Mutable（相似于后面对clone()的挪用，但这一次创立了一个分歧范例的对象）。随后，用Mutable对象举行大批修正操纵，同时用不着新建很多对象。最初，它切换回Immutable2。在这里，我们只创立了两个新对象（Mutable和Immutable2的了局），而不是四个。
这一办法出格合适鄙人述场所使用：
(1)必要不成变的对象，并且
(2)常常必要举行大批修正，大概
(3)创立新的稳定对象价值太高
前些天，在CSDN上看到了一个消息，说是net网页编程网页编程AJAX成功在Linux上运行，这一点对我触动很大，而且引发了我许多感叹，所以想写出来分享一下。

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。