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(); }

}

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

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

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

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

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

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

 

 

 

  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值