一、定义

简单工厂模式是属于创建型模式，在简单工厂模式中用于被创建实例的方法通常为静态(static)方法，因此又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

二、使用场景

• 工厂类负责创建的对象比较少；
• 客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
• 由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

三、代码样例

1.需求

用面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。

2.类图

3.运算操作类

/**
 * 操作类抽象类
 * 
 */
public abstract class Operation {
    public double numberA;
    public double numberB;

    public abstract double result();
}

/**
 * 加法类
 * 
 */
public class OperationAdd extends Operation {

    @Override
    public double result() {
	return numberA + numberB;
    }

}

/**
 * 除法类
 * 
 */
public class OperationDiv extends Operation {

    @Override
    public double result() {
	if (numberB == 0) {
	    throw new RuntimeException("divided by 0");
	}
	return numberA / numberB;
    }

}

/**
 * 乘法类
 * 
 */
public class OperationMul extends Operation {

    @Override
    public double result() {
	return numberA * numberB;
    }

}

/**
 * 减法类
 * 
 */
public class OperationSub extends Operation {

    @Override
    public double result() {
	return numberA - numberB;
    }

}

4.操作工厂类

/**
 * 操作类工厂类
 * 
 */
public class OperationFactory {
    public static Operation createOperation(char operator) {
	Operation operation = null;

	switch (operator) {
	case '+':
	    operation = new OperationAdd();
	    break;
	case '-':
	    operation = new OperationSub();
	    break;
	case '*':
	    operation = new OperationMul();
	    break;
	case '/':
	    operation = new OperationDiv();
	    break;
	default:
	    throw new RuntimeException("unsupported operation");
	}

	return operation;
    }
}

5.客户端类

/**
 * 使用工厂方法生成实例完成运算操作
 * 
 */
public class Calculator {
    public static void main(String[] args) {
	Operation operation;
	char operator;

	operator = '+';
	operation = OperationFactory.createOperation(operator);
	operation.numberA = 1.2;
	operation.numberB = 2.3;

	System.out.println(operation.result());
    }
}

四、优缺点

优点：

• 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
• 客户端无需知道所创建具体产品的类名，只需知道参数即可
• 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。（这也是我在开始的披萨店里遇到没有的披萨的解决情况）

缺点：

• 工厂类集中了所有产品的创建逻辑，职责过重，一旦异常，整个系统将受影响
• 使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度
• 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
• 简单工厂模式使用了static工厂方法，造成工厂角色无法形成基于继承的等级结构。

这些缺点在工厂方法模式中得到了一定的克服。

结尾

• 感谢大家的耐心阅读，如有建议请私信或评论留言。
• 如有收获，劳烦支持，关注、点赞、评论、收藏均可，博主会经常更新，与大家共同进步

Java 静态工厂方法详解

本文章主要是对《Effective Java》对静态工厂方法的理解

第一次使用静态工厂方法是在HIT《Software Construction》课程的Lab2-P1的Graph.java中，对静态工厂方法的理解也相当有限，因此撰写此博客加深对静态工厂方法的理解。

Java 静态工厂方法在实际开发中经常使用，在《Effective Java》中第二章第一条即为：考虑使用静态工厂方法代替构造器。

静态工厂方法的含义

静态工厂方法指的是在类中提供一个公有的静态方法，返回类的一个实例。

静态工厂方法的第一大优势：它们有名称

类的构造器名称被限制为类名，然而当构造器因不同的参数类型而无法确切的描述被返回的对象时，静态工厂方法却可以提供不同的函数名称作为不同构造方法。
例如如下代码：

public class Person {
    private final SEX sex;
    private final String name;
    private final int age;

    private Person(String name, int age, SEX sex){
        this.sex = sex;
        this.name = name;
        this.age = age;
    }

    public static Person getManInstance(String name, int age){
        return new Person(name, age, SEX.man);
    }
    
    public static Person getWomanInstance(String name, int age){
        return new Person(name, age, SEX.woman);
    }
}

enum SEX{
    man,
    woman;
}

在实际开发中，也如果是需要定义相同参数的构造器，可以通过交换参数位置的方法完成，但是这并不是一个好的方法，降低客户端代码的阅读性。

静态工厂方法的第二大优势：不必在每次调用时都创建新的对象

这种方法使得immutable的类可以使用预先构造好的实例或者是已经构造好的静态实例对象、进行重复利用。

这里提供以下immutable类的五条规则:

1. 不提供任何mutator
2. 保证类不会被扩展
3. 所有的域都是final的
4. 所有的域都是私有的
5. 确保对于任何可变组件的互斥性访问
   示例代码如下：

public class Position{
    private final int x;
    private final int y;
    private static Position ORIGIN = new Position(0,0);
    private Position(int x, int y){
        this.x = x;
        this.y = y;
    }

    public static Position getORIGIN(){
        return ORIGIN;
    }
    
    public int getX(){
        return x;
    }
    
    public int getY(){
        return y;
    }
}

静态工厂方法第三大优势：他们可以返回原返回类型的任何子类型的对象

这样我们在选择返回对象的类时就有了更大的灵活性。
这种灵活性的一种应用是，API可以返回对象，同时又不会使对象的类变成公有的。以这种方式隐藏实现类会使API变得非常简洁。这项技术适用于基于接口的框架(interface-basedframework)，因为在这种框架中，接口为静态工厂方法提供了自然返回类型。接口不能有静态方法，因此按照惯例，接口Type的静态工厂方法被放在一个名为Types的不可实例化的类(见第4条)中。
示例代码如下：

public class Person {
    public static Person getStudent(){
        return new Student();
    }
}
class Student extends Person {

}//仅为一无内涵的示例

静态工厂方法的第四大优势在于，在创建参数化类型的实例的时候，他们使代码变得更加简介

此优势主要体现在泛型初始化时，示例代码如下：

    // 不使用静态工厂方法的情况：
    Map<String, Integer> map = new HashMap<String, Integer>();
    
    
    // HashMap中如果存在此方法：
    public Map<K,V> getInstance(){
        return new HashMap<K,V>();
    }
    
//    即可简化成以下代码
    Map<String, Integer> map = HashMap.getInstance();

静态方法的主要缺点是，类如果不含有共有的或受保护的构造器，就不能被子类化。

这一部分较有体会，例如以下代码（错误示例）

public class Person {
    private final SEX sex;
    private final String name;
    private final int age;

    private Person(String name, int age, SEX sex){
        this.sex = sex;
        this.name = name;
        this.age = age;
    }

    public static Person getManInstance(String name, int age){
        return new Person(name, age, SEX.man);
    }

    public static Person getWomanInstance(String name, int age){
        return new Person(name, age, SEX.woman);
    }
}

class Student extends Person {
    
}

实际在编译器的静态检查中会报错，原因是父类缺少公有的构造方法，而子类无法调用父类的私有构造器，导致子类无法生成构造器。

静态工厂方法的第二个缺点在于，他们与其他的静态方法实际没有任何区别

下面是一些静态工厂方法的惯用名称：

1. valueOf——不太严格地讲，该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转换方法。
2. of—— valueOf的一 种更为简洁的替代，在EnumSet (见第32条)中使用并流行起来。
3. getInstance-返回的实例是通过方法的参数来描述的，但是不能够说与参数具有同样的值。 对于Singleton来说， 该方法没有参数，并返回唯一的实例。
4. newInstance——像 getInstance-样， 但newInstance 能够确保返回的每个实例都与所有其他实例不同。
5. getType——像getInstance- 样， 但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
6. newType——像newinstance一样，但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。

要不，点个赞？~

最近在啃《Effective Java》这本神书。简单记录一下，方便以后温习。

静态工厂方法

静态工厂方法是什么？直接从字面应该就很好理解:

工厂方法：大家应该都知道，就是构建实例的方法呗。（比如：“江南皮革厂”就是创建“皮包”这个对象的工厂）

静态方法：这还有解释的必要么.......

合起来就是静态的构建对象的方法呗。。哦了，这就是静态工厂方法。本文到此结束，感谢大家观看！

哈哈，开个玩笑。 虽然静态工厂方法是什么很好理解。可是静态工厂方法到底有什么用呢，我们又为什么要用它呢？

一般情况下，java中我们创建对象要写一个公有的构造函数，外部调用构造函数来创建一个对象。静态工厂方法就是与它相对应的。代码分别如下：

class People {

    private String sex = "男";
    private String appearance = "一般";
    private String asset = "穷";//原则上来讲，默认数据要符合普遍情况。

    //普通构造函数--无参
    public People() {
    }

    //普通构造函数--有参
    public People(String sex) {
        this.sex = sex;
    }

    public People(String sex, String appearance) {
        this.sex = sex;
        this.appearance = appearance;
    }

    public People(String sex, String appearance, String asset) {
        this.sex = sex;
        this.appearance = appearance;
        this.asset = asset;
    }

    //静态工厂方法
    public static People createGirlfriend() {//程序员的基本操作，new一个女朋友。
        People people = new People();
        people.sex = "女";
        people.appearance = "倾国倾城";
        people.asset = "市中心十栋楼";
        return people;
    }

}

上面就是一个简单的静态工厂方法，其实本质上就是加了一层封装。有了这层封装自己可以操作和控制很多东西。

下面看看两者的区别：

1.静态工厂方法的优点

1.1 静态工厂方法是有名称的

我们在java中应该经常看到类似这种构造函数：

class People {

    private String sex = "男";
    private String appearance = "一般";
    private String asset = "穷";

    //普通构造函数--无参
    public People() {
    }

    //普通构造函数--有参
    public People(String sex) {
        this.sex = sex;
    }

    public People(String sex, String appearance) {
        this.sex = sex;
        this.appearance = appearance;
    }

    public People(String sex, String appearance, String asset) {
        this.sex = sex;
        this.appearance = appearance;
        this.asset = asset;
    }

}

当然，官方文档的注释还是很完善和规范的。我们可以看到每个构造函数的用处和每个参数的作用。可是如果在多点参数呢，又如果是自己写方法呢。（有时候懒再少些两行注释~~后期维护两行泪~） 调用的时候是不是就会一脸懵逼？我该调用哪个？这个参数是什么？要传什么值？况且每次构建对象的时候都要点进去看注释也挺麻烦的。

为了解决上述问题，我们可以使用静态工厂方法。因为静态工厂方法是可以有名字的，这样构建对象时就非常直观。比如文章开始的第一个demo。通过静态工厂方法createGirlfriend()方法可以直接创建一个“People”的实例，同时我们可以直接从方法名看出我们创建出来的“people”实例是“女朋友”。是不是很方便易懂呢~~

1.2 静态工厂方法可以不必在每次调用他们的时候都创建一个新对象

这个应该很好理解，因为静态工厂方法是多一层封装的。所以在这里面我们可以自由控制返回的对象，可以全局只使用一个对象（单例）或者控制什么时候创建新的实例，什么时候使用缓存的实例。代码如下：

class People {

    private String sex = "男";
    private String appearance = "一般";
    private String asset = "穷";

    //静态工厂方法
    public static People createGirlfriend() {
        People people = new People();//这里是我们可控制的，所以你可以选择new新的对象或者使用缓存的已创建的对象
        people.sex = "女";
        people.appearance = "倾国倾城";
        people.asset = "市中心十栋楼";
        return people;
    }

}

1.3 静态工厂方法可以返回原返回类型的任何子类型

这一点也好理解，先看代码：

class People {

    //静态工厂方法
    public static People createChildren() {
        Children people = new Children();
        return people;
    }

}

//People的子类
class Children extends People {
    public Children() {
    }
}

这个很好理解了，Children是People的子类。所以在静态工厂方法中可以直接返回Children的实例。

不过这里我们不得不提一下设计原则--里式替换原则：任何基类可以出现的地方，子类一定可以出现。 --百度百科

最通俗的讲，就是我们在写子类的时候要注意：可以拓展父类功能和属性，但是不能修改。（也就是对扩展开放，对修改关闭）

1.4 静态工厂方法返回的对象的类可以随着每次调用而发生改变，这取决于所传参数值

理解：静态工厂方法可以根据参数不同返回不同的子类对象。代码如下：

class People {

    /**
     * @param timeForSingle 单身时长
     * @return 对象
     */
    public static People createGirlfriend(int timeForSingle) {
        if (timeForSingle < 5) {//根据所传参数，返回不同的子类对象。
            EighteenBeauty eighteenBeauty = new EighteenBeauty();
            return eighteenBeauty;
        } else {//单身超过五年，看男生都感觉很清秀了呢~~
            Man man = new Man();
            return man;
        }
    }

}

//18岁年轻漂亮的小姑娘
class EighteenBeauty extends People {
    public EighteenBeauty() {
    }
}

//男人
class Man extends People {
    public Man() {
    }
}

OK，看代码就很好理解了。根据所传递参数不同返回了不同的子类对象。

1.5 静态工厂方法返回的对象所属的类，在编写包含该静态工厂方法的类时可以不存在（该篇唯一难点）

重头戏到了，这是本篇唯一难点。这个概念理解起来倒是很简单：静态工厂方法返回对象所属的类，在编写包含该静态工厂方法时可以不存在。（好像是把概念又抄了一遍，不过单从字面实在没什么可解释的了~~）。

不过重点在于，怎么实现呢？

这里直接从 这种静态工厂方法最典型的实现--服务提供者框架 来探讨。

服务提供者框架包含四大组件：（概念不太好理解，可以直接先看下面的例子讲解，然后回过头来再看概念）

1. 服务接口：这是服务提供者要去实现的接口
2. 服务提供者接口：生成服务接口实例的工厂对象（就是用来生成服务接口的）（可选）
3. 提供者注册API：服务者 提供服务者自身的实现
4. 服务访问API：根据客户端指定的某种条件去实现对应的服务提供者

概念太拗口，上栗子讲解：

//四大组成之一：服务接口
public interface LoginService {//这是一个登录服务
    public void login();
}

//四大组成之二：服务提供者接口
public interface Provider {//登录服务的提供者。通俗点说就是：通过这个newLoginService()可以获得一个服务。
    public LoginService newLoginService();
}

/**
 * 这是一个服务管理器，里面包含了四大组成中的三和四
 * 解释：通过注册将 服务提供者 加入map，然后通过一个静态工厂方法 getService(String name) 返回不同的服务。
 */
public class ServiceManager {
    private static final Map<String, Provider> providers = new HashMap<String, Provider>();//map，保存了注册的服务

    private ServiceManager() {
    }

    //四大组成之三：提供者注册API  (其实很简单，就是注册一下服务提供者)
    public static void registerProvider(String name, Provider provider) {
        providers.put(name, provider);
    }

    //四大组成之四：服务访问API   (客户端只需要传递一个name参数，系统会去匹配服务提供者，然后提供服务)  (静态工厂方法)
    public static LoginService getService(String name) {
        Provider provider = providers.get(name);
        if (provider == null) {
            throw new IllegalArgumentException("No provider registered with name=" + name);

        }
        return provider.newLoginService();
    }
}

OK，代码中注释的很清楚了。

思考下，这么做有什么好处呢？？重点看一下上面demo中的 “四大组成之四：服务访问API ”

想一想，是不是以后想要增加服务时只需要实现服务提供者接口、服务接口，然后约定一个服务名就可以了？

2.静态工厂方法的缺点

2.1 如果类不含公有的或者受保护的构造器时，就是能被子类化

如果类的构造方法是私有的，那么这个类就不能被继承了。这时候建议用复合代替继承实现类的拓展。

2.2 静态工厂方法实际上就是静态方法，如果命名不规范的话程序员很难发现他们

这时候就需要我们自我约束了，利用静态工厂方法时一定要遵循命名规范，下面是一些常用的静态工厂方法命名：

1. from    类型转换方法，它只有单个参数，返回该类型的一个实例，并把它们合并起来。
2. of    聚合方法，带有多个参数，返回该类型的一个实例，把他们合并起来。
3. valueOf    比from和of更繁琐的一种替代方法。
4. instance或者getInstance    返回的实例是通过方法的（如有）参数来描述的，但是不能说与参数具有同样的值。
5. create或者newInstance    像instance或者getInstance一样，但create或者newInstance能够确保每次调用都返回一个新的实例
6. getType    像getInstance一样，但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
7. newType    像getInstance一样，但是在工厂方法处于不同的类中的时候使用。
8. type    getType和newType的精简版。