GOF 23设计模式之二（创建型模式）

目录

1.工厂模式

1.1简单工厂模式

1.2工厂方法

2.抽象工厂模式

3.建造者模式

一、工厂模式（Factory Method）

     定义一个创建产品对象的工厂接口，将产品对象的实际创建交给具体的子类去完成。

    工厂模式分为：简单工厂模式、工厂方法模式。

    核心角色：

• (1)抽象工厂(Abstract Factory)：提供了创建产品的接口
• (2)具体工厂(Concrete Factory)：实现抽象工厂中的方法，完成具体产品的创建
• (3)抽象产品(Product)：描述产品的主要特性和功能。
• (4)具体产品(Concrete Product)：实现抽象产品中的接口，由具体工厂来创建。

    优点：

• (1)用户只需知道工厂名就可以获取产品，无需知道产品生产的过程。
• (2)添加产品时，只需要添加对应的具体产品类、具体工厂类。无需改动原工厂。满足开闭原则

    缺点：

• (1)每添加一个产品都要添加具体产品类和具体工厂类。增加了系统的复杂度。

简单工厂方法：

    如果只要一个工厂类就可以完成的。不属于GOF的模式。

public class textFactory {

    public static void main(String[] args) {
        //实现工厂
        Factory factory = new Factory();
        factory.createMD().show(); //生产美的空调
        factory.createGL().show(); //生产格力空调
    }
}

interface Product{ //定义接口
    
    public void show();
}

class md implements Product{ //实现接口的产物

    @Override
    public void show() {
        System.out.println("我是美的空调！");
    }
}

class gl implements Product{ //实现接口的产物

    @Override
    public void show() {
        System.out.println("我是格力空调！");
    }
}

class Factory{ //定义工厂类 只有一个简单的工厂
    
    public Product createMD() {//生产美的
        
        return new md();
    };
    
    public Product createGL() { //生成格力
        
        return new gl();
    }
}

返回顶部

工厂方法

    就是专门创建一个工厂类的接口，来进行工厂类的管理。

public class textFactory {

    public static void main(String[] args) {

        //创建美的工厂
        AbstractFactory md = new ConcreateFactory1();
        md.newProduct().show(); //生产美的空调
        
        //创建格力工厂
        AbstractFactory gl = new ConcreateFactory2();
        gl.newProduct().show(); //生产格力空调
    }
}

interface Product{ //定义接口
    public void show();
}

class md implements Product{ //实现接口的产物

    @Override
    public void show() {
        System.out.println("我是美的空调！");
    }
}

class gl implements Product{ //实现接口的产物

    @Override
    public void show() {
        System.out.println("我是格力空调！");
    }
}

interface AbstractFactory{ //工厂接口类
    public Product newProduct();
}

//创建美的空调的工厂
class ConcreateFactory1 implements AbstractFactory{

    @Override
    public Product newProduct() {
        
        return new md();
    }
}

//创建格力空调工厂
class ConcreateFactory2 implements AbstractFactory{

    @Override
    public Product newProduct() {
        
        return new gl();
    }
}

返回顶部

二、抽象工厂方法（Abstract Factory）

      提供一个创建一组相关或相互依赖对象的接口，且访问类无需指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

      产品族：同一个具有工厂所生产的位于不同等级的一组产品。

      核心角色：

• (1)抽象工厂(Abstract Factory)：创建产品的接口，可以创建多个不同等级的产品。
• (2)具体工厂(Conrete Factory)：实现抽象工厂中多个抽象方法，完成具体的产品创建
• (3)抽象产品(Product)：描述产品主要特性和功能，抽象工厂中有多个抽象产品
• (4)具体产品(Concrete Product)：实现抽象产品定义的接口，由工厂来创建。

      优点：(除了工厂方法的优点外)

• (1)可以在类的内部对产品族的多等级产品共同管理，而不必引入新类来进行管理
• (2)当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

      缺点：

• (1)当产品族中添加新的产品族时，所有的工厂类都要进行修改。

public class textFactory {

    public static void main(String[] args) {
     
        //这里使用了用抽象工厂来创建不同品质等级的汽车零件。
        
        //1、生产高质量汽车零件
        AbstractFactory gzl = new gcar();//高质量汽车工厂
        gzl.newProduct1().showWK();
        gzl.newProduct2().showFDJ();
        
        //2、生产低质量汽车零件
        AbstractFactory dzl = new dcar();//低质量汽车工厂
        dzl.newProduct1().showWK();
        dzl.newProduct2().showFDJ();
    }
}

interface Product1{ //产品一 （生产汽车外壳）
    public void showWK();
}

interface Product2{//产品二 （生产汽车发动机）
    public void showFDJ();
}

//不同品质的成品
class gcs implements Product1{ //高品质外壳

    @Override
    public void showWK() {
        System.out.println("高质量外壳");
    }
}

class dcs implements Product1{ //低品质外壳

    @Override
    public void showWK() {
        System.out.println("低质量外壳");
    }
}

class gfdj implements Product2{    //高品质发动机

    @Override
    public void showFDJ() {
        System.out.println("高质量发动机");
    }
}

class dfdj implements Product2{ //低品质发动机

    @Override
    public void showFDJ() {
        System.out.println("低质量发动机");
    }
}


//抽象工厂
interface AbstractFactory{//需要产出的不同的品质的产品。（产品族）
    
    public Product1 newProduct1();    //生产不同品质的外壳
    public Product2 newProduct2();    //生产不同品质的发动机
}

class gcar implements AbstractFactory{//高质量汽车

    @Override
    public Product1 newProduct1() {
        return new gcs(); //高质量外壳
    }

    @Override
    public Product2 newProduct2() {
        return new gfdj(); //高质量发动机
    }
}

class dcar implements AbstractFactory{//低质量汽车

    @Override
    public Product1 newProduct1() {
        return new dcs();//低质量外壳
    }

    @Override
    public Product2 newProduct2() {
        return new dfdj(); //低质量发动机
    }
}

返回顶部

五、建造者（Builder）

      指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示。就是将对象的构建和装配进行解耦。

      核心角色：

• (1)产品角色(Product)：包含多个组成部件的复杂对象，由具体建造者类创建
• (2)抽象建造者(Builder)：包含创建产品各个子部件的抽象方法的接口
• (3)具体建造者(Conrete Builder)：实现Builder接口，完成复杂的具体部件的创建
• (4)指挥者(Director)：调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体商品的信息。

      优点：

• (1)各个具体建造者互相独立，有益于系统的扩展
• (2)客户端不必知道产品内部组成的细节，便于控制细节风险

      缺点：

• (1)产品的组成部分必须相同，这限制了其使用范围。
• (2)如果产品的内部变化复杂，该模式会增加很多的建造者类

public class textBuilder {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //先产出材料 （炫彩材料）
        Builder xc = new xc(); //或者换回 普通材料
        
        //指挥者进行指挥
        Director director = new Director(xc);
        
        //显示墙
        director.construct().show();
        
        
    }
}

//实体产物

class Product{
    
    private String zt;//砖头
    private String sn;//水泥

    public void setZt(String zt) {
        this.zt = zt;
    }
    public void setSn(String sn) {
        this.sn = sn;
    }

    
    //建造出来的墙
    public void show() {
        
        System.out.println("建造出来的墙：使用砖头："+zt+";水泥："+sn);
    }
}

//抽象建造者
abstract class Builder{
    
    //使用protected，为了可以给子类使用
    protected Product p = new Product();
    
    abstract void getzt();//给子类工厂进行修饰
    abstract void getsn();//给子类工厂进行修饰
    
    public Product getResult() {
        
        return p;
    }
}

//第一个修饰工厂
class xc extends Builder{//炫彩材料

    @Override
    void getzt() {
        p.setZt("七彩砖");
    }

    @Override
    void getsn() {
        p.setSn("混合凝土");
    }
}

class pt extends Builder{//普通材料

    @Override
    void getzt() {
        p.setZt("沙砖");
    }

    @Override
    void getsn() {
        p.setSn("单一凝土");
    }
}

//指挥者
class Director{
        
    private Builder builder;

    public Director(Builder builder) {
        super();
        this.builder = builder;
    }
    
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }


    //指挥者进行指挥装配
    public Product construct() {
        
        builder.getzt();
        builder.getsn();
    
        return builder.getResult();
    }
}

返回顶部