Java23种设计模式——建造者模式

该系列文章为博主学习笔记，原文请参考参考链接
本文禁止转载，但是欢迎大家留言区留言交流[微笑]

建造者模式是一种对象创建模型，比如需要创建两个交通工具类，分别是汽车和摩托车类，两个对象的结构都一致（属性：名称、类型、车身颜色、车龄等等）。可能有的人会想，我创建一个Card类，然后创建两个类分别是汽车类和摩托车类，然后分别继承Card类，并重写get和set方法等等。

如果按照上述做法不是很好，因为设计的时候应该多关联少继承，这样会不利于程序的扩展。其次我们不想让客户端知道创建一个汽车类或者摩托车类都需要什么方法，想要对客户端透明，所以我们应该采用建造者模式。

代码：

//Card类对应Product类，是一个产品的类
public class Card {
    //汽车名称
    private String name;
    //汽车类型
    private String type;
    //使用时间
    private int age;
    //车盖颜色
    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "车名："+this.name+"  车类型："+this.type+"  车龄:"+this.age+"  车盖颜色："+this.color;
    }
}

//具体产品，对应UML图中的concreteBuilder类
//是CardBuilder的具体实现类，用于生产具体的产品
public class BigCard extends CardBuilder {
    @Override
    public void buildName() {
        card.setName("大运摩托");
    }

    @Override
    public void buildType() {
        card.setType("摩托车");
    }

    @Override
    public void buildAge() {
        card.setAge(3);
    }

    @Override
    public boolean isColor() {
        return false;
    }

    @Override
    public void buildColor() {
        card.setColor("蓝色");
    }
}

//具体产品，对应UML图中的concreteBuilder类
//是CardBuilder的具体实现类，用于生产具体的产品
public class SmallCard extends CardBuilder {
    @Override
    public void buildName() {
        card.setName("三菱");
    }

    @Override
    public void buildType() {
        card.setType("货车");
    }

    @Override
    public void buildAge() {
        card.setAge(5);
    }

    @Override
    public void buildColor() {
        card.setColor("红色");
    }

}

//CardBuilder对应Builder类，对产品（Card）设置的属性声明为抽象方法（buildName、buildType等等），然后具体产品类（SmallCard，BigCard）去继承，并且重写抽象方法，这里面保存了对产品类Card的依赖，在子类中通过card去进行设置，在该类中声明createCard方法，用于返回设置完的card对象。这样在客户端种就不会知道构建一个对象的细节，将细节的流程都交给抽象类，将具体的流程交给抽象类的子类。
public abstract class CardBuilder {

    protected Card card = new Card();

    public abstract void buildName();

    public abstract void buildType();

    public abstract void buildAge();

    public abstract void buildColor();


    protected boolean isColor() {
        return true;
    }


    public Card createCard() {
        return card;
    }
}

//对应于UML图中的Director
//用于返回具体生产的类
public class CardController {
    public Card construct(CardBuilder ab) {
        Card card;
        ab.buildName();
        ab.buildAge();
        ab.buildType();
        if (ab.isColor()) {
            ab.buildColor();
        }

        card = ab.createCard();
        return card;
    }
}

public class myClass {
    public static void main(String[] args) {
        CardController cardController=new CardController();
        final Card construct = cardController.construct(new SmallCard());
        System.out.println("construct = " + construct.toString());
    }
}

输出：
construct = 车名：三菱 车类型：货车 车龄:5 车盖颜色：红色

这种模式适用于两个或者两个以上，对象大致相同（属性，方法），而要设置不同属性，产生不同的对象，在写日常写代码中，我觉得用途还是很大的，之前对于这种操作都是运用的继承的方式，现在感觉low到爆。

微信公众号：

QQ群：365473065