CSDN博客

img jery_lee

竹笋炒肉转载 -- 读《Effective java 中文版》(3)

发表于2004/10/13 22:33:00  1083人阅读

FROM 竹笋炒肉 http://hedong.3322.org/


读《Effective java 中文版》(21)
第20条:用类层次来代替联合
  C语言中的联合(union)是用来定义可以容纳多种数据类型的数据结构,常见用法是在一个结构中包含一个联合和一个标签(标签通常是某一个枚举(enum)类型),用标签指明联合中存放的是哪种数据类型的数据,这也被称为可区分的联合。Java语言中,union结构被子类型化这种机制代替。


  类层次与可区分的联合相比,有N多好处:

类层次提供了类型的安全性,而C语言中如果标签的指示与union存放对象不一致,则会出错。

代码简洁明了。

容易扩展,即使多方在独立的工作。

可以反映出这些类型之间本质上的层次关系,从而允许更强的灵活性,以及更好的编译时类型检查。

  当要编写一个类,而其中包含一个显式的标签域的时候,就应该考虑这个标签是否可以被取消而用一个类层次来代替。
  C语言中union的另一个用途是,查看一片数据的内部表示。看例:
union{
float f;
int bits;
}sleaze;

sleaze.f=6.699e-41;
print("%x/n",sleeze.bits);

  在java语言中可以这样做:
system.out.println(Integer.toHexString(Float.floatToIntBits(6.699e-41f)));

 

读《Effective java 中文版》(22)
第21条:用类来代替enum结构
  C语言中,enum结构定义一个枚举类型:它的合法值是由一组固定的常量组成的。但这种类型定义有问题:

它只是定义了一组被命名的整数常量,在类型安全和使用方便性方面没有提供任何帮助。如:
typedef enum{FUJI, PIPPIN, GRANNY_SMITH}apple_t;
typedef enum{NAVEL,TEMPLE,BLOOD} orange_t;
下一行是合法的:
orange_t myFavorite=PIPPIN;/*mixing apples and oranges*/
下一行是可怕的:
orange_t x=(FUJI-PIPPIN)/TEMPLE;/* Applesauce! */

enum结构并没有为它产生的常量建立起一个名字空间,如下面则会出现冲突:
typedef enum{BLOOD, SWEAT, TEARS} fluid-t;

用enum结构定义的类型是非常脆弱的。在enum类型增加新的常量而不重新编译客户程序,会引起不可预知的行为。多个开发方不能独立地为这样的类型增加常量,因为可能冲突。

enum结构中没提供便利的方法来将枚举常量转换成可打印字符串,或者枚举出一个类型中的所有的常量。

  不幸的是,java中最常用的针对枚举类型的模式,也有这些缺点,如例:
//the int enum pattern - problematic!!
public class PlayingCard{
public static final int SUIT_CLUBS =0;
public static final int SUIT_DIAMONDS =1;
public static final int SUIT_HEARTS =2;
public static final int SUIT_SPADES =3;
....
}


  幸运的是,java程序还有被称为类型安全枚举的模式:定义一类来代表枚举类型的单个元素,并且不提供任何公有的构造函数,相反提供公有的静态final域,使枚举类型的每一个常量都对应一个域。如:
//the typesafe enum pattern
public class Suit{
private final String name;
private Suit(String name){this.name=name;}
public String toString(){return name;}
public static final Suit CLUBS =new Suit("Clubs");
public static final Suit DIAMANDS=new Suit("Diamands");
public static final Suit HEARTS =new Suit("Hearts");
public static final Suit SPADES =new Suit("Spades");
}
  即使这个类没有声明为final,客户也没法创建这个类的对象,也无法扩展这个类,因而除了通过这些公有的静态final域导出的Suit对象之外,永远不会有其它的对象存在。
  好处:

提供了编译的类型安全性

多个“类型安全枚举”可以包含相同名字的枚举常量,因为每个类都有自己的命名空间。

新的常量加入到一个类型安全枚举类中,无需重新编译客户代码,因为常量并没有被编译到客户代码中。

可以通过改写toString来允许其值转化为可打印字符串。

因为任何方法都可以被加到类型安全枚举中类中,所以它们可以实现任何接口。如Comparable:
//ordinal-based typesafe enum
public class Suit implements Comparable{
private final String name;
private static int nextOrdinal=0;
private final int ordinal = nextOrdinal++;
private Suit(String name){this.name=name;}
public String toString(){return name;}
public int compareTo(Object o){
return ordinal-((Suit)o).ordinal;
}
public static final Suit CLUBS =new Suit("Clubs");
public static final Suit DIAMANDS=new Suit("Diamands");
public static final Suit HEARTS =new Suit("Hearts");
public static final Suit SPADES =new Suit("Spades");
}


因为类型安全枚举类型的常量是对象,所以你可以把这些常量放到集合中。如:
private static final Suit[] PRIVATE_VALUES={CLUBS, DIAMAONDS, HEARTS, SPADES};
public static final List VALUES=Collection.unmodifiableList(Array.asList(PRIVATE_VALUES));

基于序数形式的类型安全枚举模式,在声明中增加implements Serializable,然后提供一一个readResolve方法,即可支持序列化。
private Object readResolve() throws ObjectStreamException{
return PRIVATE_VALUES[ordinal];
}

类型安全枚举类在性能可与int枚举常量相比美,因为可以使用“引用的同一性比较”来检查逻辑上的相关等关系。

  使得一个类型安全枚举类可以扩展,只需要提供一个受保护的构造函数即可。
对客户没有用的方法,应声明为prtotected,对客户隐藏,允许子类修改。且如果没有合理的默认实现,应声明为abstract.
改写equals和hashCode,使他们成为final,以保证该枚举类型的所有相等的对象也一定是相同的

  看一个可扩展的、可序列化的类型安全枚举类:
//Serializable,extensible typesafe enum
public abstract class Operation implements Serializable{
private final transient String name;
protected Operation(String name){this.name=name;}

public static Operation PLUS=new Operation("+"){
protected double eval(double x,double y){return x+y;}
};
public static Operation MINUS=new Operation("-"){
protected double eval(double x,double y){return x-y;}
};
public static Operation TIMES=new Operation("*"){
protected double eval(double x,double y){return x*y;}
};
public static Operation DIVIDE=new Operation("/"){
protected double eval(double x,double y){return x/y;}
};

protected abstract double eval(double x,double y);

public String toString(){return this.name;}
public final boolean equals(Object that){
return super.equals(that);
}
public final int hashCode(){
return super.hashCode();
}

//the 4 following lines are necessary fro serialization
private static int nextOrdinal =0;
private final int ordinal=nextOrdinal++;
private static final Operation[] VALUES={PLUS, MINUS, TIMES, DIVIDE};
Object readResolve() throws ObjectStreamException{
return VALUES[ordinal];
}
}
//subclass of extensible , serializable typesafe enum
abstract class ExtendedOperation extends Operation{
ExtendedOperation(String name){super(name);}

public static Operation LOG=new Operation("log"){
protected double eval(double x,double y){return Math.log(x)/Math.log(y);}
};
public static Operation EXP=new Operation("exp"){
protected double eval(double x,double y){return Math.power(x,y);}
};
//the 4 following lines are necessary fro serialization
private static int nextOrdinal =0;
private final int ordinal=nextOrdinal++;
private static final Operation[] VALUES={LOG,EXP};
Object readResolve() throws ObjectStreamException{
return VALUES[ordinal];//canonicalize
}
}

  与int模式相比,类型安全枚举模式的缺点:

把类型安全枚举常量组合到一起比较困难

不能用在switch语句中

类型安全枚举需要一定的时空开销

 

读《Effective java 中文版》(23)
第22条:用类和接口来代替函数指针
  C语言支持函数指针,其主要用途是实现Strategy(策略)模式,典型的应用如比较器函数,就是策略模式的一个例子。Java省略了函数指针,因为对象引用可以被用于提供同样的功能。如例:
class StringLengthComparator{
public int compare(String s1,String s2){
return s1.lenght()-s2.length();
}
}


  java中实现策略模式,声明一个接口来表示该策略,且为每个具体策略声明一个实现了该接口的类。如果一个具体策略只被使用一次,则常用匿名类实现声明和实例化。如果一个具体策略要被导出以重复使用,则常为一个私有的静态成员类,且通过一个公有静态final域被导出,其类型为该策略接口。
  作为一个典型的具体策略类,StringLengthComparator类是无状态的,没有域,它作为一个singleton非常合适,如下:
class StringLengthComparator{
private StringLengthComparator(){}
public static final StringLengthComparator INSTANCE=new StringLengthComparator();
public int compare(String s1,String s2){
return s1.lenght()-s2.length();
}
}
  在设计具体策略类的时候,还需要定义一个策略接口,如:
//Stragetegy interface
public interface Comparator{
public int compare(Object o1,Object o2);
}
  具体的策略类往往使用匿名类声明,如:
Arrays.sort(stringArray,new Comparator(){
public int compare(Object o1,Object o2){
String s1=(String)o1;
String s2=(String)o2;
return s1.length()-s2.length();
}
});
  由于策略接口被用做所有具体策略实例的类型,故不必将具体策略类做成公有的。如下:
//exporting a concrete stategy
class Host{
...
private static class StrlenCmp implements Comparator , Serializable{
public int compare(Object o1,Object o2){
String s1=(String)o1;
String s2=(String)o2;
return s1.length()-s2.length();
}
}
//returned comparator is serializable
public static final Comparator STRING_LENGTH_COMPARATOR=new StrLenCmp();
}

 


读《Effective java 中文版》(24)
第23条:检查参数的有效性
  当编写一个方法或者构造函数的时候,应该考虑对于它的参数有哪些限制,且应把这些限制写到文档中,然后在这个方法体的起始处,通过的检查来实施这些限制。


  对于公有的方法,使用javadoc的@throws标签在文档中写下“一旦针对参数值的限制被违反之后将会抛出的异常”,如IllegalArgumentException、IndexOutOfBoundsException或NullPointerException。
  非公有的方法,通常应该使用assertions断言来检查它们的参数。
  一些情况下可以不进行参数限制,如:

有效性检查工作非常昂贵
检查根本不切实际
计算过程中隐含着有有效性检查的工作.此时,如果由于无效参数而致的计算抛出的异常,与声明中的异常并不匹配,则需要使用异常转译技术。

 

读《Effective java 中文版》(25)
第24条:需要时使用保护性拷贝
  从安全的角度考虑,应该设计面对客户的不良行为时仍能保持健壮性的类,无论系统的其它部分发生什么事情,这些类的约束都可以保持为真。


  下面是一个有问题的例子:
//Broken "immutable" time period class
public final class Period{
private final Date start;
private final Date end;

/**
*@param start the begining of the period
*@param end the end of the period
*@throws IllegalArgumentException if start is after end
*@throws NullPointerException if start or end is null
*/
public Period(Date start,Date end){
if (start.compareTo(end)>0) throw new IllegalArgumentException(start+" after "+end);
this.start=start;
this.end =end;
}
public Date start(){
return start;
}
public Date end(){
return end;
}
....//remainder omitted
}
  由于Date本身可变,所以约束条件很容易被打破,如下:
//attack the internals of a Period instance
Date start=new Date();
Date end=new Date();
Period p=new Period(start,end);
end.setYear(78);//modify the internals of P!!
  为保护Period实例的内部信息免受攻击,对构造函数的每个参数进行保护性拷贝是必要的。而且,保护性拷贝要在检查参数的有效性之前进行,并且有效性检查是针对拷贝后的对象而不是原始的对象,以防止其它的线程会修改原始值。如下:
//repared constructor- make defensive copy of parameters.
public Period(Date start,Date end){
this.start=new Date(start.getTime());
this.end=new Date(end.getTime());
if(this.start.compareTo(this.end)>0) throw new IllegalArgumentException(start+" after "+end);
}
  注意,如果一个类可以被子类化,则不要用clone方法进行参数的保护性拷贝。

  到目前为止,虽然对Period类进行了保护,但对它的攻击还是有可能的。如下:
//second attack on the internals of a Period instance.
Date start=new Date();
Date end=new Date();
Period p=new Period(start,end);
p.end().setYear(78);//modifis the internal of p!!
  此时要对相关的方法进行修改,要求它们返回的是内部域的保护性拷贝即可,如下:
//repaired accessors-make defensive copies of internal fields
public Date start(){
return (Date)start.clone();
}
public Date end(){
return (Date)end.clone();
}
  至此,“一个周期的起始时间不能落后于结束时间”的约束,才真正做的到。

  只要有可能,都使用非可变的对象做为对象内部的组件,这样就不必关心保护性拷贝的问题。

 


读《Effective java 中文版》(26)
第25条:谨慎地设计方法的原型


谨慎选择方法的名字
不要过于追求提供便利的方法。
只有当一个方法被用的非常频繁的时候,才考虑为它提供一个快捷方法。如果不能确定,还是不考虑为好。
避免长长的参数列表。
三个参数应为实践中的最大值。有两项技术可以缩短方法的参数列表:
把一个方法分解成多个方法,每个方法只要求这些参数一个子集。
创建辅助类,来保存参数的聚集
对于参数类型,优先使用接口而不是类
例如,应该使用Map而不是Hashtable作为参数类型。
谨慎地使用函数对象

 


读《Effective java 中文版》(27)
第26条:谨慎地使用重载

  下面的例子希望能识别出实例的类型分别为Set, List, 和unkown:
//broken - incorrect use of overloading.
public class CollectionClassifier{
public static String classify(Set s){
return "Set";
}
public static String classify(List l){
return "List";
}
public static String classify(Collection c){
return "Unkown collection";
}
public static void main(String[] args){
Collection[] tests=new Collection[]{
new HashSet(),
new ArrayList();
new HashMap().values()};
for(int i=0;i System.out.println(classify(tests[i]));
}
}
}
  显示结果却是unkown,unkown,unkown,:(,虽然常识是“重载方法的选择是静态的,改写方法的选择是动态的”。
  下面是重写的一个例子:
class A{
String name(){return "A";}
}
class B extends A{
String name(){return "B";}
}
class C extends B{
String name(){return "C";}
}
public class Overriding{
public static void main(String[] args){
A[] tests=new A[]{new A(), new B(), new C()};
for(int i=0;i }
}
  打印结果当然是"ABC"了。
  因为改写机制是规范,而重载机制是例外,所以改写机制满足了人们对于方法调用的行为的期望,而重载机制很容易混淆这些期望。以避免重载机制的混淆用法的方法有

一个安全而保守的策略是,永远不要导出两个具有相同参数数目的重载方法。

对于每一对重载方法,只有一个对应的形参具有“根本不同”的类型,指把一个参数的类型转换为另一个类型是不可能的。

对于构造函数或实现某个接口时,可能会较多地出现重载的机会,前者可考虑用静态工厂,后者可以考虑两个重载方法合并。

 


读《Effective java 中文版》(28)
第27条:返回零长度的数组而不是null
  看例子:
private List cheeseInStock=...;
/**
* @return an array containing all of the cheese in the shop,
* or null if no cheeses are available for purchase.
*/
public Cheese[] getCheeses(){
if( cheeseInStock.size==0) return null;
...
}
  调用这个方法时,需要:
Cheese[] cheeses=shop.getCheeses();
if(cheeses!=null && Arrays.asList(shop.getCheeses()).contains(Cheese.STILTON))
System.out.println("Jolly good, just the thing");

  如果改用返回长度为0的数组,则是这样:


private List cheesesInStock=...;
private final static Cheese[] NULL_CHEESE_ARRAY=new Cheese[0];
/**
* @return an array containing all of the cheeses in the shop.
*/
public Cheese[] getCheese(){
return (Cheese[])cheeseInStock.toArray(NULL_CHEESE_ARRAY);
}
  调用代码改为:
if(Arrays.asList(shop.getCheeses()).contains(Cheese.STILTON))
System.out.println("Jolly good, just the thing");

 

 

读《Effective java 中文版》(29)
第28条:为所有导出的API元素编写文档注释
  为了正确地编写API文档,必须在每一个被导出的类、接口、构造函数、方法和域声明之前增加一个文档注释。

每个文档注释应简洁描述出它和客户之间的约定,以说明这个方法做了什么而不说明它是如何做的,专门为继承而设计的类例外。

通过@throws和@param来说明调用这个方法的前提条件。

还要描述它的副作用(指系统状态中一个可观察到的变化,它不是为了获得后置条件而要求的变化。

应该描述一个类的线程安全性

 

  具体编写时的一些注意事项:


@param和@return后跟一个名词短语,@throws后跟一个if语句再加一个名词短语。

可以HTML元字符和标签,尤其是>、<、&符号不要忘了转义。

单词this指被调用的方法所在的实例

元素文档的第一句话是概要描述,注意不要在第一句话内部使用句号(.),如果非要出现可以使用.来代替。
对于方法和构造函数,概要描述是一个动词短语;
对于类、接口或域,是一个名词短语。

  从1.2.2开始,javadoc已经有“自动重用”或“继承”方法注释的能力了。

 


读《Effective java 中文版》(30)
第29条:将局部变量的作用域最小化
  应该打破C语言设计的一个习惯:局部变量须被声明在代码块的开始处。java语言允许在任何可以出现语句的地方声明变量。


  使一个局部变量的作用域最小化,最有力的技术是在第一次使用它的地方声明。几乎每一个局部变量的声明都应包含一个初始化表达式,如果没有足够的信息进行初始化,则应该推迟这个声明,try-catch是个例外。
  最小化局部变量作用域的另一项技术是方法小而功能单一。
  最常见的局部变量作用最小化的例子是for循环,相对于while循环,除了前者可以少一行代码外,前者可以避免“复制-粘贴”类错误。如下例:
Iterator i=c.iterator();
while(i.hasNext()){
doSomething(i.next());
}
Iterator i2=c2.iterator();
while(i.hasNext()){ //BUG!!!
doSomething(i2.next());
}
-------------------------------------
for (Iterator i=c.iterator();i.hasNext();){
doSomething(i.next());
}
for (Iterator i2=c2.iterator();i.hasNext();){//Compile-time error.
doSomething(i2.next());
}

阅读全文
0 0

相关文章推荐

img
取 消
img