Effective Java
@(java)[书籍]
一. Creating and Destorying Objects
- 考虑用静态工厂方法替代构造器
- Advantage:
- 静态工厂方法有名称:如果构造器的参数本身没有确切地描述正被返回的对象,那么具有适当名称的静态工厂会更容易使用,产生的客户端代码也更容易阅读。当一个类需要多个带有相同签名的构造器时,就用静态工厂方法代替构造器,并且慎重地选择名称以便突出它们之间的区别。
- 不必在每次调用它们的时候都创建一个新对象
- 它们可以返回原返回类型的任何子类型的对象
- 在创建参数化类型实例的时候,它们使代码变得更加简洁
- Disadvantage:
- 类如果不含有公有的或受保护的构造器,就不能被子类化。
- 它们与其他的静态方法实际上没有任何区别:下面列举一些静态工厂方法的惯用名称:
- valueOf——不太严格地讲,该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转换方法。
- of——valueOf的一种更为简洁的替代。
- getInstance——返回的实例是通过方法的参数来描述的,但是不能够说与参数具有同样的值。对于单例来说,该方法没有参数,并返回唯一的实例。
- newInstance——像getInstance一样,但newInstance能够确保返回的每个实例都与所有其他实例不同。
- getType——像getInstance一样,但是在工厂方法处于不同的类中的时候使用。
- newType——同理。
- Advantage:
- 遇到多个构造器参数时考虑用构建器
- 程序员一向习惯采用重叠构造器(telecsoping construstor)模式,在这种模式下,会根据参数组合来写构造器,但是当有许多参数的时候,客户端代码会很难编写,并且难以阅读。
- 还有第二种方法,即JavaBeans模式,在这种模式下,调用一个无参构造器来创建对象,然后调用setter方法来设置每个必要的参数,以及每个相关的可选参数。但是缺点是:JavaBeans可能处于不一致的状态,也阻止了把类做成不可变的可能。
- 最佳解决方案就是* 构建器模式 builder pattern *了:客户端使用所有必要的参数调用构造器,得到一个builder对象,然后客户端调用builder对象中的如setter方法来设置想要的可选参数,最后,客户端调用一个无参build()方法来生成一个不可变对象。builder是一个静态成员类。
public class MutritionFacts{
private final int requireField;
private final int optionField;
public static class Builder{
private final int requireField;
private final int optionField=0;
public Builder(int requireFeild{
this.requireFeild=requireFeild;
}
public Builder optionField(int val){
optionField=val;
return this;
}
public NutritionFacts build(){
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder){
requireFeild=builder.requireFeild;
optionFeild=builder.optionFeild;
}
public static void main(String[] args){
NutritionFacts cocaCola=new NutritionFacts.Builder(110).optionFeild(120).build();
}
}
- 使用私有构造器或者枚举类型强化singleton属性
- 实现Singleton有两种方法,这两种方法都要把构造器保持为私有的,并导出公有的静态成员。
- 方法一:公有静态成员是个final 字段;组成类的成员的声明很清楚地表明了这个类是一个Singleton
//Singleton with public final field
public class Elvis{
public static final Elvis INSTANCE=new Elvis();
//有特殊权限的客户端可以调用私有构造器,通过反射,AccessibleObject.setAccessible方法。
private Elvis(){};
public void leaveTheBuilding(){};
}
- 方法二:公有静态成员是一个静态工厂方法。该方法提供了灵活性:在不改变其API的前提下,我们可以改变该类是否应该为Singleton的想法,工厂方法返回该类的唯一实例,但是,它可以很容易被修改,比如改称为每个调用该方法的线程返回一个唯一的实例。
//Singleton with static factory
public class Elvis{
private static final Elvis INSTANCE=new Elvis():
private Elvis(){};
public static Elvis getInstance(){
return INSTANCE;
}
public void leaveTheBuilding(){};
}
- 通过私有构造器强化不可实例化的能力
- 有时候,你可能需要编写只包含静态方法和静态字段的类,这样的工具类不希望被实例化,实例。如果企图通过将类做成抽象类来强制该类不可被实例化,这是行不通的。该类可以被子类化,并且该子类也以备实例化,同时也会误导用户。因此我们只要让这个类包含私有构造器,它就不能被实例化了。
public class UtilityClass{
private UtilityClass(){
throw new AssertionError();
}
}
- 避免创建不必要的对象
- 如果对象是不可变的,它就始终可以被重用
- 对于同时提供了静态工厂方法和构造器的不可变类,通常可以使用静态工厂方法而不是构造器,以避免创建不必要的对象。例如:静态工厂方法Boolean.valueOf(String)几乎总是优先于构造器Boolean(String)
- 除了重用不可变对象,还可以重用那些不会再被更改的可变对象
- 要优先使用基本类型而不是装箱基本类型,要当心无意识的自动装箱
public static void main(String[] args){
Long sum=0L;
for(long i=0;i<Interger.MAX_VALUEL;i++){
//这里sum是包装类Long,相当与创建了很多个对象
sum+=i;
}
System.out.println(sum);
}
排除过期的对象引用
例如一个栈中存储着对象,如果栈先入栈再出栈,可是没有对出栈的对象赋值为null,那么这些对象就无法进行垃圾回收,因为栈还维护着这些对象的引用,从而造成内存泄露。
只要类是自己管理内存,程序员就应该警惕内存泄露问题。一旦元素被释放掉,则该元素中包含的任何对象引用都应该被清空。
- 内存泄露的另一个常见来源是缓存(略,弱引用)
- 内存泄露的第三个常见来源是监听器和其他回调。如果你实现了一个API,客户端在这个API中注册回调,却没有显示地取消注册,那么除非你采取某些动作,否则他们就会被积累。(略)
public Object pop(){
if(size==0){
throw new EmptyStackException();
Object result=elements[--size];
elements[size]=null;
return result;
}
}
- 避免使用finalizers
- 缺点:
- 不保证finalizers的及时执行,甚至不保证是否执行,会根据不同的JVM实现产生不同的执行效果。
- 使用finalizers存在着严重的性能损失。
- 替代方案:提供一个显式地termination方法,并要求客户端当实例不需再使用后调用这个方法,这个终止方法通常都会结合try-finally结构一起使用。
- 什么时候使用finalizers:
- 作为一个安全保障防止实例对象没有调用终止方法(如果资源不是被终止方法所关闭的,那么finalizers应该记录日志警告,毕竟这个bug)
- 本地对等对象(native peers)略
- 如果一个类拥有一个finalizers并且子类重写它,那么子类的finalizers必须手动调用父类的finalizers,否则父类的finalizers不会执行。为了预防这种情况,可以将finalizers写成一个内部匿名类。
- 缺点:
public class Foo{
private final Object finalizerGuadian=new Object(){
@Override protected void finalize() throws Throwable{
……//Finalize outer Foo object
}
}
}
二. 所有对象都通用的方法
- 重写equals方法时请遵守通用约定
- 在值类中通常会重写equals方法,确保只是比较逻辑相等,而不是引用相等。
- 那些确保只有单一实例的值类也可不重写equals方法。
- 重写equals方法还需要遵循通用约定
- 自反性:对象必须等于自身。假如违背了这一条,然后把该类的实例添加到集合,该集合的contains方法将果断地告诉你,该集合不包含你刚刚添加的实例。
- 对称性
- 传递性
- 一致性
- 非空性
//对称性
public boolean equals(Object o){
if(o instanceof CaseInsensitiveString)
return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
if(o instanceof String){
return s.equalsIgnoreCase((String) o);
}
return false;
}
- 重写equals方法时也要重写hashCode方法
- 关于HashCode的约定
- 同个执行程序中(重启可能就不一样了),同个对象不管执行多少次hashCode方法,返回的值都一样。
- 如果两个对象通过equals方法测试出来相等,那么hashCode的返回值也相等。
- 根据equals方法两个对象不相等,但是hashCode的返回值可以相等。但最好是要不相等,因为这样可以提高hash表的性能。
- 不要试图从散列码计算中排除掉一个对象的关键部分来提高性能。
- 关于HashCode的约定
//PhoneNumber这个类重写equals方法但是没有重写hashCode方法。
Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
m.put(new PhoneNumber(707,867,5309),"Jenny");
m.get(new PhoneNumber(707, 867, 5309));
//因为put和get的对象是equals的,但是由于没有重写hashCode方法,所以hashCode不相等,违背了hashCode的约定。所以get方法有可能寻找phoneNumber所在的hash bucket跟put方法存储phoneNumber的hash bucket(散列桶)是不一样的。即时两个实例对象的哈希值在同个散列桶中,get方法也是返回null,因为HashMap有个优化机制就是缓存每个条目的hashCode,如果两个hashCode不相等,就不浪费性能去检查对象是否equals。
- 始终要重写toString方法
- 提供一个号的toString()实现可以使你的类更好的使用。
- 实际项目中,toString()方法应该返回对象中所有有意义的数据。
- 当你打算重写toString()方法时,你应该指定你打算以什么样的格式作为返回值(推荐是value值)。不管你是否决定指定你的格式,都应该在文档中表达清楚。
- 无论是否指定格式,都为toString()返回值中包含的所有信息,提供一种编程式的访问途径。
- 谨慎地重写clone方法(略)
- Cloneable接口的目的是作为对象的一个mixin接口,表明这样的对象允许克隆。但该接口缺少一个clone方法,Object的clone方法是受保护的。尽管借助反射,也无法保证该对象一定具有可访问的clone方法。
- 既然Cloneable并没有包含任何方法,那么它到底有什么作用呢?它决定了Object中受保护的clone方法实现的行为:如果一个类实现了Cloneable,Object的clone方法就返回该对象的 field-by-field拷贝。
- 考虑实现Comparable接口(略)
- Comparable接口的唯一方法是compareTo(),compareTo方法不但允许进行简单的等同性比较,而且允许执行顺序比较。类实现了Comparable接口,就表明它的实例具有内在的排序关系。
- compareTo方法跟equals方法的通用约定很相似:(略)
- 将对象与指定对象进行排序比较,当这个对象小于、等于或者大于指定对象时,分别返回一个负整数、零或者正整数。如果指定的对象无法与这个对象进行类型比较,则会抛出 ClassCastException 。