Practical Java

声明：原创作品，转载时请注明文章来自SAP师太技术博客（ 博/客/园ｗｗｗ.ｃｎｂｌｏｇｓ.ｃｏｍ）：www.cnblogs.com/jiangzhengjun，并以超链接形式标明文章原始出处，否则将追究法律责任！原文链接：http://www.cnblogs.com/jiangzhengjun/p/4259259.html

实践1、    参数是以by value方式而非by reference方式传递

一个普通存在的误解是：java中的参数是以 by value 方式传递。其实不是这样的，参数是以 by value 方式传递的。请看示例：

class PassByValue {

public static void modifyPoint(Point pt, int j) {

pt.setLocation(5,5);                   //1

j = 15;

System.out.println("During modifyPoint " + "pt = " + pt +

" and j = " + j);

}

public static void main(String args[]) {

Point p = new Point(0,0);              //2

int i = 10;

System.out.println("Before modifyPoint " + "p = " + p +

" and i = " + i);

modifyPoint(p, i);                     //3

System.out.println("After modifyPoint " + "p = " + p +

" and i = " + i);

}

}

这显示，modifyPoint()改变了 //2 所建立的Point对象，却没有改变 int i。在main()之中，i被赋值为10。由于参数通过by value方式传递，所以modifyPoint()收到i的一个副本，然后它将这个副本必为15并返回。main()内的原值i并没有受到影响。

对于Point对象，其实modifyPoint()是与“Point对象的reference p 的复件”打交道，而不是与“Point 对象的复件”打交道。记住，p是个object reference，并且Java以by value方式传递参数，或者更准确点说，Java以by value方式传递object reference。当p从main()被传入modifyPoint()时，传递的是p（也就是一个reference）的复件。所以modifyPoint()是在与同一个对象打交道，只不过通过别名pt罢了。在进入modifyPoint()之后和执行//1之前，内存中应该是这样的：

如果你并不想modifyPoint()改变传进的Point对象，你可以传递一个克隆对象（见64、66）或者将Point设计成不可变的（见65）。

实践2、    对不变的data和object references使用final

class FinalTest {

static final int someInt = 10;

static final StringBuffer objRef = new StringBuffer("sring");

static void prt() {

System.out.println("someInt=" + someInt + " - objRef=" + objRef);

}

public static void main(String[] args) {

prt();

//不能重新分配 FinalTest.someInt

//!!someInt = 20;//1

objRef.append(" other");//2

//不能重新分配 FinalTest.objRef

//!!objRef = new StringBuffer(); //3

prt();

}

}

输出：

someInt=10 - objRef=sring

someInt=10 - objRef=sring other

程序里的//1处理我们应该很清楚了，但//2处又是为什么呢？我们不是已经声明objRef声明成final，为什么还能改变？不，我们确实没有改变objRef的值，我们改变的是objRef所指对象的值，objRef并无变化，仍然指向同一个对象。变量objRef是一个object reference，它指向对象所在的heap位置。而//3处正是我们想的那样，编译出错了，因为你试图改objRef的值，换而言之，它企图令objRe指向其他物体。然而objRef所指对象并不受关键词final的影响，因此所指向的对象本身是可变的。

关键词final只能防止变量值的改变。如果被声明为final的变量是个object reference，那么该reference不能被改变，必须永远指向同一个对象，然而被指向的那个对象是可以随意改变的。

实践3、    缺省情况下所有non-private、non-static函数都可以被覆写

缺省情况下，类中任何non-private、non-static函数都允许被子类覆写。类的设计者如果希望阻止子类覆写（修改）某个函数，则必须采取明确的动作，也就是将该函数声明为final。

关键字final在Java中有多重用途，即可被用于变量（不能修改），也可用于类（不能继承）与方法（不能覆写）。

声明某个类为final，也就暗暗声明了这个类的所有函数都为final。这种做法可以阻止它派生类，从而禁止任何人覆写此类的所有函数。如果这种设计对你而言过于严苛，也可以考虑只将某些方法声明成final，这种方式允许你派生出类，但不允许你覆写你声明成final的方法。另外，final比non-final方法的性能要高。

实践4、    在arrays和ArrayList之间慎重选择

在新建一个数组时，每个元素都将依据其自己类型而被赋予缺省值：boolean-false，char- '\u0000'，byte、short、int、long-0，float、double-0.0，object reference-null。

数组的容量是固定的，一旦指定了就不可更改，但ArrayList的容量是可变的，它会随着元素的增加自动的增长。数组即可存放基本类型也可存储引用类型，而ArrayList只能存放引用类型元素（虽然1.5可以，但这是借助于自动装箱特性实现的）。

数组比ArrayList拥有更高的性能。

实践5、    多态（polymorphism）优于instanceof

//员工

interface Employee {

public int salary();//工资计算

}

//经理

class Manager implements Employee {

private static final int mgrSal = 40000;//工资

public int salary() {

return mgrSal;

}

}

//程序员

class Programmer implements Employee {

private static final int prgSal = 50000;

private static final int prgBonus = 10000;//奖金

public int salary() {

return prgSal;

}

public int bonus() {

return prgBonus;

}

}

//薪水册

class Payroll {

public int calcPayroll(Employee emp) {

int money = emp.salary();

if (emp instanceof Programmer)

//如果是程序员，则计算奖金

money += ((Programmer) emp).bonus();

return money;

}

public static void main(String args[]) {

Payroll pr = new Payroll();

Programmer prg = new Programmer();

Manager mgr = new Manager();

System.out.println("程序员的薪水 " + pr.calcPayroll(prg));

System.out.println("经理的薪水 " + pr.calcPayroll(mgr));

}

}

避免使用instanceof，现重构上面的程序。在Employee中可以增加一个bonus()接口，然后员工都实现他，经理没奖金时直接返回0，这样就不用在calcPayroll方法里使用instanceof了。

使用instanceof首先缺乏性能，不够优雅，也不易扩充（如在以后版本中增加另一种Employee，并有另外的福得怎么办？），其次要求程序员写代码去做Java运行期该做的事。而多态则完全可以避免这些问题。

如果这里要为使用instanceof找个理由，那就是Employee不是你设计的，你不能去重构它们。

instanceof操作符很容易被误用。很多场合都应该以多态来替代instanceof。无论何时当你看见instanceof，都请判断是否可以改进设计以消除它。以多态方式改进设计，会产生更合逻辑、更经得起推敲的设计，以及更易维护的代码。

实践6、    必要时使用instanceof

除了实践5中面对一个设计不当的class程序库时，你可能无法避免使用instanceof。事实上有更多常见情形，使你除了使用instanceof以外另无选择，如当你必须从一个基础类型向下转型为派生类型时。

将一个类型强转为另一个不相关的类型时，在编译时就会出错。而将一个基本类型强转为派生类型时在运行时可能出错。

使用instanceof可以消除强转型在运行时的错误。

在1.5以前，如果我们将不同类型的对象放入到集合中后，在取出时都是一个Object类型，这是instanceof就可以排上用场了，因为它可以消除运行期的错误。

实践7、    一旦不再需要object reference，就将它设为null

当不再需要某对象时，你可以将其reference设为null，以协助垃圾回收器取回内存，如果你的程序执行于一个内存受限环境中，这可能很有益处。你可以试着这么做：

public static void main(String args[]){

LargeObject lo = new LargeObject();//大对象

// 使用大对象

//...

// 大对象不再需要，置为null

lo = null;

//  如果确实紧需内存（但不能保证立刻加收，只是建议）

System.gc();

// 后面程序还需要运行很长一段时间...

//...

}

为了尽量降低内存乃是，与程序同寿的对象必须尽可能体积小。此外，大块头对象应该尽量“速生速灭”。

检阅代码时，请注意大块头对象，尤其是那些存在于完整（或大部分）程序生命中的对象。你得要仔细研究这此对象的建立与运用，以及它们使用多少内存，如果它们引用了大量内存，请确定是否所有那些在对象生命周期内都真的被需要。也许某些大对象可以解甲归田，从而使其后执行的代码能够更高效地运行。

任何刻候你都可以通过System.gc()要求垃圾回收器起身运行（注，还是只是建议，当控制从方法调用中返回时，虚拟机已经尽最大努力回收了所有丢弃的对象）。如果想将一个对象解除引用，则可以通过调用System.gc()要求垃圾回收器立刻运转，在代码继承执行前先回收被解除引用的那块内存，但你应当仔细都考虑这种做法为你的程序性能带来的潜在影响。

许多垃圾回收算法会在它们运转之前先虚悬其他所有线程，这种做法可以确保一旦垃圾回收器开始运转，就能够拥有heap的完整访问权，可以安全完成任务而不受其他线程的威胁。一旦垃圾回收器完成了任务，便恢复此前被虚悬的所有线程。

因此，通过System.gc()显示调用，要求垃圾回收器起而运行，你得冒“因执行回收工作而带来延迟”的风险，延迟程度取决于JVM所采用的垃圾回收算法。

大多数JVM的垃圾回收器都会足够的运行，因此你实在不必显式地调用它。然而，如果你的代码有些部分期望在继续进行前先释放所有可能的内存，则可以考虑调用System.gc()。

第二章     对象与相等性

实践8、    区别reference类型与primitive类型

int i = 5;//基本类型

Integer j = new Integer(10);//引用类型

这两个变量都存储在局部变量表（即栈，Stack），它们的操作都在Java操作数堆栈（还是栈）中进行，但二者所表述的意义完全不同。不论是基本类型int或object reference，它们都是static中占据32bits空间，但Integer对象在stack中记录的并不是对象本身，而是对象的reference。

所有Java对象都是通过Object reference来访问的，那是某种形式的指针，该指针指向heap中的某块区域，heap则为对象的生存提供了真实存储场所。当你声明了一个基本类型后，你就为它声明了一份存储空间。前面两行代码可以这样表示：

如果你使用primitive类型，便免除了“调用new以创建包装对象”的需要，这可节省时间和空间。

下面看看输出结果是否你是预想的：

class Assign{

public static void main(String args[]) {

int a = 1;

int b = 2;

Point x = new Point(0,0);

Point y = new Point(1,1);//1

System.out.println("a is " + a);

System.out.println("b is " + b);

System.out.println("x is " + x);

System.out.println("y is " + y);

System.out.println("Performing assignment and " +

"setLocation...");

a = b;

a++;

x = y;//2

x.setLocation(5,5);//3

System.out.println("a is " + a);

System.out.println("b is " + b);

System.out.println("x is " + x);

System.out.println("y is " + y);

}

}

输出结果如下：

a is 1

b is 2

x is java.awt.Point[x=0,y=0]

y is java.awt.Point[x=1,y=1]

Performing assignment and setLocation...

a is 3

b is 2

x is java.awt.Point[x=5,y=5]

y is java.awt.Point[x=5,y=5]

上面代码运行进内存表示如下，经过//1后的情形：

经过//2赋值动作后情形：

当//3调用setLocation()时，函数作用于x所指的对象。由于x和y指向同一个对象，故而形成：

由于x和y指向同一个对象，所有执行于x身上的函数，就好像执行于y身上一样。

弄清楚reference类型和primitive类型之间的差异，以及理解references语义到关重要，否则会导致代码的行为和预想不同。

实践9、    区别==和equals()

“==”用于基本类型时，比较的就是它们所存储值的大小；如果是用于引用类型，它比较的还是所存储值的大小，不过这时这个值是个特殊的值——它们是对象在heap中的地址，所以当它用于对象时比较的是对象地址，如果被比较的对象指向同一对象，则相等，否则不等。

Integer ia = new Integer(10);

Float fa = new Float(10.0f);

System.out.println(ia.equals(fa));//false

System.out.println(fa.equals(ia));//false

为什么上面打印的最是false？这不同基本类型的数值彼止可能相等（如果不同类型则会先提升类型后再比），但不同类型的对象则不然。打开类库源就会发现，它们都是先使用instanceof来测试传进被比较对象是否是同一个类型，如果不是则直接返回false。虽然我们可以自己订制一个equals让不现类型的对象也相等，但并不推荐你这么做，这违反equals业界规范。

这里再次说明的是：请使用“==”测试两个基本类型是否完全相同，或测试两个object references是否指向同一个对象；请使用equals()比较两个对象是否一致——基准点是其属性（此处是指对象的实值内容，也就是数据值域field）。我们把“根据属性来比较两个对象是否相等”称为“等值测试”，或称为“语义上的相等测试”。

实践10、            不要依赖equals()的缺省实现

如果你设计的类没有重写equals()方法，那么你在使用equals时将会使用Object中的equals默认实现，它们比较的是否指向同一个对象，而不是对象的逻辑值是否相等，源码如下：

public boolean equals(Object obj) {

return (this == obj);

}

String类正确的实现了equals()方法，但StringBuffer类根本就没有重写Object中的equals()方法。如果遇到StringBuffer，则需要将它先转换为String再使用equals相互比较。1.5中的StringBuilder与StringBuffer一样。

String、StringBuffer、StringBuilder都是final类。

equals()使用准则：

1、  若要比较对象是否相等，其class有责任提供一个正确有equals()。

2、  要“想当然地调用equals()”之前，应该先检查并确保你所使用的class的确实现了equals()。

3、  如果你所使用的class并未实现equals()，请判断java.lang.Object的缺省函数是否可胜任。

4、  如果无法胜任，就应该在某个外覆类（wrapper class）或subclass中撰写你自己的equals()方法（比如你设计的类中关键域是StringBuffer之类的类型，你得需要继承它重写它的equals方法，但它是final类，所以使用组合的方式设计功能类似的StringBuffer，并提供equals方法；或者不重新设计功能类似StringBuffer的类而是直接在使用StringBuffer的类中提供一个比较方法对StringBuffer进行专门的比较）。

实践11、            不要依赖equals()的缺省实现