第16条 复合优于继承
继承存在三个天然缺陷,这些缺陷会导致软件非常脆弱:
1) 子类如果调用了父类的方法,那么就会对父类形成依赖,一旦父类做了改动,子类就很可能不能正常工作。
2) 如果父类新增了方法,而子类恰好已经提供了一个签名相同但是返回值不同的方法,那么子类将无法通过编译。
3) 在不应该继承的时候使用继承,会暴露不必要的API给子类。
可以被继承的类要么在同一个包内(在同一个程序员的控制之下),要么是专门为继承而实现,并提供了很好的文档说明。
复合方法:先创建一个转发类,该转发类实现接口内的所有方法
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(); }
}
子类继承该转发类
public class InstrumentedSet<E> extends ForwardingSet<E> {
private int addCount = 0;
public InstrumentedSet(Set<E> s) {
super(s);
}
@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 static void main(String[] args) {
InstrumentedSet<String> s =
new InstrumentedSet<String>(new HashSet<String>());
s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));
System.out.println(s.getAddCount());
}
}
复合就是设计模式中的装饰模式。继承多用于继承本项目中的类,复合则用于引用的其他项目的类。
第17条 要么为继承而设计,并提供文档说明,要么就禁止继承
该类的文档必须精确地描述覆盖的每个方法的影响,阐明该方法对其他方法的影响
第18条 接口优于抽象类
抽象类与接口的区别:
1.抽象类中可以存在非抽象的方法,而接口不行。接口默认的方法都为public abstract类型。也可以说接口是一种特殊的抽象类。
2.一个类只能继承一个抽象类,但可以实现多个接口。
3.抽象类的非抽象方法可以选择继承,接口中的每一个方法必须被重写。
接口通常是允许多个实现的类型的最佳途径。
第19条 接口只用于定义类型
接口应该只被用来定义类型,不应该被用于导出常量。即不应在接口中定义常量。
第20条 类层次优于标签类
abstract class Figure {
abstract double area();
}
class Circle extends Figure {
final double radius;
Circle(double radius) {
this.radius = radius;
}
double area() {
return Math.PI * (radius * radius);
}
}
class Rectangle extends Figure {
final double length;
final double width;
Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
double area() {
return length * width;
}
}
应尽量将类分成多个层次,直观,便于理解。标签类用途较少。