设计模式 在线

2253适配器模式

分享一个例子:笔记本通过读卡去读取TF卡;

一、先模拟计算机读取SD卡:

1、先创建一个SD卡的接口:

public interface SDCard {
    //读取SD卡方法
    String readSD();
    //写入SD卡功能
    int writeSD(String msg);
}

2、创建SD卡接口的实现类,模拟SD卡的功能:

public class SDCardImpl implements SDCard {
    @Override    
    public String readSD() {
        String msg = "sdcard read a msg :hello word SD";
        return msg;  
    }
    @Override  
    public int writeSD(String msg) {      
        System.out.println("sd card write msg : " + msg);    
        return 1;   
    }
}

3、创建计算机接口,计算机提供读取SD卡方法:

public interface Computer {    
    String readSD(SDCard sdCard);
}

4、创建一个计算机实例,实现计算机接口,并实现其读取SD卡方法:

public class ThinkpadComputer implements Computer {
    @Override    
    public String readSD(SDCard sdCard) {        
        if(sdCard == null)throw new NullPointerException("sd card null");        
        return sdCard.readSD();    
    }
}

5、这时候就可以模拟计算机读取SD卡功能:

public class ComputerReadDemo {    
    public static void main(String[] args) {        
        Computer computer = new ThinkpadComputer();        
        SDCard sdCard = new SDCardImpl();       
        System.out.println(computer.readSD(sdCard));    
    }
}

二、接下来在不改变计算机读取SD卡接口的情况下,通过适配器模式读取TF卡:

1、创建TF卡接口:

public interface TFCard {    
    String readTF();    
    int writeTF(String msg);
}

2、创建TF卡实例:

public class TFCardImpl implements TFCard {    
    @Override    
    public String readTF() {        
        String msg ="tf card reade msg : hello word tf card";        
        return msg;    
    }    
    @Override    
    public int writeTF(String msg) {        
        System.out.println("tf card write a msg : " + msg);        
        return 1;    
    }
}

3、创建SD适配TF (也可以说是SD兼容TF,相当于读卡器):

实现SDCard接口,并将要适配的对象作为适配器的属性引入。

public class SDAdapterTF implements SDCard {    
    private TFCard tfCard;    
    public SDAdapterTF(TFCard tfCard) {        
        this.tfCard = tfCard;    
    }    
    @Override    
    public String readSD() {        
        System.out.println("adapter read tf card ");        
        return tfCard.readTF();    
    }    
    @Override    
    public int writeSD(String msg) {        
        System.out.println("adapter write tf card");        
        return tfCard.writeTF(msg);    
    }
}

4、通过上面的例子测试计算机通过SD读卡器读取TF卡:

public class ComputerReadDemo {    
    public static void main(String[] args) {        
        Computer computer = new ThinkpadComputer();        
        SDCard sdCard = new SDCardImpl();        
        System.out.println(computer.readSD(sdCard));        
        System.out.println("====================================");        
        TFCard tfCard = new TFCardImpl();        
        SDCard tfCardAdapterSD = new SDAdapterTF(tfCard);        
        System.out.println(computer.readSD(tfCardAdapterSD));    
    }
}

输出:

sdcard read a msg :hello word SD
====================================
adapter read tf card 
tf card reade msg : hello word tf card

在这种模式下,计算机并不需要知道具体是什么卡,只需要负责操作接口即可,具体操作的什么类,由适配器决定。

2252原型模式

原型模式中有三个登场角色:

原型角色:定义用于复制现有实例来生成新实例的方法;

// 以贴主示例代码为例  
implements Cloneable   // 1.(抽象类或者接口)实现 java.lang.Cloneable 接口
public Shape clone();  // 2.定义复制现有实例来生成新实例的方法

具体原型角色:实现用于复制现有实例来生成新实例的方法

public Shape clone() {// 2.实现复制现有实例来生成新实例的方法(也可以由超类完成)
    Shape clone = null;
    try {
        clone = (Shape) clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    return clone;
}

使用者角色:维护一个注册表,并提供一个找出正确实例原型的方法。最后,提供一个获取新实例的方法,用来委托复制实例的方法生成新实例。

private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();//维护一个注册表
    public static void loadCache() {
    Circle circle = new Circle();
    circle.setId("1");
    shapeMap.put(circle.getId(),circle);

    Square square = new Square();
    square.setId("2");
    shapeMap.put(square.getId(),square);

    Rectangle rectangle = new Rectangle();
    rectangle.setId("3");
    shapeMap.put(rectangle.getId(),rectangle);
}
public static Shape getShape(String shapeId) {//提供一个获取新实例的方法
    Shape cachedShape = shapeMap.get(shapeId);//提供一个找出正确实例原型的方法
    return (Shape) cachedShape.clone();//委托复制实例的方法生成新实例。
}

2251建造者模式

步骤 7可以拆开吧?

抽象建造者 1

public  class Builder {    
    public Meal meal = new Meal();    
    public void prepareVegMeal(){};    
    public void prepareNonVegMeal(){};    
    public Meal getMeal(){return null;
};

指挥者 2

public class Director {    
    public void Constuct(Builder builder){        
        builder.prepareVegMeal();        
        builder.prepareNonVegMeal();    
    }
}

具体的建造者

public class VegMealBuilder extends Builder{    
    public void prepareVegMeal() {        
        meal.addItem(new VegBurger());        
        meal.addItem(new Coke());
    }    
    public void prepareNonVegMeal() {    }    
    public Meal getMeal() {        
        return meal;    
    }
}

具体建造者

public class NonVegMealBuilder extends Builder {    
    @Override    
    public void prepareVegMeal() {    }    
    @Override    
    public void prepareNonVegMeal() {        
        meal.addItem(new ChickenBurger());        
        meal.addItem(new Pepsi());    
    }    
    @Override   
    public Meal getMeal() {        
        return meal;    
    }
}

调用

public class Test {    
    @Test    
    public void BuilderPatternDemo() {        
        Director director = new Director();        
        VegMealBuilder b1 = new VegMealBuilder();        
        NonVegMealBuilder b2 = new NonVegMealBuilder();        
        director.Constuct(b1);        
        director.Constuct(b2);        
        Meal vegMeal = b1.getMeal();        
        System.out.println("Veg Meal");        
        vegMeal.showItems();        
        System.out.println("Total Cost: " +vegMeal.getCost());        
        Meal nonVegMeal = b2.getMeal();        
        System.out.println("\n\nNon-Veg Meal");        
        nonVegMeal.showItems();       
        System.out.println("Total Cost: " +nonVegMeal.getCost());    
    }
}

最后应该是优化成 list(含有多参数)传入,上层组装meal套餐或者单点,这种灵活性更强吧。

2250建造者模式

建造者模式,又称生成器模式:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。

三个角色:建造者具体的建造者监工使用者(严格来说不算)

  • 建造者角色:定义生成实例所需要的所有方法;
  • 具体的建造者角色:实现生成实例所需要的所有方法,并且定义获取最终生成实例的方法;
  • 监工角色:定义使用建造者角色中的方法来生成实例的方法;
  • 使用者:使用建造者模式。

注意:定义中“将一个复杂的构建过程与其表示相分离”,表示并不是由建造者负责一切,而是由监工负责控制(定义)一个复杂的构建过程,由各个不同的建造者分别负责实现构建过程中所用到的所有构建步骤。不然,就无法做到“使得同样的构建过程可以创建不同的表示”这一目标。

建造者角色:

public abstract class Builder {
    public abstract void buildPart1();
    public abstract void buildPart2();
    public abstract void buildPart3();
}

监工角色:

public class Director {    // 将一个复杂的构建过程与其表示相分离
    private Builder builder;    // 针对接口编程,而不是针对实现编程
    public Director(Builder builder) {
        this.builder = builder;
    }
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public void construct() {   // 控制(定义)一个复杂的构建过程
        builder.buildPart1();
        for (int i = 0; i < 5; i++) {   // 提示:如果想在运行过程中替换构建算法,可以考虑结合策略模式。
            builder.buildPart2();
        }
        builder.buildPart3();
    }
}

具体的建造者角色:

/**
 * 此处实现了建造纯文本文档的具体建造者。
 * 可以考虑再实现一个建造HTML文档、XML文档,或者其它什么文档的具体建造者。
 * 这样,就可以使得同样的构建过程可以创建不同的表示
 */
public class ConcreteBuilder1 extends Builder {
  private StringBuffer buffer = new StringBuffer();//假设 buffer.toString() 就是最终生成的产品

    @Override
    public void buildPart1() {//实现构建最终实例需要的所有方法
        buffer.append("Builder1 : Part1\n");
    }

    @Override
    public void buildPart2() {
        buffer.append("Builder1 : Part2\n");
    }

    @Override
    public void buildPart3() {
        buffer.append("Builder1 : Part3\n");
    }
    
    public String getResult() {//定义获取最终生成实例的方法
        return buffer.toString();
    }
}

客户角色:

public class Client {
    public void testBuilderPattern() {
        ConcreteBuilder1 b1 = new ConcreteBuilder1();//建造者
        Director director = new Director(b1);//监工
        director.construct();//建造实例(监工负责监督,建造者实际建造)
        String result = b1.getResult();//获取最终生成结果
        System.out.printf("the result is :%n%s", result);
    }
}

2249建造者模式

建造者模式举例:去肯德基点餐,我们可以认为点餐就属于一个建造订单的过程。我们点餐的顺序是无关的,点什么东西也是没有要求的,可以单点,也可以点套餐,也可以套餐加单点,但是最后一定要点确认来完成订单。

public class OrderBuilder{
    private Burger mBurger;
    private Suit mSuit;

    //单点汉堡,num为数量
    public OrderBuilder burger(Burger burger, int num){
        mBurger = burger;
    }

    //点套餐,实际中套餐也可以点多份
    public OrderBuilder suit(Suit suit, int num){
    mSuit = suit;
    }

    //完成订单
    public Order build(){
        Order order = new Order();
        order.setBurger(mBurger);
        order.setSuit(mSuit);
        return order;
    }
}

另外适用于快速失败,在 build 时可以做校验,如果不满足必要条件,则可以直接抛出创建异常,在 OkHttp3 中的 Request.Builder 中就是这样用的。

public Request build() {  
    if (url == null) throw new IllegalStateException("url == null");  
    return new Request(this);
}

例如订单要求价格至少达到 30 块:

//完成订单
public Order build(){
    Order order = new Order();
    order.setBurger(mBurger);
    order.setSuit(mSuit);
    if(order.getPrice() < 30){
        throw new BuildException("订单金额未达到30元");
    }
    return order;
}

另外,在构建时如果有必传参数和可选参数,可以为 Builder 类添加构造函数来保证必传参数不会遗漏,例如在构建一个 http 请求时, url 是必传的:

public class RequestBuilder{
    private final String mUrl;
    private Map<String, String> mHeaders = new HashMap<String, String>();

    private RequestBuilder(String url){
        mUrl = url;
    }

    public static RequestBuilder newBuilder(String url){
        return new RequestBuilder(url);
    }

    public RequestBuilder addHeader(String key, String value){
        mHeaders.put(key, value);
    }

    public Request build(){
        Request request = new Request();
        request.setUrl(mUrl);
        request.setHeaders(mHeaders);
        return request;
    }
}