大话设计模式总结

1.简单工厂模式

内容：建立一个工厂类，对实现了同一接口的一些类进行实例的创建
优点：实现多态

说明：简单工厂类可以创建四种实例（加法、减法、乘法和除法），返回运算类（四种类的基类）的引用，这样调用GetResult()方法时就能自动知道调用哪个类重写的方法。

样例：

• 简单工厂类

package simplefactory;
 
public class OperationFactory {
 
    public static Operation createOperate(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new RuntimeException("不支持运算!");
        }
        return operation;
    }
 
}

• 其他类

package simplefactory;
 
// Operation运算类
public abstract class Operation {
 
    public double numberA = 0;
    public double numberB = 0;
 
    public abstract double getResult();
 
}
 
//加法类
class OperationAdd extends Operation {
 
    @Override
    public double getResult() {
        return numberA + numberB;
    }
 
}
 
//减法类
class OperationSub extends Operation {
 
    @Override
    public double getResult() {
        return numberA - numberB;
    }
 
}
 
//乘法类
class OperationMul extends Operation {
 
    @Override
    public double getResult() {
        return numberA * numberB;
    }
 
}
 
//除法类
class OperationDiv extends Operation {
 
    @Override
    public double getResult() {
        if (numberB == 0) {
            throw new RuntimeException("除数不能为0!");
        }
        return numberA / numberB;
    }
 
}

• 调用

package simplefactory;
 
public class Calculator {
 
    public static void main(String[] args) {
        Operation operation;
        operation = OperationFactory.createOperate("+");
        operation.numberA = 20;
        operation.numberB = 10;
        double result = operation.getResult();
        System.out.println(result);
    }
 
}

2.策略模式

内容：创建一个能根据传入的参数类型从而具备不同行为的方法

说明：Context类里维护一个引用，会调用Strategy类里的方法，一般在外部实例化，也可以结合工厂模式在Context里实例化。

样例：（结合了简单工厂模式）

• Context类

package strategy;
 
//Cash上下文
public class CashContext {
 
    CashSuper cs = null;
 
    public CashContext(String type) {
        switch (type) {
            case "正常收费":
                CashNormal c0 = new CashNormal();
                cs = c0;
                break;
            case "满300返100":
                CashReturn c1 = new CashReturn("300", "100");
                cs = c1;
                break;
            case "打8折":
                CashRebate c2 = new CashRebate("0.8");
                cs = c2;
                break;
        }
    }
 
    public double getResult(double money) {
        return cs.acceptCash(money);
    }
 
}

• Strategy类

package strategy;
 
//现金收费抽象类
public abstract class CashSuper {
     public abstract double acceptCash(double money);
}

package strategy;
 
//正常收费子类
public class CashNormal extends CashSuper {
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

package strategy;
 
//打折收费子类
public class CashRebate extends CashSuper {
    private double moneyRebate = 1.0;
    public CashRebate(String moneyRebate) {
        this.moneyRebate = Double.parseDouble(moneyRebate);
    }
 
    @Override
    public double acceptCash(double money) {
        return money * moneyRebate;
    }
}

package strategy;
 
//返利收费子类
public class CashReturn extends CashSuper {
 
    // 满多少
    private double moneyCondition = 1.0;
    // 返多少
    private double moneyReturn = 1.0;
 
    public CashReturn(String moneyCondition, String moneyReturn) {
        this.moneyCondition = Double.parseDouble(moneyCondition);
        this.moneyReturn = Double.parseDouble(moneyReturn);
    }
 
    @Override
    public double acceptCash(double money) {
        double result = money;
        if (money >= moneyCondition) {
            result = money - Math.floor(money / moneyCondition) * moneyReturn;
        }
        return result;
    }
 
}

• 调用

package strategy;
 
//客户端main方法
public class CashClient {
 
    public static void main(String[] args) {
        CashContext context = new CashContext("正常收费");
        double money0 = context.getResult(300);
        System.out.println("正常收费: " + money0);
 
        context = new CashContext("打8折");
        double money1 = context.getResult(300);
        System.out.println("打8折: " + money1);
 
        context = new CashContext("满300返100");
        double money2 = context.getResult(300);
        System.out.println("满300返100: " + money2);
    }
 
}

3.单一职责原则

4.开放封闭原则

5.依赖倒转原则

6.装饰模式

7.代理模式

8.工厂方法模式

内容：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

说明：左上那个是接口，和简单工厂模式相比，把具体选择创建哪种对象实例的部分从工厂类里提出来交给客户端了，好处是添加新的工厂方法只需要新定义一个满足接口的工厂类即可。
样例：

• Product

//雷锋类
public class LeiFeng {
 
    public void sweep() {
        System.out.println("扫地");
    }
 
    public void wash() {
        System.out.println("洗衣");
    }
 
    public void buyRice() {
        System.out.println("买米");
    }
 
}

• ConcreteProduct

//大学生类
public class Undergraduate extends LeiFeng {
 
    @Override
    public void sweep() {
        System.out.println("学雷锋的大学生帮忙扫地");
    }
 
    @Override
    public void wash() {
        System.out.println("学雷锋的大学生帮忙洗衣");
    }
 
    @Override
    public void buyRice() {
        System.out.println("学雷锋的大学生帮忙买米");
    }
 
}

//社区志愿者类
public class Volunteer extends LeiFeng {
 
    @Override
    public void sweep() {
        System.out.println("社区志愿者帮忙扫地");
    }
 
    @Override
    public void wash() {
        System.out.println("社区志愿者帮忙洗衣");
    }
 
    @Override
    public void buyRice() {
        System.out.println("社区志愿者帮忙买米");
    }
 
}

• Creator

//雷锋工厂
public interface IFactory {
 
    LeiFeng createLeiFeng();
 
}

• ConcreteCreator

// 学雷锋的大学生工厂
class UndergraduateFactory implements IFactory {
 
    @Override
    public LeiFeng createLeiFeng() {
        return new Undergraduate();
    }
    
}
 
//社区志愿者工厂
class VolunteerFactory implements IFactory {
 
    @Override
    public LeiFeng createLeiFeng() {
        return new Volunteer();
    }
    
}

• 调用

public class Client {
 
    public static void main(String[] args) {
        // 大学生
        IFactory undergraduateFactory = new UndergraduateFactory();
        LeiFeng student = undergraduateFactory.createLeiFeng();
        student.sweep();
        student.wash();
        student.buyRice();
        // 志愿者
        IFactory volunteerFactory = new VolunteerFactory();
        LeiFeng volunteer = volunteerFactory.createLeiFeng();
        volunteer.sweep();
        volunteer.wash();
        volunteer.buyRice();
    }
 
}

9.原型模式

10.模板方法模式

内容：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
优点：子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤；通过把不变行为搬移到超类，去除子类中的重复代码。

样例：

• 基类

abstract class AbstractClass{
	//一些抽象方法，放到子类去实现
	public abstract void operation1();
	public abstract void operation2();
			
	//模板方法，给出了逻辑骨架，逻辑的组成是一些相应的抽象方法
	public void templateMethod(){
		operation1();
		operation2();
		System.out.println("ok");
	}
}

• 子类

class SonA extends AbstractClass{
	@override
	public void operation1(){
		//具体实现方法
	}
			
	public void operation2(){
		//具体实现方法
	}
}//相似的可以写出SonB等其他子类

• 调用

static void main(String[] args){
	AbstractClass test;
	test=new SonA();
	test.templateMethod();
}

11.迪米特法则

12.外观模式

13.建造者模式

14.观察者模式

15.抽象工厂模式

16.状态模式

17.适配器模式

内容：将一个类的接口转换成另一个类的接口
优点：解决接口不兼容问题

样例：

• Target

class Target{
	public void request(){
		System.out.println("普通请求");
	}
}

• Adapter

class Adapter{
	Adaptee adaptee=new Adaptee();
	@Override
	public void request(){
		adaptee.specificRequest();
	}
}

• Adaptee

class Adaptee{
	public void specificRequest(){
		System.out.println("特殊请求");
	}
}

• 调用

static void main(String[] args){
	Target target=new Target();
	target.request();
}

18.备忘录模式

19.组合模式

20.迭代器模式

内容：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

样例：

• Aggregate

//聚集抽象类
public abstract class Aggregate {
    public abstract Iterator createIterator();
}

• ConcreteAggregate

import java.util.ArrayList;
import java.util.List;
 
//具体聚集类

public class ConcreteAggregate extends Aggregate {
 
    private List<Object> items = new ArrayList<>();
 
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
 
    public int count() {
        return items.size();
    }
 
    public Object get(int index) {
        return items.get(index);
    }
 
    public void set(int index, Object object) {
        items.add(index, object);
    }
 
}

• Iterator

// 抽象类

public abstract class Iterator {
 
    public abstract Object first();
    public abstract Object next();
    public abstract boolean isDone();
    public abstract Object currentItem();
 
}

• ConcreteIterator

// 具体迭代器
public class ConcreteIterator extends Iterator {
 
    private ConcreteAggregate aggregate;
    private int current = 0;
 
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }
 
    @Override
    public Object first() {
        return aggregate.get(0);
    }
 
    @Override
    public Object next() {
        Object ret = null;
        current++;
        if (current < aggregate.count()) {
            ret = aggregate.get(current);
        }
        return ret;
    }
 
    @Override
    public boolean isDone() {
        return current >= aggregate.count() ? true : false;
    }
 
    @Override
    public Object currentItem() {
        return aggregate.get(current);
    }
 
}

• 调用

//客户端main方法

public class Client {
 
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
 
        aggregate.set(0, "大鸟");
        aggregate.set(1, "小菜");
        aggregate.set(2, "行李");
        aggregate.set(3, "老外");
        aggregate.set(4, "公交内部员工");
        aggregate.set(5, "小偷");
 
        Iterator iterator = new ConcreteIterator(aggregate);
        Object item = iterator.first();
        while (!iterator.isDone()) {
            System.out.println(iterator.currentItem() + " 请买车票！");
            iterator.next();
        }
    }
 
}

21.单例模式

22.桥接模式

23.命令模式

24.职责链模式

25.中介者模式

26.享元模式

27.解释器模式

28.访问者模式