effective java之第四章：类和接口

第十三条：使用类和成员的可访问性最小化

第一规则：尽可能使每个类或者成员不被外界访问。

第十四条：在公有类中使用访问方法而非公有域

公有类不应该直接暴露数据域，公有类永远都不应该暴露可变的域，让公有类暴露不可变的域其危害比较小，有时候会需要用包级私有或者私有的嵌套类来暴露域。

第十五条：使可变性最小化

使用类成为不可变，要遵循下面5条规则

1、不要提供任何会修改对象状态的方法

2、保证类不会被扩展

3、使所有的域都是final的

4、使所有的域都成为私有的

5、确保对于任何可变组件的互斥访问

第十六条：复合优先于继承

复合(composition):不扩展现有的类，而是在新的类中增加一个私有域，引用现有类的一个实例。

继承：

public class InstrumentedHashSet<E> extends HashSet<E> {
    // The number of attempted element insertions
    private int addCount = 0;
    public InstrumentedHashSet() {
    }
    public InstrumentedHashSet(int initCap, float loadFactor) {
        super(initCap, loadFactor);
    }
    @Override public boolean add(E e) {
        addCount++;
        return super.add(e);
    }
    @Override public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }
    public int getAddCount() {
        return addCount;
    }
}

复合：

public class ForwardingSet<E> implements Set<E> {

    private final Set<E> s;

    public ForwardingSet(Set<E> s) { this.s = s; }

 

    public void clear()               { s.clear();            }

    public boolean contains(Object o) { return s.contains(o); }

    public boolean isEmpty()          { return s.isEmpty();   }

    public int size()                 { return s.size();      }

    public Iterator<E> iterator()     { return s.iterator();  }

    public boolean add(E e)           { return s.add(e);      }

    public boolean remove(Object o)   { return s.remove(o);   }

    public boolean containsAll(Collection<?> c)

                                   { return s.containsAll(c); }

    public boolean addAll(Collection<? extends E> c)

                                   { return s.addAll(c);      }

    public boolean removeAll(Collection<?> c)

                                   { return s.removeAll(c);   }

    public boolean retainAll(Collection<?> c)

                                   { return s.retainAll(c);   }

    public Object[] toArray()          { return s.toArray();  }

    public <T> T[] toArray(T[] a)      { return s.toArray(a); }

    @Override public boolean equals(Object o)

                                       { return s.equals(o);  }

    @Override public int hashCode()    { return s.hashCode(); }

    @Override public String toString() { return s.toString(); }

}

第十七条：要么为继承而设计，并提供文档说明，要么就禁止继承

第十八条：接口优于抽象类

第十九条：接口只用于定义类型

第二十条：类层次优于标签类

第二十一条：用函数对象表示策略

第二十二条：优先考虑静态成员类