likes
comments
collection
share

EffectiveJava之创建和销毁对象篇

作者站长头像
站长
· 阅读数 44

小伙伴们好呀,我是 4ye ,今天来和大家分享下 《Effective Java》这本书的 第2章 —— 创建和销毁对象

一共有 9 点,一起看看叭~

1. 考虑用 静态工厂方法 而不是构造器

有这五个优点:

  1. 有方法名
  2. 不用每次都创建对象
  3. 可以返回任意子类
  4. 可以根据不同的入参而返回不同的类
  5. 在编写包含方法的类时,返回对象的类不需要存在

A. 有方法名

这个优点确实很显眼 ,毕竟构造器名固定了🐖

B. 不用每次都创建对象

这个也好理解,可以缓存对象, 设计思想上可参考 亨元设计模式

例如 valueOf 方法 👇

EffectiveJava之创建和销毁对象篇

EffectiveJava之创建和销毁对象篇

C. 可以返回任意子类

这个作者举了 Collections 这个工具类,但是我也没啥特别的感觉,感觉和 面向接口编程 差不多的意思

EffectiveJava之创建和销毁对象篇

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 等都可以很随意的转换出来!👍

EffectiveJava之创建和销毁对象篇

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

EffectiveJava之创建和销毁对象篇

将 Long 改成 long

EffectiveJava之创建和销毁对象篇

这里试了下,确实很夸张,从 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 也是第一次见,继承了 虚引用

EffectiveJava之创建和销毁对象篇

9. 用 try-with-resources 而不是 try-finally

这里作者主要说这个 twr 比较优雅,以及解决了异常覆盖的问题。

这个我之前写过的这篇文章也有提到过 👇

try-with-resources 这样坑过我

总之,就是要注意 关闭这个流,会不会有其他影响,有的话还是手动关闭好了。

特别是 Web 端,不要把客户端请求吃掉了,还没返回信息过去。

总结

看完之后,最大的收获是

  1. 对创建出来的对象要考虑复用,即缓存的使用,会涉及到亨元,单例设计模式的使用
  2. 面向接口编程,多考虑 依赖注入 而不是硬编码
  3. 构造器参数过多要用 Builder 模式
  4. 注意 自动装箱拆箱 带来的开销,如上面的 Long 计算
  5. 注意内存泄漏,如 ThreadLocal , 其他集合,缓存等,注意对象引用的处理,软引用和弱引用的巧妙使用,可以提升 JVM 的 GC 效率。
  6. 注意 TWR 自动关闭资源 带来的隐患,结合业务。

Joshua Bloch 的 GitHub 地址

github.com/jbloch/effe…

最后

有所收获的话,别忘了 三连(点赞,在看,转发) 鼓励下 4ye 呀,谢谢&下期见!😝

EffectiveJava之创建和销毁对象篇

转载自:https://juejin.cn/post/7215386938869006396
评论
请登录