2023-03-30 13:15 湖南大学 Java

关注

EffectiveJava之创建和销毁对象篇

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 和线程池是如何巧妙用上 软引用和弱引用 的。