1. 中介者模式

中介者模式，用一个中介对象来封装一系列的对象交互。中介者使个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变他们之间的交互

public abstract class Mediator {
    public abstract void sendMessage(String message, Colleague colleague);
}

public abstract class Colleague {
    Mediator mediator;
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
    public abstract void note(String msg);
}

public class ConcreteMediator extends Mediator {
    ConcreteColleague1 concreteColleague1;
    ConcreteColleague2 concreteColleague2;

    public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
        this.concreteColleague1 = concreteColleague1;
    }

    public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
        this.concreteColleague2 = concreteColleague2;
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        if(colleague == concreteColleague1) {
            concreteColleague2.note(message);
        } else {
            concreteColleague1.note(message);

        }
    }
}

public class ConcreteColleague1 extends Colleague {

    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    public void sendMessage(String msg) {
        mediator.sendMessage(msg, this);
    }

    @Override
    public void note(String msg) {
        System.out.println("colleague1 received msg" + msg);
    }
}

public class ConcreteColleague2 extends Colleague {

    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void sendMessage(String msg) {
        mediator.sendMessage(msg, this);
    }

    @Override
    public void note(String msg) {
        System.out.println("colleague2 received msg" + msg);

    }
}

public class MediatorClient {
    public static void main(String[] args) {
        ConcreteMediator concreteMediator = new ConcreteMediator();
        ConcreteColleague1 concreteColleague1 = new ConcreteColleague1(concreteMediator);
        ConcreteColleague2 concreteColleague2 = new ConcreteColleague2(concreteMediator);
        concreteMediator.setConcreteColleague1(concreteColleague1);
        concreteMediator.setConcreteColleague2(concreteColleague2);

        concreteColleague1.sendMessage("你好呀");
    }
}

中介者模式

中介者模式一般用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多子类的场合

2. 享元模式

享元模式，运用共享技术有效地支持大量细粒度的对象

public class User {
    private String userName;
    public User(String userName) {
        this.userName = userName;
    }

    public String getUserName() {
        return userName;
    }
}

public abstract class Web {
    public abstract void Use(User user);
}

public class ConcreteWeb extends Web {
    String webName;
    public ConcreteWeb (String name) {
        this.webName = name;
    }
    @Override
    public void Use(User user) {
        System.out.println("User is "+ user.getUserName());
    }
}

import java.util.HashMap;

public class WebFactory {
    private HashMap<String, Web> hashMap = new HashMap<>();

    public Web getWeb(String name){
        if(hashMap.get(name) == null) {
            hashMap.put(name, new ConcreteWeb(name));
        }
        return hashMap.get(name);
    }
}

public class WebClient {
    public static void main(String[] args) {
        WebFactory webFactory = new WebFactory();
        Web web = webFactory.getWeb("alibaba.com");
        web.Use(new User("马云"));
    }
}

享元模式

享元模式可以避免大量相似类的开销
把不同的参数移动到外部，在方法调用时将它们传进来（用户），相同的参数放在内部（具体网站）

3. 解释器模式

解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子

解释器模式

public class PlayContext {
    private String text;

    public void setText(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }
}

public abstract class Expression {
    public void Intercept(PlayContext context) {
        if(context.getText().length() == 0) {
            return;
        } else {
            String playKey = context.getText().substring(0, 1);
            String playValue = context.getText().substring(2,3);
            execute(playKey, playValue);
            context.setText(context.getText().substring(context.getText().indexOf(" ")+ 1));
        }
    }

    protected abstract void execute(String playKey, String playValue);
}

public class Note extends Expression {
    @Override
    protected void execute(String playKey, String playValue) {
        String note = "";
        switch (playKey) {
            case "C":
                note = "1";
                break;
            case "D":
                note = "2";
                break;
            case "E":
                note = "3";
                break;
            case "F":
                note = "4";
                break;
            case "G":
                note = "5";
                break;
            case "A":
                note = "6";
                break;
            case "B":
                note = "7";
                break;
        }
        System.out.println(note);
    }
}

public class Scale extends Expression {
    @Override
    protected void execute(String playKey, String playValue) {
        String scale = "";
        switch (playValue) {
            case "1":
                scale = "低音";
                break;
            case "2":
                scale = "中音";
                break;
            case "3":
                scale = "高音";
                break;
        }
        System.out.println(scale + " ");
    }
}

public class PlayClient {
    public static void main(String[] args) {
        PlayContext playContext = new PlayContext();
        playContext.setText("O 2 E 0.5 F 3");
        Expression expression = null;
        while(playContext.getText().length() != 0) {
            String str = playContext.getText().substring(0,1);
            if(str.equals("O")) {
                expression = new Scale();
            } else {
                expression = new Note();
            }

            expression.Intercept(playContext);
        }
    }
}