Android 小知识点(三)

那些年你未曾注意过的设计模式

1.工厂模式(简单静态工厂)

public abstract class Drink {

    public void make() {
        // 1. 拿出一次性饮料杯
        System.out.println("拿出一次性饮料杯");

        // 2. 加入速溶橙汁粉
        System.out.println("加入" + getInstantPackage());

        // 3. 加水冲兑
        System.out.println("加水");

        // 4. 加盖, 打包
        System.out.println("加盖, 打包");
    }

    abstract String getInstantPackage();
}



public class Coke extends Drink {
    @Override
    String getInstantPackage() {
        return "速溶可乐粉";
    }
}

public class PlumJuice extends Drink {
    @Override
    String getInstantPackage() {
        return "速溶酸梅粉";
    }
}

public class OrangeJuice extends Drink {
    @Override
    String getInstantPackage() {
        return "速溶橙汁粉";
    }
}


public class Factory{

    public static Drink create(String drinkType) {

        //  Java7开始, switch支持String
        switch (drinkType) {
            case "橙汁":
                return new OrangeJuice();

            case "酸梅汤":
                return new PlumJuice();

            case "可乐":
                return new Coke();

            default:
                return new OrangeJuice();
        }
    }
}

微信截图_20190125171824.png

同时在分支逻辑上 属于策略模式,在生产目的上属于工厂模式(关注的是产出,策略关注的分支)

个人理解:调用对象不需要关心对象是如何产生的,只需要调用工厂生产方法,并且传入(或者工厂内部自行判断条件) ,产出对应的对象产品
弊端: 判断的分支UML逻辑和生成对象的创建操作都在工厂类中进行,工厂类复杂.

2.装饰者模式

public interface Drink {

    String make();
}


public class Coke implements Drink {
    @Override
    public String make() {
        return "这是一杯可乐";
    }
}

blic class Ice implements Drink {

    private Drink originalDrink;
    public Ice(Drink originalDrink) {
        this.originalDrink = originalDrink;
    }

    @Override
    public String make() {
        return originalDrink.make() + ", 加一块冰";
    }


public class XiaoGuang {

    public static void main(String[] args) {

        Drink coke = new Coke();
        System.out.println(coke.make());

        Drink iceCoke = new Ice(new Coke());
        System.out.println(iceCoke.make());
    }
}

public abstract class Stuff implements Drink {

    private Drink originalDrink;
    public Stuff(Drink originalDrink) {
        this.originalDrink = originalDrink;
    }

    @Override
    public String make() {
        return originalDrink.make() + ", 加一份" + stuffName();
    }

    abstract String stuffName();
}


public class Ice extends Stuff {

    public Ice(Drink originalDrink) {
        super(originalDrink);
    }

    @Override
    String stuffName() {
        return "冰";
    }
}


Drink iceSugarXDrink = new Ice(new Sugar(new XDrink()));
System.out.println(iceSugarXDrink.make());

这是一杯X牌饮料, 加一份糖, 加一份冰

a.jpg

装饰者模式就是用来动态的给对象加上额外的职责.
Drink是被装饰的对象, Stuff作为装饰类, 可以动态地给被装饰对象添加特征, 职责.

注意:
Builder模式是一种创建型的设计模式. 旨在解决对象的差异化构建的问题.
装饰者模式是一种结构型的设计模式. 旨在处理对象和类的组合关系.
构建者模式的情况通常是可以预见的,但是装饰者可以通过增加类 而不是修改原本的构建类这种方式,所以构建者模式通常用于一些参数不可预见的情况