EffectiveJava之创建和销毁对象篇
小伙伴们好呀,我是 4ye ,今天来和大家分享下 《Effective Java》这本书的 第2章 —— 创建和销毁对象 。
一共有 9 点,一起看看叭~
1. 考虑用 静态工厂方法 而不是构造器
有这五个优点:
- 有方法名
- 不用每次都创建对象
- 可以返回任意子类
- 可以根据不同的入参而返回不同的类
- 在编写包含方法的类时,返回对象的类不需要存在
A. 有方法名
这个优点确实很显眼 ,毕竟构造器名固定了🐖
B. 不用每次都创建对象
这个也好理解,可以缓存对象, 设计思想上可参考 亨元设计模式
例如 valueOf 方法 👇
C. 可以返回任意子类
这个作者举了 Collections 这个工具类,但是我也没啥特别的感觉,感觉和 面向接口编程 差不多的意思
D 可以根据不同的入参而返回不同的类
这个可以参考 Spring 中 BeanFactory 接口的 getBean 方法。
这个我便轻车熟路了,它可以很对业务模块进行解耦,方便扩展
接口A a = applicationContext.getBean(参数);
a.common();
E. 在编写包含方法的类时,返回对象的类不需要存在
这个还是 面向接口编程 好吧……
作者举了 JDBC 这个例子。
Connection conn=DriverManager.getConnection(xxx)
2. 如果构造器有很多参数,建议用 builder 去创建对象
这个就是 建设者模式 的使用了,下面是作者 Joshua Bloch 在 GitHub 仓库给的例子
package effectivejava.chapter2.item2.builder;
// Builder Pattern (Page 13)
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public static class Builder {
// Required parameters
private final int servingSize;
private final int servings;
// Optional parameters - initialized to default values
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public Builder(int servingSize, int servings) {
this.servingSize = servingSize;
this.servings = servings;
}
public Builder calories(int val)
{ calories = val; return this; }
public Builder fat(int val)
{ fat = val; return this; }
public Builder sodium(int val)
{ sodium = val; return this; }
public Builder carbohydrate(int val)
{ carbohydrate = val; return this; }
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
.calories(100).sodium(35).carbohydrate(27).build();
}
}
看到这个 链式调用,不得不感叹下 stream 源码,封装的超级牛,要 List,要 Map 等都可以很随意的转换出来!👍
3. 用 枚举或者私有构造器 来强化 单例属性
这个就差不多在说 单例模式 了
👉 一文带你看遍单例模式的八个例子,面试再也不怕被问了 (我都忘光了😂)
这两个也是作者 Joshua Bloch 在 GitHub 仓库给的例子
枚举 👇
package effectivejava.chapter2.item3.enumtype;
// Enum singleton - the preferred approach (Page 18)
public enum Elvis {
INSTANCE;
public void leaveTheBuilding() {
System.out.println("Whoa baby, I'm outta here!");
}
// This code would normally appear outside the class!
public static void main(String[] args) {
Elvis elvis = Elvis.INSTANCE;
elvis.leaveTheBuilding();
}
}
属性 👇
package effectivejava.chapter2.item3.field;
// Singleton with public final field (Page 17)
public class Elvis {
public static final Elvis INSTANCE = new Elvis();
private Elvis() { }
public void leaveTheBuilding() {
System.out.println("Whoa baby, I'm outta here!");
}
// This code would normally appear outside the class!
public static void main(String[] args) {
Elvis elvis = Elvis.INSTANCE;
elvis.leaveTheBuilding();
}
}
4. 用 私有构造器 来限制实例化
这个也是 单例模式 的影子了。
5. 通过 依赖注入 而不是 硬编码 的方式使用资源
这句话听着还有点别扭,作者举了一个例子,就是一个工具里把 字典 写死了,这样是不对的,应该是下面这种依赖注入的写法才对。
个人感觉。。。还是 面向接口编程 🐖
// Dependency injection provides flexibility and testability
public class SpellChecker {
private final Lexicon dictionary;
public SpellChecker(Lexicon dictionary) {
this.dictionary = Objects.requireNonNull(dictionary);
}
public boolean isValid(String word) { ... }
public List<String> suggestions(String typo) { ... }
}
6. 避免创建不必要的对象
比如,String 对象的创建
// 这样写每次都创建新对象,不要使用
String s= new String("Java4ye");
// 使用
String s= "Java4ye";
开头提到的 亨元模式 ,valueOf 等缓存对象的方法。
日常中各种连接的建立,线程池的使用等等。
注意 基本数据类型和包装类型
// Hideously slow! Can you spot the object creation?
private static long sum() {
Long sum = 0L;
for (long i = 0; i <= Integer.MAX_VALUE; i++)
sum += i;
return sum;
}
将 Long 改成 long
这里试了下,确实很夸张,从 7s 到 1s,所以在 计算时,一定要留意用 基本数据类型去计算,小心自动装箱拆箱。
7. 清除过时对象的引用
这个就是大名鼎鼎的 内存泄漏 了🐖
经常看到很多 线上环境cpu飙升,内存溢出 宕机之类的问题,基本都是这个数据结构使用不当造成的。
比如 ThreadLocal , 还有 集合中存着对象的引用 没有被清掉等问题
你能从这个例子中找到问题吗 👇
package effectivejava.chapter2.item7;
import java.util.*;
// Can you spot the "memory leak"? (Pages 26-27)
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}
public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}
/**
* Ensure space for at least one more element, roughly
* doubling the capacity each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
// // Corrected version of pop method (Page 27)
// public Object pop() {
// if (size == 0)
// throw new EmptyStackException();
// Object result = elements[--size];
// elements[size] = null; // Eliminate obsolete reference
// return result;
// }
public static void main(String[] args) {
Stack stack = new Stack();
for (String arg : args)
stack.push(arg);
while (true)
System.err.println(stack.pop());
}
}
说到底还是 对象引用 的问题,可以看看 4ye 之前写的
四种引用类型在Springboot中的使用 ,看看 Springboot 和线程池是如何巧妙用上 软引用和弱引用 的。
8. 避免 finalize 方法和 Cleaner 类的使用
这两个都没用过,而且 finalize 方法不是你调用就立刻执行的。
Cleaner 也是第一次见,继承了 虚引用
9. 用 try-with-resources 而不是 try-finally
这里作者主要说这个 twr 比较优雅,以及解决了异常覆盖的问题。
这个我之前写过的这篇文章也有提到过 👇
总之,就是要注意 关闭这个流,会不会有其他影响,有的话还是手动关闭好了。
特别是 Web 端,不要把客户端请求吃掉了,还没返回信息过去。
总结
看完之后,最大的收获是
- 对创建出来的对象要考虑复用,即缓存的使用,会涉及到亨元,单例设计模式的使用
- 面向接口编程,多考虑 依赖注入 而不是硬编码
- 构造器参数过多要用 Builder 模式
- 注意 自动装箱拆箱 带来的开销,如上面的 Long 计算
- 注意内存泄漏,如 ThreadLocal , 其他集合,缓存等,注意对象引用的处理,软引用和弱引用的巧妙使用,可以提升 JVM 的 GC 效率。
- 注意 TWR 自动关闭资源 带来的隐患,结合业务。
Joshua Bloch 的 GitHub 地址
最后
有所收获的话,别忘了 三连(点赞,在看,转发) 鼓励下 4ye 呀,谢谢&下期见!😝
转载自:https://juejin.cn/post/7215386938869006396