设计模式

设计原则

• 单一职责原则
  就一个类而言应当仅有一个引起它变化的原因

• 开放-封闭原则
  一个类（模块、函数。。）应该对拓展开放，对修改封闭

• 依赖倒转
  高层模块不应该依赖于低层模块，两个都应该依赖于抽象
  抽象不应该依赖于细节，细节应当依赖于抽象

  里氏代换原则，子类型必须能够替换到他们的父类型
  +

策略模式

使用目的：为了达到同一目标，但在不同场景下有着不同的算法，这些算法的输入输出属性相同

对于商场活动，我们最终的目的就是收费，不同的活动有不同的收费策略，比如半价、返现金等。
这些算法的最终目标都是计算出最后需要收多少钱，而输入都是当前收费。

public abstract class Cash {
    public abstract double getResult(int money);
}

public class CashRate extend Cash{
	double rate;
	public CashRate(double rate) {
		this.rate = rate;
	}
	public doutle getREsult(int money) {
		return money * rate;
	}
}

public CashContext extend Cash {
	Cash cash;
	public CashContext(int type) {
		switch(type) {
			case(1) :
			this.cash = new CashRate(0.5);
				break;
			// ....
		}
	}

	public double getResult(int money) {
		return cash.getResult(money);
	}
}

装饰器模式

目的：在原来的处理过程基础之上进行更改，可以增加处理过程却不更改原始代码

对于数据保存的过程，可能包括加密和敏感词过滤，后续也可能有更多的流程，那么利用到装饰器设计模式，就是设计原始类、装饰类、具体装饰类

// 原始类，待装饰
public class Data {
    public String saveData(String s) {
        System.out.println("保存数据");
        return s;
    }
}
// 装饰器：继承自原始类，属性包含原始类，重写原始类的所有方法，调用其包含的原始类，
public class Finery extends Data {
    private Data data;

    public void decorator(Data data) {
        this.data = data;
    }

    @Override
    public String saveData(String s) {
        if (data != null) {
            return data.saveData(s);
        }
        return s;
    }
}
// 具体装饰
public class Encrypt extends Finery {
    @Override
    public String saveData(String s) {
        String pre = super.saveData(s);
        System.out.println("执行加密");
        // ....
        return pre + "  这是加密后的数据";
    }
}
public class Filter extends Finery {
    @Override
    public String saveData(String s) {
        String pre = super.saveData(s);
        System.out.println("执行过滤");
        // ...
        return pre + "  这是过滤后的数据";
    }
}

// 使用
    public static void main(String[] args) {
        Data data = new Data();
        Finery filter = new Filter();
        Finery encrypt = new Encrypt();

        filter.decorator(data);
        encrypt.decorator(filter);

        Data beautifulData = encrypt;

        System.out.println(beautifulData.saveData("原始数据"));
    }
/**
保存数据
执行过滤
执行加密
原始数据  这是过滤后的数据  这是加密后的数据 **/

代理模式

目的：控制对原始对象的访问，包括增强或者弱化

使用场合：

• 远程代理，代理不在同一空间的对象
• 虚拟代理，虚拟需要很大创建开销的对象
• 安全代理，进行访问控制
• 智能指引，对调用过程进行增强，处理额外的任务

售卖机票，真正可以售卖机票的肯定只有机票官方，那么我们通过携程之类的购买其实就是通过他们的代理去官方购买，携程相比于官方提供了更多的功能，更加友好，这很好的体现了代理模式

public interface TicketService {
    void sell();

    void cancel();
}
public class OfficialTicketService implements TicketService {
    public void sell() {
        System.out.println("官方：买了一张票");
    }

    public void cancel() {
        System.out.println("官方：退了一张票");
    }
}

public class XieChengTicketService implements TicketService {
    private OfficialTicketService officialTicketService;

    public XieChengTicketService(OfficialTicketService officialTicketService) {
        this.officialTicketService = officialTicketService;
    }

    public void sell() {
        officialTicketService.sell();
        System.out.println("携程：你买了一张票");
    }

    public void cancel() {
        officialTicketService.cancel();
        System.out.println("携程：你退了一张票");
    }

    public void buyOthers() {
        System.out.println("携程：你还可以买别的东西");
    }
}
public class Main {
    public static void main(String[] args) {
        OfficialTicketService officialTicketService = new OfficialTicketService();
        XieChengTicketService xieChengTicketService = new XieChengTicketService(officialTicketService);

        xieChengTicketService.sell();
        xieChengTicketService.cancel();

        xieChengTicketService.buyOthers();
    }
}
/*
官方：买了一张票
携程：你买了一张票
官方：退了一张票
携程：你退了一张票
携程：你还可以买别的东西 */

工厂模式

简单工厂模式

输入对应的产品代号，产生对应的对象，由一个工厂管理所有不同的对象，不符合开闭原则

public interface Operation {
    int getResult(int a, int b);
}
public class PlusOperation implements Operation {
    public int getResult(int a, int b) {
        return a + b;
    }
}
public class SubOperation implements Operation {
    public int getResult(int a, int b) {
        return a - b;
    }
}
public class SimpleFactory {
    public static Operation createOperation(String type) {
        Operation operation;
        switch (type) {
            case "+":
                operation = new PlusOperation();
                break;
            case "-":
                operation = new SubOperation();
                break;
            default:
                operation = null;
                break;
        }
        return operation;
    }
}

工厂方法模式

每个品类有自己的工厂，符合开闭原则，避免对象内的修改，将增减修改转换到了对象外部。

public interface OperationFactory {
    Operation getOperation();
}
public class PlusOperationFactory implements OperationFactory{
    @Override
    public Operation getOperation() {
        return new PlusOperation();
    }
}
public class SubOperationFactory implements OperationFactory {
    @Override
    public Operation getOperation() {
        return new SubOperation();
    }
}
public class Main {
    public static void main(String[] args) {
        OperationFactory operationFactory = new PlusOperationFactory();
        Operation plusOperation = operationFactory.getOperation();
        System.out.println(plusOperation.getResult(1, 1));
    }
}