工厂模式（Factory Pattern）

一、工厂模式简介

1. 定义

工厂模式（Factory Pattern）是Java中常用的设计模式之一，这种设计模式属于创建型模式。工厂模式的主要意图是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

2. 分类

工厂模式可以分为三类：

• 简单工厂模式（Simple Factory）
• 工厂方法模式（Factory Method）
• 抽象工厂模式（Abstract Factory）

二、简单工厂模式

1. 定义

简单工厂模式又称静态工厂方法模式，其工厂类定义了一个静态方法。在简单工厂模式中，工厂类处于对产品类实例化调用的中心位置上，它决定那一个产品类应当被实例化。简而言之，就是有一个专门生产某个产品的类。

2. 模式组成

• 抽象产品
• 具体产品
• 工厂类

3. 具体实现

鼠标工厂，专业生产鼠标，给参数"Dell"，生产戴尔鼠标，给参数Hp"，生产惠普鼠标。

/**
 * 抽象产品-鼠标
 */
public abstract class Mouse {
    public abstract void sayHi();
}
/**
 * 具体产品-戴尔鼠标
 */
public class DellMouse extends Mouse {
    @Override
    public void sayHi() {
        System.out.println("**** SimpleFactoryPattern ****    I am a Dell Mouse.");
    }
}
/**
 * 具体产品-惠普鼠标
 */
public class HpMouse extends Mouse {
    @Override
    public void sayHi() {
        System.out.println("**** SimpleFactoryPattern ****    I am a Hp Mouse.");
    }
}
/**
 * 工厂类
 */
public class MouseFactory {

    public static Mouse ManufactureMouse(String mouseType) {
        if ("Dell".equals(mouseType)) {
            return new DellMouse();
        } else if ("Hp".equals(mouseType)) {
            return new HpMouse();
        }
        return null;
    }
}

外界通过调用工厂类的静态方法，传入不同参数从而创建不同具体产品类的实例:

private void testSimpleFactoryPattern() {
        Mouse dellMouse = MouseFactory.ManufactureMouse("Dell");
        if (dellMouse != null) {
            dellMouse.sayHi();
        }

        Mouse hpMouse = MouseFactory.ManufactureMouse("Hp");
        if (hpMouse != null) {
            hpMouse.sayHi();
        }
    }

输出结果：

**** SimpleFactoryPattern ****    I am a Dell Mouse.
**** SimpleFactoryPattern ****    I am a Hp Mouse.

三、工厂方法模式

1. 定义

工厂方法模式去掉了简单工厂模式中工厂类中的静态属性，使得它可以被子类继承，而子类则负责生成具体的对象。这样就可以将类的实例化延迟到工厂类的子类中完成，即由子类来决定应该实例化哪一个类。

2. 模式组成

• 抽象产品
• 具体产品
• 抽象工厂
• 具体工厂

3. 具体实现

生产鼠标工厂是个父类，有生产鼠标这个接口。生产戴尔鼠标工厂，生产惠普鼠标工厂分别继承这个工厂父类，可以分别生产戴尔鼠标，惠普鼠标。生产哪种鼠标不再由参数决定，而是由创建的具体鼠标工厂决定，后续直接调用鼠标工厂.生产鼠标()即可。

/**
 * 抽象产品-鼠标
 */
public abstract class Mouse {
    public abstract void sayHi();
}
/**
 * 具体产品-戴尔鼠标
 */
public class DellMouse extends Mouse {
    @Override
    public void sayHi() {
        System.out.println("**** FactoryPattern ****    I am a Dell Mouse.");
    }
}
/**
 * 具体产品-惠普鼠标
 */
public class HpMouse extends Mouse {
    @Override
    public void sayHi() {
        System.out.println("**** FactoryPattern ****    I am a Hp Mouse.");
    }
}
/**
 * 抽象工厂-生产鼠标
 */
public abstract class MouseFactory {
    public abstract Mouse ManufactureMouse();
}
/**
 * 具体工厂-生产戴尔鼠标
 */
public class DellMouseFactory extends MouseFactory {
    @Override
    public Mouse ManufactureMouse() {
        return new DellMouse();
    }
}
/**
 * 具体工厂-生产惠普鼠标
 */
public class HpMouseFactory extends MouseFactory {
    @Override
    public Mouse ManufactureMouse() {
        return new HpMouse();
    }
}

创建不同的鼠标工厂，生产不同的鼠标：

private void testFactoryPattern() {
        MouseFactory dellMouseFactory = new DellMouseFactory();
        dellMouseFactory.ManufactureMouse().sayHi();

        MouseFactory hpMouseFactory = new HpMouseFactory();
        hpMouseFactory.ManufactureMouse().sayHi();
    }

输出结果:

**** FactoryPattern ****    I am a Dell Mouse.
**** FactoryPattern ****    I am a Hp Mouse.

四、抽象工厂模式

1. 定义

抽象工厂模式是工厂方法模式的升级版本，用来创建一组相关或者相互依赖的对象。它允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，具体的工厂负责会实现具体的产品实例。其与工厂方法模式最大的区别就是抽象工厂中每个工厂可以创建多种类的产品，而工厂方法每个工厂只能创建一类产品。

2. 模式组成

• 抽象产品（多个）
• 具体产品
• 抽象工厂
• 具体工厂

3. 具体实现

抽象工厂模式也就是不仅生产鼠标，而且同时生产键盘。PC厂商是个父类，有生产鼠标，生产键盘两个接口。戴尔工厂，惠普工厂分别继承这个父类，可以分别生产戴尔鼠标和戴尔键盘，以及惠普鼠标和惠普键盘。生产的鼠标以及键盘由创建的工厂决定，后续工厂.生产鼠标()则生产具体的鼠标，工厂.生产键盘()则生产具体的键盘。

/**
 * 抽象产品-鼠标
 */
public abstract class Mouse {
    public abstract void sayHi();
}
/**
 * 抽象产品-键盘
 */
public abstract class Keyboard {
    public abstract void sayHi();
}
/**
 * 具体产品-戴尔鼠标
 */
public class DellMouse extends Mouse {
    @Override
    public void sayHi() {
        System.out.println("**** AbstractFactoryPattern ****    I am a Dell Mouse.");
    }
}
/**
 * 具体产品-惠普鼠标
 */
public class HpMouse extends Mouse {
    @Override
    public void sayHi() {
        System.out.println("**** AbstractFactoryPattern ****    I am a Hp Mouse.");
    }
}
/**
 * 具体产品-戴尔键盘
 */
public class DellKeyboard extends Keyboard {
    @Override
    public void sayHi() {
        System.out.println("**** AbstractFactoryPattern ****    I am a Dell Keyboard.");
    }
}
/**
 * 具体产品-惠普键盘
 */
public class HpKeyboard extends Keyboard {
    @Override
    public void sayHi() {
        System.out.println("**** AbstractFactoryPattern ****    I am a Hp Keyboard.");
    }
}
/**
 * 抽象工厂-生产鼠标和键盘
 */
public abstract class PcFactory {
    public abstract Mouse ManufactureMouse();
    public abstract Keyboard ManufactureKeyboard();
}
/**
 * 具体工厂-生产戴尔鼠标和戴尔键盘
 */
public class DellFactory extends PcFactory {
    @Override
    public Mouse ManufactureMouse() {
        return new DellMouse();
    }

    @Override
    public Keyboard ManufactureKeyboard() {
        return new DellKeyboard();
    }
}
/**
 * 具体工厂-生产惠普鼠标和惠普键盘
 */
public class HpFactory extends PcFactory {
    @Override
    public Mouse ManufactureMouse() {
        return new HpMouse();
    }

    @Override
    public Keyboard ManufactureKeyboard() {
        return new HpKeyboard();
    }
}

创建不同的工厂，生产不同的鼠标和键盘：

private void testAbstractFactoryPattern() {
        PcFactory dellFactory = new DellFactory();
        dellFactory.ManufactureMouse().sayHi();
        dellFactory.ManufactureKeyboard().sayHi();

        PcFactory hpFactory = new HpFactory();
        hpFactory.ManufactureMouse().sayHi();
        hpFactory.ManufactureKeyboard().sayHi();
    }

输出结果：

**** AbstractFactoryPattern ****    I am a Dell Mouse.
**** AbstractFactoryPattern ****    I am a Dell Keyboard.
**** AbstractFactoryPattern ****    I am a Hp Mouse.
**** AbstractFactoryPattern ****    I am a Hp Keyboard.