一、创建型模式

01. 简单工厂模式

抽象产品类：将要批量生产的对象实体进行一个抽象提取，便于扩展更多实体，比如手机类;
具体产品类：继承抽象产品，将产品实例化。比如小米手机、华为手机等；
工厂类：简单工厂的核心，根据用户传入不同参数来创建不同类型的产品对象。比如传入小
米就得创建小米手机的实例对象，若要增加新的产品，则需要添加一个继承抽象产品类的具
体产品类，在工厂类的静态工厂方法中添加一个 else if 来生产该新产品。

• 简单工厂模式优点：
  • 用户无需知道创建的具体类名，只需知道要传的参数即可得到对象；
• 简单工厂模式缺点：
  • 扩展困难。

02. 工厂方法模式

抽象产品：描述具体产品的公共接口。
具体产品：象产品的子类，工厂类要创建的目标类，描述生产的具体产品。
抽象工厂：描述具体工厂的公共接口。
具体工厂：抽象工厂的子类；被外界调用，实现 FactoryMethod 工厂方法创建产品的实例。
创建过程：
①：创建抽象工厂类，定义具体工厂的公共接口；
②：创建抽象产品类 ，定义具体产品的公共接口；
③：创建具体产品类（继承抽象产品类）与定义生产的具体产品；
④：创建具体工厂类（继承抽象工厂类）与定义创建对应具体产品实例的方法；
⑤：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例。

• 工厂方法模式的优点：
  • 更符合开-闭原则，新增一种产品时，只需要增加相应的具体产品类
    和相应的工厂子类即可；
  • 符合单一职责原则，每个具体工厂类只负责创建对应的产品，不使用静态工厂方法，可以形成基于继承的等级结构；
• 工厂方法模式的缺点：
  • 添加新产品时，除了增加新产品类外，还要提供与之对应的具体工厂
    类，增加系统复杂度。

（1）工厂方法模式例题

  现需要设计一个程序来读取多种不同类型的图片格式，针对每一种图片格式都设计一个图片读取器 ImgReader,如 gif 图片读取器 GifReader 用于读取 gif 格式的图片,jpg 图片读取器 JPGReader 用于读取 jpg 格式的图片。图片读取器对象通过图片读取器工厂ImgReaderFactory 来创建。ImgReaderFactory 是一个抽象类,用于定义创建图片读取器的工厂方法,其 GifReaderFactory 和 JPGReaderFactory 用于创建具体的图片读取器对象。使用工厂方法模式，实现该程序的设计。

抽象工厂：ImgReaderFactory 接口，有一个用来生产 ImgReader 产品的方法；
具体工厂：GifReaderFactory 和 JpgReaderFactory 实现了 ImgReaderFactory 接口,并有一个用来生产具体产品的方法；
抽象产品：ImgReader 接口，有一个 read 的方法；
具体产品：GidReader,JpgReader 实现了 ImgReader 接口和 read 方法。
Client：用来测试使用工厂来生产具体产品。

代码实现：

// 抽象工厂接口
public interface ImageReaderFactory {
    public ImgReader createReader();
}

// 具体工厂 GifReaderFactory
public class GifReaderFactory implements ImageReaderFactory {
    @Override
    public ImgReader createReader() {
        return new GIfReader();
    }
}

// 具体工厂 JpgReaderFactory
public class JpgReaderFactory implements ImageReaderFactory {
    @Override
    public ImgReader createReader() {
        return new JpgReader();
    }
}

// 抽象产品接口
public interface ImgReader {
    void read();
}

// 具体产品 GIfReader
public class GIfReader implements ImgReader {
    @Override
    public void read() {
        System.out.println("gif");
    }
}

// 具体产品 JpgReader
public class JpgReader implements ImgReader {
    @Override
    public void read() {
        System.out.println("jpg");
    }
}

// 测试
public class Client {
    public static void main(String[] args) {
        ImageReaderFactory factory1 = new JpgReaderFactory();
        ImgReader reader1 = factory1.createReader();
        reader1.read(); // 输出 jpg
        ImageReaderFactory factory2 = new GifReaderFactory();
        ImgReader reader2 = factory2.createReader();
        reader2.read(); // 输出 gif
    }
}

03. 抽象工厂模式

AbstactFactory(抽象工厂)：声明一组用于创建一族产品的方法，每个方法对应一种对象；在抽象工厂中声明了多个工厂方法， 用于创建不同类型的对象，抽象工厂可以是接口，在这里是接口的形式；
ConcreteFactory1/2(具体工厂)：具体工厂实现了抽象工厂，每个工厂方法返回一个具体对象，一个具体工厂所创建的具体对象构成一个族；
AbstactProductA/B(抽象产品)：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品；
ProductA1/A2/B1/B2(具体产品)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

• 抽象工厂模式优点：
  • 抽象工厂隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例。
  • 一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象；
• 抽象工厂模式缺点：
  • 添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，增加新的产品等级结构麻烦。

（1）抽象工厂模式例题

  计算机包括内存（RAM）,CPU 等硬件设备，根据图中的”产品等级结构–产品族“示意图，使用抽象工厂模式实现计算机设备创建过程并绘制出相应的类图。

抽象工厂：是一个接口，有两个方法用来生产RAM、CPU；
具体工厂：PcFactory和MacFactory，实现了抽象工厂类，各个类中实现了以上2个方法来生产各自需要的RAM、CPU；
抽象产品：RAM、CPU，一个RAM和一个CPU组成一个族；
具体产品：PcRAM、MacRAM、PcCPU、MacCPU。

代码实现：

public class Client {
    public static void main(String[] args) {
        AbstractFactory pcFactory = new PcFactory();
        AbstractFactory macFactory = new MacFactory();

        pcFactory.createCPU().printCPU(); // PcCPU
        pcFactory.createRAM().printRAM(); // PcRAM

        macFactory.createCPU().printCPU(); // MacCPU
        macFactory.createRAM().printRAM(); // MacRAM
    }
}

// 抽象工厂接口
interface AbstractFactory {
    RAM createRAM();

    CPU createCPU();
}

// 具体工厂
class PcFactory implements AbstractFactory {
    @Override
    public RAM createRAM() {
        return new PcRAM();
    }

    @Override
    public CPU createCPU() {
        return new PcCPU();
    }
}

class MacFactory implements AbstractFactory {
    @Override
    public RAM createRAM() {
        return new MacRAM();
    }

    @Override
    public CPU createCPU() {
        return new MacCPU();
    }
}

// 抽象产品接口
interface RAM {
    void printRAM();
}

interface CPU {
    void printCPU();
}

// 具体产品
class PcRAM implements RAM {

    @Override
    public void printRAM() {
        System.out.println("PcRAM");
    }
}

class MacRAM implements RAM {
    @Override
    public void printRAM() {
        System.out.println("MacRAM");
    }
}

class PcCPU implements CPU {
    @Override
    public void printCPU() {
        System.out.println("PcCPU");
    }
}

class MacCPU implements CPU {
    @Override
    public void printCPU() {
        System.out.println("MacCPU");
    }
}

04. 建造者模式

抽象建造者(Builder)：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的对象部件的创建。
具体建造者(ConcreteBuilder)：实现 Builder 接口，完成复杂对象的各个部分的具体创建方法。在构造过程完成后，提供产品的实例。
产品类（Product)：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。。
指挥者类（Director)：调用具体建造者(ConcreteBuilder)来创建复杂对象的各个组成部分。在指挥者中不涉及具体产品的信息。
  建造者模式更加注重方法的调用顺序，建造者模式创建复杂的对象，不仅要创建出对象，还
要创建该对象的组件。以上是简单创建一个产品，该模式是创建产品的构建来组装成产品。

原文地址：http://www.cnblogs.com/hbjiaxin/p/16907406.html