EffectiveJava阅读笔记（一）

考虑用静态工厂方法代替构造器

一、概述

二、使用静态工厂的优势

获取类对象的两种方式：

• 使用公有构造方法
• 静态工厂方法

1、介绍

• 有名称
• 不必每次调用时创建一个新对象
• 可以返回原类型的任何子类型对象
• 在创建参数化类型实例的时候，它们使代码变得简洁

2、优势详解

优势一：有名称

一个常见的例子，并发库中的Executors工具类。Executor的静态工厂方法有不同的名字，更能清晰地表达要返回哪种类型的线程池对象。

public class Executors {

     public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(...);
    }
    
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(...);
    }
    
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(...);
    }

}

Executors的继承关系如下

public interface ExecutorService extends Executor {...}

public abstract class AbstractExecutorService implements ExecutorService {...}

public class ThreadPoolExecutor extends AbstractExecutorService {...}

优势二：不必每次调用时创建一个新对象

DynamicPropertyFactory为Eureka中用于读取配置文件的类。它就使用了静态工厂来返回单例对象

public class DynamicPropertyFactory {

    private static DynamicPropertyFactory instance = new DynamicPropertyFactory();

    private DynamicPropertyFactory() {
    }

    public static DynamicPropertyFactory getInstance() {
        if (config == null) {
            Class var0 = ConfigurationManager.class;
            synchronized(ConfigurationManager.class) {
                if (config == null) {
                    AbstractConfiguration configFromManager = ConfigurationManager.getConfigInstance();
                    if (configFromManager != null) {
                        initWithConfigurationSource(configFromManager);
                        initializedWithDefaultConfig = !ConfigurationManager.isConfigurationInstalled();
                        logger.info("DynamicPropertyFactory is initialized with configuration sources: " + configFromManager);
                    }
                }
            }
        }

        return instance;
    }

}

优势三：可以返回原类型的任何子类型对象

如前面所说的Executors工具类。其中的静态工厂方法，返回的对象都是ThreadPoolExecutor对象，ThreadPoolExecutor是Executors的子类。

优势四：在创建参数化类型实例的时候，它们使代码变得简洁

Map<String, List<String>> map = new HashMap<String, List<String>>();

public static HashMap<K, V> newInstance() {
    return new HashMap<K, V>();
}

Map<String, List<String>> map = HashMap.newInstance();

三、使用静态工厂的缺点

转载于:https://www.cnblogs.com/fonxian/p/10261842.html