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 。
扫一扫
1593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
