Effective Java笔记(一)
Effective Java
1. 考虑用静态方法代替构造器
例如
public static Boolean valueOf(boolean b){
return b > Boolean.TRUE : Boolean.FALSE
}
优势
- 有名称
- 不必每次调用他们的的时候都创建一个新对象
- 可以返回员返回类型的任何子类型的对象
缺点
- 类如果不含共有的或者搜保护的构造器没,就不能被子类化
- 他们于其他的静态方法实际上没有任何区别
2.遇到多个构造器参数时要考虑用构建器
JavaBeans
调用一个无参构造器来创建对象,然后调用 setter方法来设置每个必要的参数以及各每个相关的可选参数
缺点:
- 因为被分到几个调用中,在构建过程中可能处于不一致的状态。
- 阻止了把类做成不可变的可能,需求程序员付出额外的努力来确保它的线程安全
Builder模式(建造者模式)
如果类的构造器或者静态工厂中具有多个参数,设计这种类时,Builder模式是不错的选择。
// 例如
public class Course {
private String courseName;
private String coursePPT;
private String courseVideo;
private String courseArticle;
/**
* question & answer
*/
private String courseQA;
public Course(CourseBuilder courseBuilder) {
this.courseName = courseBuilder.courseName;
this.coursePPT = courseBuilder.coursePPT;
this.courseVideo = courseBuilder.courseVideo;
this.courseArticle = courseBuilder.courseArticle;
this.courseQA = courseBuilder.courseQA;
}
@Override
public String toString() {
return "Course{" +
"courseName='" + courseName + '\'' +
", coursePPT='" + coursePPT + '\'' +
", courseVideo='" + courseVideo + '\'' +
", courseArticle='" + courseArticle + '\'' +
", courseQA='" + courseQA + '\'' +
'}';
}
public static class CourseBuilder {
private String courseName;
private String coursePPT;
private String courseVideo;
private String courseArticle;
/**
* question & answer
*/
private String courseQA;
public CourseBuilder buildCoureseName(String courseName) {
this.courseName = courseName;
return this;
}
public CourseBuilder buildCoursePPT(String coursePPT) {
this.coursePPT = coursePPT;
return this;
}
public CourseBuilder buildCourseVideo(String courseVideo) {
this.courseVideo = courseVideo;
return this;
}
public CourseBuilder buildCourseArticle(String courseArticle) {
this.courseArticle = courseArticle;
return this;
}
public CourseBuilder buildCourseQA(String courseQA) {
this.courseQA = courseQA;
return this;
}
public Course build() {
return new Course(this);
}
}
}
// 测试
Course course = new Course.CourseBuilder()
.buildCoureseName("Java设计模式精讲")
.buildCoursePPT("Java设计模式PPT")
.buildCourseVideo("Java设计模式视频")
.build();
System.out.println(course);
3.用私有构造器或者枚举类型强化Singleton属性
Singleton是指仅仅被实例化一次的类。
注意:享有特权的客户端可以借助 AccessibleObject.setAccessible方法,通过反射机制调用私有构造器
4.通过私有构造器强化不可实例化的能力
企图通过将类做成抽象类来强制该类不可被实例化,是行不通的
5.避免创建不必要的对象
要优先使用基本类型而不是装箱基本类型,要当心无意思的自动装箱
6.消除过期的对象引用
/**
* @author stone
* @des 内存泄露示例
* @date 2018/12/5/005 8:40
**/
public class Stack {
private Object[] element;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
}
public void push(Object e) {
ensureCapacity();
element[size++] = e;
}
public Object pop() {
if (size == 0) {
throw new EmptyStackException();
}
// 注意下面这行代码会引起内存泄露
// 如果一个栈是先增长,然后再收缩,那么,从栈中弹出来的对象将不会被当做垃圾回收,即使使用栈的程序不再引用这些对象,他们也不会被回收
// 栈内部维护着这些对象的过期引用。过期引用:永远也不会再被解除的引用。
// 本例中 凡是element数组中的活动部分之外的任何引用都是过期的。活动部分:element中下标小于size的那些元素
// return element[--size];
Object result = element[--size];
// 解决方法如下 消除过期引用
// Eliminate obsolete reference
element[size] = null;
return result;
}
/**
* ensure space for at least one more element,roughly
* doubling the capacity each time the array needs to grow
*/
private void ensureCapacity() {
if (element.length == size) {
element = Arrays.copyOf(element, 2 * size + 1);
}
}
}
总结 : 过期的对象引用 可能会引起内存泄露
只要类是自己管理内存,程序员就应该警惕内存泄露的问题。
内存泄露常见来源
- 只要类是自己管理内存,程序员就应该警惕内存泄露的问题。
- 缓存
- 监听器和其他回调
7.避免使用终结方法
终结方法(finalizer)通常是不可预测的,很危险的,也一般是不必要的。
Java语言规范不仅不保证终结方法会被及时地执行,而且根本就不保证它们会被执行。
不应该依赖终结方法来更新重要的持久状态。
System.gc System.runFinalization这两个方法确实增加了终结方法被执行的机会,但它们并不保证终结方法一定会被执行。
终结方法有一个非常严重的(Severe)性能损失。
用终结方法创建和销毁对象比正常要慢上百倍。
8.覆盖equals时请遵守通用约定
equals方法实现了等价关系
- 自反性 非null情况下 x.equals(s) return true
- 对称性 非null情况下 如果 y.equals(x) return true 则 x.equals(y) return true
- 传递性 非null情况下 x,y,z 如果 x.equals(y) return true && y.euqals(z) return true 则 x.equals(z) return true
- 一致性 非null情况下 x,y不被修改 x.equals(y) 结果不会变
- 对于任何非null的引用值 x, x.equals(null) 一定 return false
一个对称性冲突的例子 不建议如此书写代码
public final class CaseInsensitiveString {
private final String s;
public CaseInsensitiveString(String s) {
if (s == null) {
throw new NullPointerException();
}
this.s = s;
}
@Override
public boolean equals(Object o) {
if (o instanceof CaseInsensitiveString) {
return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
}
// 为了解决对称性的问题 建议将下面于String 进行操作的代码删除
if (o instanceof String) {
return s.equalsIgnoreCase((String) o);
}
return false;
}
public static void main(String[] args) {
CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
String s = "polish";
// 注意 这里违反了 equals的对称性
// 对称性 非null情况下 如果 y.equals(x) return true 则 x.equals(y) return true
// cis 的 equals 知道要忽略大小写 但 s.equals 不知道
boolean result1 = cis.equals(s);
System.out.println(result1);
boolean result2 = s.equals(cis);
System.out.println(result2);
}
}
我们无法在拓展可实例化的类的同时,即增加新的值组件,同时有保留 equals约定吗
告诫
- 覆盖equals时总要覆盖hashCode
- 不要企图让equals方法过于智能
- 不要将equals声明中的Object对象替换为其他的类型
9.覆盖equals时总要覆盖hashCode
在每个覆盖了equals方法的类中,必须覆盖hashCode。如果不这样做就会违反Object,hashCode的通用约定,从而导致该类无法结合所有基于散列的集合一起正常工作,这些集合包括HashMap、HashSet和Hashtable。
- 在应用程序的执行期间,只要对象的equals方法的比较操作所用到的信息没有被修改,那么对这同一个对象调用多次,hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中,每次执行所返回的整数可以不一致。
- 如果两个对象根据equals(Object)方法比较是相等的,那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
- 如果两个对象根据equals(Object)方法比较是不相等的。那么调用这两个对象中任意一个对象的hashCode方法,则不一定要产生不同的整数结果。但是程序员应该知道,给不相等的对象产生截然不同的整数结果,有可能提高散列表(hash table)的性能。
public class PhoneNumber {
private final short areaCode;
private final short prefix;
private final short lineNumber;
public PhoneNumber(int areaCode, int prefix, int lineNumber) {
rangeCheck(areaCode, 999, "area code");
rangeCheck(prefix, 999, "prefix");
rangeCheck(lineNumber, 9999, "line number");
this.areaCode = (short) areaCode;
this.prefix = (short) prefix;
this.lineNumber = (short) lineNumber;
}
private static void rangeCheck(int arg, int max, String name) {
if (arg < 0 || arg > max) {
throw new IllegalArgumentException(name + ":" + arg);
}
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof PhoneNumber)) {
return false;
}
PhoneNumber pn = (PhoneNumber) o;
return pn.lineNumber == lineNumber
&& pn.prefix == prefix
&& pn.areaCode == areaCode;
}
@Override
public int hashCode() {
int result = 17;
// 31 * i == (i << 5) - i;
result = 31 * result + areaCode;
result = 31 * result + prefix;
result = 31 * result + lineNumber;
return result;
}
public static void main(String[] args) {
Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
m.put(new PhoneNumber(707, 867, 5309), "jenny");
// 添加 hashCode后 可以获取到该 value
// 如果不添加 hashCode 方法 这里获取到的 value是null
String result = m.get(new PhoneNumber(707, 867, 5309));
System.out.println(result);
}
}
注:关于hashCode 的写法有一整套的数学公式 1.6前还没有支持函数化(散列函数) 需要自己写
有空查看一下 1.5之后有没有支持
10.始终要覆盖 toString
PhoneNumber a = new PhoneNumber(707, 867, 5309);
System.out.println(a.toString());
console
com.alan.effectivejava.chapter9.PhoneNumber@12960c
可以发现非常难以理解
建议尽量重写 toString方法