设计模式之创建型模式

设计模式之创建型模式 Java pattern 设计模式分类

9月 13, 2015

技术

1. 简单工厂模式(Simple Factory)；
2. 工厂方法模式(Factory Method)；
3. 抽象工厂模式(Abstract Factory)；
4. 建造者模式(Builder)；
5. 原型模式(Prototype)；
6. 单例模式(Singleton)；

##创建型模式
这六个模式都是与创建对象相关的

简单工厂模式（Simple Factory）；
工厂方法模式（Factory Method）；
抽象工厂模式（Abstract Factory）；
创建者模式（Builder）；
原型模式（Prototype）；
单例模式（Singleton）；

简单工厂模式(Simple Factory)；

工厂方法模式(Factory Method)；

建立一个工厂类，对实现同一接口的类进行实例化创建。

package design.pattern.factory;

/**
 * Created by Aaron on 15/9/13.
 */
public interface IParser {
    String parse(Object obj);
}

package design.pattern.factory;

/**
 * Created by Aaron on 15/9/13.
 */
public class JSONParser implements IParser{
    @Override
    public String parse(Object obj) {
        //create json string
        return "{class:"+obj.getClass()+"}";
    }
}

package design.pattern.factory;

/**
 * Created by Aaron on 15/9/13.
 */
public class XMLParser implements IParser{
    @Override
    public String parse(Object obj) {
        //create xml string....
        return "<object><class>"+obj.getClass()+"</class></object>";
    }
}

package design.pattern.factory;

/**
 * Created by Aaron on 15/9/13.
 */
public class ParserFactory {
    public static final  String  TYPE_XML="xml";
    public static final String  TYPE_JSON="json";
    public static IParser buildParser(String type){
        switch (type){
            case ParserFactory.TYPE_XML:return new XMLParser();
            case ParserFactory.TYPE_JSON:return new JSONParser();
        }
        return null;
    }

    public static void main(String[] args){
       IParser parser= ParserFactory.buildParser(ParserFactory.TYPE_JSON);
        System.out.print(parser.parse(parser));
    }
}

//output {class:JSONParser}

抽象工厂模式(Abstract Factory)；

工厂方法，每创建一个新的类时，就要个性类工厂类，这样拓展性比较差，如何能通过不个性工厂类而进行扩展呢。这里就用到了抽象工厂模式，就是创建多个工厂，一旦要增加新的类型就增加一个新的工厂，不需要修改现有代码。

基于上面代码将ParserFactory工厂类用一个抽象工厂类和两个子工厂类进行代替

package design.pattern.abstractfactory;

import design.pattern.factory.*;

/**
 * Created by Aaron on 15/9/13.
 */
public abstract class AbstractParserFactory {
    abstract IParser create();
}

package design.pattern.abstractfactory;

/**
 * Created by Aaron on 15/9/13.
 */
public class JSONParserFactory extends AbstractParserFactory {
    @Override
    IParser create() {
        return new JSONParser();
    }
}

package design.pattern.abstractfactory;

/**
 * Created by Aaron on 15/9/13.
 */
public class XMLParserFactory extends AbstractParserFactory {
    @Override
    IParser create() {
        return new XMLParser();
    }
}

建造者模式(Builder)；

GoF这样定义：

建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

咱们这里以创建应用为例，这里我们创建两个应用，考试系统和CRM系统，创建过程是，需求->原型图->开发计划->表设计->架构设计->功能实现->测试->交付大概是这样一个简单的过程,这里就会看到同样的构建过程得到不同的表示。

package design.pattern.builder;

import java.util.Vector;

/**
 * Created by Aaron on 15/9/13.
 */
public class Project {

    private Vector<String> impleProcess=new Vector<String>();
    public void process(String imple){
        impleProcess.add(imple);
    }
    public Vector<String> getImpleProcess() {
        return impleProcess;
    }

}

package design.pattern.builder;

/**
 * Created by Aaron on 15/9/13.
 */
public interface IProjectBuilder {
    Project getProject();
    void makeRequirement();

    void makePrototype();

    void makeScheduler();

    void makeTables();

    void makeAppFrameWork();

    void programming();

    void test();

    void delivery();
}

package design.pattern.builder;

/**
 * Created by Aaron on 15/9/13.
 */
public class ExamProjectBuilder implements IProjectBuilder {
    private Project project;

    public ExamProjectBuilder() {
        this.project = new Project();
    }

    public Project getProject() {
        return project;
    }

    @Override
    public void makeRequirement() {
        this.project.process("创建考试系统需求");

    }

    @Override
    public void makePrototype() {
        this.project.process("创建考试原型");
    }

    @Override
    public void makeScheduler() {
        this.project.process("创建考试计划");
    }

    @Override
    public void makeTables() {
        this.project.process("创建考试系统表");
    }

    @Override
    public void makeAppFrameWork() {
        this.project.process("创建考试应用架构");
    }

    @Override
    public void programming() {
        this.project.process("考试应用代码实现");
    }

    @Override
    public void test() {
        this.project.process("测试考试应用");
    }

    @Override
    public void delivery() {
        this.project.process("交付考试应用");
    }
}

package design.pattern.builder;

/**
 * Created by Aaron on 15/9/13.
 */
public class CRMProjectBuilder implements IProjectBuilder {
    public CRMProjectBuilder() {
        this.project = new Project();
    }

    public Project getProject() {
        return project;
    }

    private Project project;

    @Override
    public void makeRequirement() {
        this.project.process("创建CRM系统需求");
    }

    @Override
    public void makePrototype() {
        this.project.process("创建CRM原型");
    }

    @Override
    public void makeScheduler() {
        this.project.process("创建CRM计划");
    }

    @Override
    public void makeTables() {
        this.project.process("创建CRM系统表");
    }

    @Override
    public void makeAppFrameWork() {
        this.project.process("创建CRM应用架构");
    }

    @Override
    public void programming() {
        this.project.process("CRM应用代码实现");
    }

    @Override
    public void test() {
        this.project.process("测试CRM应用");
    }

    @Override
    public void delivery() {
        this.project.process("交付CRM应用");
    }
}

package design.pattern.builder;

/**
 * Created by Aaron on 15/9/13.
 */
public class Director {
    private IProjectBuilder builder;
    public Director(IProjectBuilder builder){
        this.builder=builder;
    }
    public Project process(){
        this.builder.makeRequirement();
        this.builder.makePrototype();
        this.builder.makeScheduler();
        this.builder.makeAppFrameWork();
        this.builder.makeTables();
        this.builder.programming();
        this.builder.test();
        this.builder.delivery();
        return builder.getProject();
    }

    public static void main(String[] args){
        Director  director = new Director(new CRMProjectBuilder());
        Project project = director.process();
        System.out.println(project.getImpleProcess());
    }
}

//输出  [创建CRM系统需求, 创建CRM原型, 创建CRM计划, 创建CRM应用架构, 创建CRM系统表, CRM应用代码实现, 测试CRM应用, 交付CRM应用]

原型模式(Prototype)；

GoF这样定义：

用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象。

package design.pattern.prototype;

import java.io.*;
import java.util.Vector;

/**
 * Created by Aaron on 15/9/13.
 */
public class DeepClonePrototype implements Cloneable,Serializable {
    public Vector<String> attrs=new Vector<String>();

    public Object deepClone() throws CloneNotSupportedException, IOException, ClassNotFoundException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(this);
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        return ois.readObject();
    }

    public static void main(String[] args) throws Exception{
        Object pro=new DeepClonePrototype().deepClone();
        System.out.println(pro.getClass());
    }

}

单例模式(Singleton)；

保证一个类仅有一个实例,并提供一个访问它的全局访问点。

package design.pattern.singleton;

/**
 * Created by Aaron on 15/9/11.
 */
public class Singleton {
    private Singleton() {

    }

    private static Singleton instance = null;

    private static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    return instance = new Singleton();
                } else {
                    return instance;
                }
            }
        } else {
            return instance;
        }
    }

    public String getName() {
        return Singleton.class.getName();
    }

    public static void main(String args[]) {
        Singleton instance = Singleton.getInstance();
        System.out.print(instance.getName());
    }

}

java 设计模式

prev： Protobuf是什么 next：设计模式之结构型模式