设计模式

设计原则

Java的23种设计模式

创建型模式

它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。

单例模式

指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

懒汉式单例实现

public class LazySingleton {
  private static volatile LazySingleton instance = null;
  
  private LazySingleton() {}   
  
  // 第一次使用的时候再去创建，增加了线程同步
  public static LazySingleton getInstance() {
    if (instance == null) {
      synchronized(LazySingleton.class){
        if(instance == null){
          instance = new LazySingleton();
        }
      }
    }
    return instance;
  }
}

饿汉式单例实现

public class HungrySingleton {
  // 在类加载时就创建好这个对象了
  private static final HungrySingleton instance = new HungrySingleton();
  
  private HungrySingleton() {}
  
  public static HungrySingleton getInstance() {
    return instance;
  }
}

静态内部类实现

// 利用了classloader机制来保证初始化 instance 时只有一个线程，线程安全
public class SingletonInStaticInnerClass {
  // 静态内部类
  private static class InnerClass {
    private final static SingletonInStaticInnerClass INSTANCE = new SingletonInStaticInnerClass();
  }
  
  private SingletonDemoInStaticInnerClass() {}
  
  // 公关获取实例方法（线程安全，延迟加载）
  public static SingletonDemoInStaticInnerClass getInstance() {
    return InnerClass.INSTANCE;
  }
}

工厂模式

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

简单工厂模式

interface Car {
  void drive();
}

class ACar implements Car {
  @Override
  void drive(){
  }
}

class BCar implements Car {
  @Override
  void drive(){
  }
}

class CarFactory {
  // 通过名字就能获取一个对应的对象
  public static Car makeCar(String carName) {
    switch(carName) {
      "ACar": return new ACar(); break;
      "BCar": return new BCar(); break;
      default: return null;
    }
  }
}

工厂方法模式

interface Car {
  void drive();
}

class ACar implements Car {
  @Override
  void drive(){
  }
}

class BCar implements Car {
  @Override
  void drive(){
  }
}

interface CarFactory {
  Car makeCar();
}

class ACarFactory implements CarFactory {
  @Override
  Car makeCar() {
    return ACar();
  }
}

class BCarFactory implements CarFactory {
  @Override
  Car makeCar() {
    return BCar();
  }
}

// 使用的时候大概这样用
class Test {
  void test() {
    CarFactory carFactory = new ACarFactory();
    Car car = carFactory.makeCar();
    car.drive();
  }
}

抽象工厂模式

interface Screen {
  void output();
}

class HpScreen implements Screen {
  @Override
  void output(){
  }
}

class MiScreen implements Screen {
  @Override
  void output(){
  }
}

interface Keyboard {
  void input();
}

class HpKeyboard implements Keyboard {
  @Override
  void input() {
  }
}

class MiKeyboard implements Keyboard {
  @Override
  void input() {
  }
}

interface CompterPartFactory {
  Screen makeScreen();
  
  Keyboard makeKeyboard();
}

// 为了创建一个可以生成同品牌不同类型的产品的工厂
class HpCompterPartFactory implements CompterPartFactory {
  @Override
  Screen makeScreen() {
    return HpScreen();
  }
  
  @Override
  Keyboard makeKeyboard() {
    return HpKeyboard();
  }
}

class MiCompterPartFactory implements CompterPartFactory {
  @Override
  Screen makeScreen() {
    return MiScreen();
  }
  
  @Override
  Keyboard makeKeyboard() {
    return MiKeyboard();
  }
}

建造者模式

指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

public class NewComputer {
  
  private String cpu;
  private String screen;
  private String memory;
  private String mainboard;
  
  private NewComputer(Builder builder) {
    cpu = builder.cpu;
    screen = builder.screen;
    memory = builder.memory;
    mainboard = builder.mainboard;
  }
  
  public static final class Builder {
    
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
      
    public Builder cpu(String cpu) {
      this.cpu = cpu;
      return this;
    }
    
    public Builder screen(String screen) {
      this.screen = screen;
      return this;
    }
    
    public Builder memory(String memory) {
      this.memory = memory;
      return this;
    }
    
    public Builder mainboard(String mainboard) {
      this.mainboard = mainboard;
      return this;
    }
    
    public NewComputer build() {
      return new NewComputer(this);
    }
  }
}

原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。也就是我们说的深克隆和浅克隆这些。

结构型模式

结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。

代理模式

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。（为了控制被代理对象，以防止直接调用被代理对象的其他方法）。

静态代理

interface Request {
  void request();
}

class GetInfoRequest implements Request {
  @Override
  void request(){
  }
}

class ProxyRequest implements Request {
  
  Request realRequest;
  
  ProxyRequest(Request realRequest){
    this.realRequest = realRequest;
  }
  
  @Override
  void request(){
    // doSomething before
    realRequest.request();
    // doSomething after
  }
}

class Test {
  void test() {
    Request realRequest = new GetInfoRequest();
    Request proxyRequest = new ProxyRequest(realRequest);
    proxyRequest.request();
  }
}

动态代理

interface Request {
  void request();
}

class GetInfoRequest implements Request {
  @Override
  public void request() {
  }
}

class ProxyFactory {
  private Object target;
  
  public ProxyFactory(Object target) {
    this.target = target;
  }
  
  public Object getProxyInstance() {
    return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                                  target.getClass().getInterfaces(),
                                  new InvocationHandler() {
                                    @Override
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                 // doSomething before
                 Object objectReturnVal = method.invoke(target, args);
                 // doSomething after
                 return objectReturnVal;
             }
         });
    }
}

class Test {
  void test(){
    Request realRequest = new GetInfoRequest();
    ProxyFactory proxyFactory = new ProxyFactory(realRequest);
    Request proxyRequest = (Request) proxyFactory.getProxyInstance();
    proxyRequest.request();
  }
}

适配器模式

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作

类适配器模式

class LinuxUtil {
    void handleElectricOnLinux() {
        // 处理Linux电量相关
    }
}

interface IAdapter {
    void handleElectric();
}

class AndroidAdapter extends LinuxUtil implements IAdapter {
    @Override
    public void handleElectric() {
        // 调用，增强，重写这个能力
        super.handleElectricOnLinux();
    }
}

class AndroidUtil {
    void handleElectricOnAndroid(IAdapter adapter) {
        adapter.handleElectric();
    }
}

class Test {
    void test() {
        AndroidUtil androidUtil = new AndroidUtil();
        AndroidAdapter androidAdapter = new AndroidAdapter();
        androidUtil.handleElectricOnAndroid(androidAdapter);
    }
}

对象适配器模式

// 将Model适配到ListView上面去
class ListViewModel {
  public List<Object> datas = new ArrayList<>();
}

interface IAdapter {
  View getViewByPosition(int position);
  int getViewCount();
}

class ListAdapter implements IAdapter {
  
  public ListViewModel listViewModel;
  
  public ListAdapter(ListViewModel listViewModel) {
    this.listViewModel = listViewModel;
  }
  
  private View buildView(Object obj) {
    return null;
  }

  @Override
  public View getViewByPosition(int position) {
    return buildView(listViewModel.datas.get(position));
  }

  @Override
  public int getViewCount() {
    return listViewModel.datas.size();
  }
}

class ListView {
  public List<View> getChildren(IAdapter iAdapter) {
    List<View> views = new ArrayList<>();
    for (int position = 0; position < iAdapter.getViewCount(); position++) {
      views.add(iAdapter.getViewByPosition(position));
    }
    return views;
  }
}

class Test {
  void test(){
    ListViewModel listViewModel = new ListViewModel();
    ListAdapter listAdapter = new ListAdapter(listViewModel);
    ListView listView = new ListView();
    listView.getChildren(listAdapter);
  }
}

桥接模式

将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

interface Brand {
  String getBrandName();
  void call();// 感觉关键还是在这个方法上
}

class MiBrand implements Brand {

  @Override
  public String getBrandName() {
    return "Mi";
  }

  @Override
  public void call() {
  }
}

class HwBrand implements Brand {

  @Override
  public String getBrandName() {
    return "Hw";
  }

  @Override
  public void call() {
  }
}

class BasePhone {
  Brand brand;

  public BasePhone(Brand brand) {
    this.brand = brand;
  }

  protected void call() {
    this.brand.call();
    
  }
}

class FoldedPhone extends BasePhone {

  public FoldedPhone(Brand brand) {
    super(brand);
  }

  @Override
  protected void call() {
    // do Something
    super.call();
  }
}

class Test {
  void test() {
    FoldedPhone foldedPhone = new FoldedPhone(new MiBrand());
    foldedPhone.call();
  }
}

装饰器模式

指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
注意：装饰器模式在实现上和代理模式有一定相似之处，但是目的不同。代理模式是用于控制使用对象，而装饰器模式是为了扩充能力。

interface FriedChicken {
  void makeFriedChicken();
}

class KFC extends FriedChicken {
  @Override
  public void makeFriedChicken() {
  
  }
}

class McDonald extends FriedChicken {
  @Override
  public void makeFriedChicken() {
  
  }
}

class FriedChickenCheckDecorator implements FriedChicken {
  
  // 内部维护一个炸鸡类
  private FriedChicken friedChicken;
    
  // 通过构造方法把需要装饰的炸鸡类传进来
  public FriedChickenDecorator(FriedChicken friedChicken) {
    this.friedChicken = friedChicken;
  }
  
  @Override
  public void makeFriedChicken() {
    this.friedChicken.makeFriedChicken();
    // do check
  }
}

class Test {
  void test() {
    FriedChicken kfc = new KFC();
    FriedChicken kfcWithCheck = new FriedChickenCheckDecorator(kfc);
    kfc.makeFriedChicken();
  }
}

外观模式

外观（Facade）模式又叫作门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。

abstract class AbstractWorker {
  
  String name;
  
  AbstractWorker(String name) {
    this.name = name;
  }
  
  abstract void doWork();
}

class ProjectManager extends AbstractWorker {
  
  ProjectManager() {
    super("项目经理");
  }

  @Override
  void doWork() {
    // 制定项目计划
  }
}

class DevelopmentEngineer extends AbstractWorker {

  DevelopmentEngineer() {
    super("码农");
  }

  @Override
  void doWork() {
    // 编码
  }
}

class QualityAssurance extends AbstractWorker {

  QualityAssurance() {
    super("测试狗");
  }

  @Override
  void doWork() {
    // 测试
  }
}

// 外观类
class Project {

  private AbstractWorker projectManager;
  private AbstractWorker developmentEngineer;
  private AbstractWorker qualityAssurance;

  public Project(AbstractWorker projectManager, 
                 AbstractWorker developmentEngineer, 
                 AbstractWorker qualityAssurance) {
    this.projectManager = projectManager;
    this.developmentEngineer = developmentEngineer;
    this.qualityAssurance = qualityAssurance;
  }
  
  public void develop() {
    projectManager.doWork();
    developmentEngineer.doWork();
    qualityAssurance.doWork();
  }
  
}

享元模式

享元模式的定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

//外部状态，非享元角色
public class User {
  
  private String name;
  
  public User(String name) {
    this.name=name;
  }
  
  public String getName() {
    return name;
  }
  
}

public abstract class WebSite {
  abstract void use(User user);
}

// 具体的网站类型
public class ConcreateWebSite extends WebSite{
  // 共享的部分 内部状态
  public static String type;
  
  // 构造
  public ConcreateWebSite(String type){
    this.type=type;
  }
  
  @Override
  void use(User user) {
    System.out.println(user.getName()+"正在使用,"+"发布形式是"+type);
  }
}

//工厂类
public class WebSiteFactory {

  // 集合，充当池作用
  HashMap<String,ConcreateWebSite> pool=new HashMap<>();

  // 根据网站类型 返回网站 如果没有则创建
  public WebSite getWebSiteCategory(String type){
    if (!pool.containsKey(type)){
      pool.put(type,new ConcreateWebSite(type));
    }
    // 返回的是子类 需要变成父类
    return (WebSite) pool.get(type);
  }

  // 查看网站的个数
  public int getSite(){
    return pool.size();
  }
}

class Test {
  void test() {
    // 创建工厂类
    WebSiteFactory factory=new WebSiteFactory();

    // 客户需要以网站形式发布
    WebSite webSite1 = factory.getWebSiteCategory("网站");
    webSite1.use(new User("小明"));

    // 以博客的形式发布
    WebSite webSite2 = factory.getWebSiteCategory("博客");
    webSite2.use(new User("小李"));

    WebSite webSite3 = factory.getWebSiteCategory("博客");
    webSite3.use(new User("小艺"));
  }
}

组合模式

组合模式的定义是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户对单个对象和组合对象具有一致的访问性。

//抽象构件
interface Component {
  public void add(Component c);
  public void remove(Component c);
  public Component getChild(int i);
  public void operation();
}

//树叶构件
class Leaf implements Component {
  private String name;
  public Leaf(String name) {
    this.name = name;
  }
  public void add(Component c) {
  }
  public void remove(Component c) {
  }
  public Component getChild(int i) {
    return null;
  }
  public void operation() {
    System.out.println("树叶" + name + "：被访问！");
  }
}

//树枝构件
class Composite implements Component {
  private ArrayList<Component> children = new ArrayList<Component>();
  public void add(Component c) {
    children.add(c);
  }
  public void remove(Component c) {
    children.remove(c);
  }
  public Component getChild(int i) {
    return children.get(i);
  }
  public void operation() {
    for (Object obj : children) {
      ((Component) obj).operation();
    }
  }
}

行为型模式

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

模版方法模式

模板方法模式的定义如下：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

//抽象类
abstract class AbstractClass {
  //模板方法
  public void TemplateMethod() {
    abstractMethod1();
    abstractMethod2();
    SpecificMethod();
  }
  
  //具体方法
  public void SpecificMethod() {
    System.out.println("抽象类中的具体方法被调用...");
  }
  //抽象方法1
  public abstract void abstractMethod1();
  //抽象方法2
  public abstract void abstractMethod2();
}
//具体子类
class ConcreteClass extends AbstractClass {
  public void abstractMethod1() {
    System.out.println("抽象方法1的实现被调用...");
  }
  public void abstractMethod2() {
    System.out.println("抽象方法2的实现被调用...");
  }
}

策略模式

策略模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。

//抽象策略类
interface Strategy {
  public void strategyMethod();    //策略方法
}

//具体策略类A
class ConcreteStrategyA implements Strategy {
  public void strategyMethod() {
    System.out.println("具体策略A的策略方法被访问！");
  }
}
//具体策略类B
class ConcreteStrategyB implements Strategy {
  public void strategyMethod() {
    System.out.println("具体策略B的策略方法被访问！");
  }
}
//环境类
class Context {
  private Strategy strategy;
  public Strategy getStrategy() {
    return strategy;
  }
  public void setStrategy(Strategy strategy) {
    this.strategy = strategy;
  }
  public void strategyMethod() {
    strategy.strategyMethod();
  }
}

class Test {
  void test() {
    Context c = new Context();
    Strategy s = new ConcreteStrategyA();
    c.setStrategy(s);
    c.strategyMethod();
    s = new ConcreteStrategyB();
    c.setStrategy(s);
    c.strategyMethod();
  }
}

命令模式

命令模式的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

//调用者
class Invoker {
  private Command command;
  public Invoker(Command command) {
    this.command = command;
  }
  public void setCommand(Command command) {
    this.command = command;
  }
  public void call() {
    System.out.println("调用者执行命令command...");
    command.execute();
  }
}
//抽象命令
interface Command {
  public abstract void execute();
}
//具体命令
class ConcreteCommand implements Command {
  private Receiver receiver;
  ConcreteCommand() {
    receiver = new Receiver();
  }
  public void execute() {
    receiver.action();
  }
}
//接收者
class Receiver {
  public void action() {
    System.out.println("接收者的action()方法被调用...");
  }
}

class Test {
  void test() {
    Command cmd = new ConcreteCommand();
    Invoker ir = new Invoker(cmd);
    System.out.println("客户访问调用者的call()方法...");
    ir.call();
  }
}

责任链模式

责任链模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

//抽象处理者角色
abstract class Handler {
  private Handler next;
  public void setNext(Handler next) {
    this.next = next;
  }
  public Handler getNext() {
    return next;
  }
  //处理请求的方法
  public abstract void handleRequest(String request);
}

//具体处理者角色1
class ConcreteHandler1 extends Handler {
  public void handleRequest(String request) {
    if (request.equals("one")) {
      System.out.println("具体处理者1负责处理该请求！");
    } else {
      if (getNext() != null) {
        getNext().handleRequest(request);
      } else {
        System.out.println("没有人处理该请求！");
      }
    }
  }
}

//具体处理者角色2
class ConcreteHandler2 extends Handler {
  public void handleRequest(String request) {
    if (request.equals("two")) {
      System.out.println("具体处理者2负责处理该请求！");
    } else {
      if (getNext() != null) {
        getNext().handleRequest(request);
      } else {
        System.out.println("没有人处理该请求！");
      }
    }
  }
}

状态模式

状态模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

// 抽象状态类
abstract class OrderState {
    protected OrderContext context;

    public void setContext(OrderContext context) {
        this.context = context;
    }

    public abstract void confirm();

    public abstract void modify();

    public abstract void ship();

    public abstract void complete();
}

// 待处理状态类
class PendingState extends OrderState {
    public void confirm() {
        System.out.println("Order confirmed");
        context.setState(new ApprovedState());
    }

    public void modify() {
        System.out.println("Order modified");
    }

    public void ship() {
        System.out.println("Cannot ship an unapproved order");
    }

    public void complete() {
        System.out.println("Cannot complete an unshipped order");
    }
}

// 已审核状态类
class ApprovedState extends OrderState {
    public void confirm() {
        System.out.println("Order already confirmed");
    }

    public void modify() {
        System.out.println("Order modified");
        context.setState(new PendingState());
    }

    public void ship() {
        System.out.println("Order shipped");
        context.setState(new ShippedState());
    }

    public void complete() {
        System.out.println("Cannot complete an unshipped order");
    }
}

// 已发货状态类
class ShippedState extends OrderState {
    public void confirm() {
        System.out.println("Order already confirmed");
    }

    public void modify() {
        System.out.println("Cannot modify a shipped order");
    }

    public void ship() {
        System.out.println("Order already shipped");
    }

    public void complete() {
        System.out.println("Order completed");
        context.setState(new CompletedState());
    }
}

// 已完成状态类
class CompletedState extends OrderState {
    public void confirm() {
        System.out.println("Order already confirmed");
    }

    public void modify() {
        System.out.println("Cannot modify a completed order");
    }

    public void ship() {
        System.out.println("Cannot ship a completed order");
    }

    public void complete() {
        System.out.println("Order already completed");
    }
}

// 上下文类
class OrderContext {
    private OrderState state;

    public OrderContext() {
        state = new PendingState();
        state.setContext(this);
    }

    public void setState(OrderState state) {
        this.state = state;
        this.state.setContext(this);
    }

    public void confirm() {
        state.confirm();
    }

    public void modify() {
        state.modify();
    }

    public void ship() {
        state.ship();
    }

    public void complete() {
        state.complete();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        OrderContext context = new OrderContext();
        context.confirm();
        context.modify();
        context.confirm();
        context.ship();
        context.complete();
    }
}

观察者模式

观察者模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

//抽象目标
abstract class Subject {
  protected List<Observer> observers = new ArrayList<Observer>();
  //增加观察者方法
  public void add(Observer observer) {
    observers.add(observer);
  }
  //删除观察者方法
  public void remove(Observer observer) {
    observers.remove(observer);
  }
  public abstract void notifyObserver(); //通知观察者方法
}
//具体目标
class ConcreteSubject extends Subject {
  public void notifyObserver() {
    System.out.println("具体目标发生改变...");
    System.out.println("--------------");
    for (Object obs : observers) {
      ((Observer) obs).response();
    }
  }
}
//抽象观察者
interface Observer {
  void response(); //反应
}
//具体观察者1
class ConcreteObserver1 implements Observer {
  public void response() {
    System.out.println("具体观察者1作出反应！");
  }
}
//具体观察者2
class ConcreteObserver2 implements Observer {
  public void response() {
    System.out.println("具体观察者2作出反应！");
  }
}

中介者模式

中介者模式的定义：定义一个中介对象来封装一系列对象之间的交互，它可以使得多个对象之间的交互变得更加灵活、简单和可扩展。中介者模式将多个对象之间的交互转移给一个中介者对象来处理，从而将对象之间的耦合度降低到最低。
注意：观察者模式是一对多的关系，而中介者模式是多对多的关系。

// 抽象中介者类
abstract class Mediator {
    public abstract void sendMessage(User user, String message);
}

// 具体中介者类
class ChatRoom extends Mediator {
    public void sendMessage(User user, String message) {
        System.out.println(user.getName() + " sends message: " + message);
        for (User u : users) {
            if (u != user) {
                u.receiveMessage(message);
            }
        }
    }
}

// 抽象用户类
abstract class User {
    private String name;
    private Mediator mediator;

    public User(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

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

    public abstract void receiveMessage(String message);
}

// 具体用户类
class ConcreteUser extends User {
    public ConcreteUser(String name, Mediator mediator) {
        super(name, mediator);
    }

    public void receiveMessage(String message) {
        System.out.println(getName() + " receives message: " + message);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Mediator mediator = new ChatRoom();

        User user1 = new ConcreteUser("User1", mediator);
        User user2 = new ConcreteUser("User2", mediator);
        User user3 = new ConcreteUser("User3", mediator);

        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi, User1!");
        user3.sendMessage("Hey, guys!");
    }
}

迭代器模式

迭代器模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

// 抽象聚合
interface Aggregate {
  public void add(Object obj);
  public void remove(Object obj);
  public Iterator getIterator();
}
// 具体聚合
class ConcreteAggregate implements Aggregate {
  private List<Object> list = new ArrayList<Object>();
  public void add(Object obj) {
    list.add(obj);
  }
  public void remove(Object obj) {
    list.remove(obj);
  }
  public Iterator getIterator() {
    return (new ConcreteIterator(list));
  }
}
// 抽象迭代器
interface Iterator {
  Object first();
  Object next();
  boolean hasNext();
}
// 具体迭代器
class ConcreteIterator implements Iterator {
  private List<Object> list = null;
  private int index = -1;
  public ConcreteIterator(List<Object> list) {
    this.list = list;
  }
  public boolean hasNext() {
    if (index < list.size() - 1) {
      return true;
    } else {
      return false;
    }
  }
  public Object first() {
    index = 0;
    Object obj = list.get(index);
    return obj;
  }
  public Object next() {
    Object obj = null;
    if (this.hasNext()) {
      obj = list.get(++index);
    }
    return obj;
  }
}

备忘录模式

备忘录模式的定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。

//备忘录
class Memento {
  private String state;
  public Memento(String state) {
    this.state = state;
  }
  public void setState(String state) {
    this.state = state;
  }
  public String getState() {
    return state;
  }
}
//发起人
class Originator {
  private String state;
  public void setState(String state) {
    this.state = state;
  }
  public String getState() {
    return state;
  }
  public Memento createMemento() {
    return new Memento(state);
  }
  public void restoreMemento(Memento m) {
    this.setState(m.getState());
  }
}
//管理者
class Caretaker {
  private Memento memento;
  public void setMemento(Memento m) {
    memento = m;
  }
  public Memento getMemento() {
    return memento;
  }
}

class Test {
  void test() {
    Originator or = new Originator();
    Caretaker cr = new Caretaker();
    or.setState("S0");
    System.out.println("初始状态:" + or.getState());
    cr.setMemento(or.createMemento()); //保存状态
    or.setState("S1");
    System.out.println("新的状态:" + or.getState());
    or.restoreMemento(cr.getMemento()); //恢复状态
    System.out.println("恢复状态:" + or.getState());
  }
}

访问者模式

访问者模式的定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。

// 访问者接口
interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

// 具体访问者A
class ConcreteVisitorA implements Visitor {
    public void visit(ConcreteElementA elementA) {
        System.out.println("Visitor A visits Element A");
    }

    public void visit(ConcreteElementB elementB) {
        System.out.println("Visitor A visits Element B");
    }
}

// 具体访问者B
class ConcreteVisitorB implements Visitor {
    public void visit(ConcreteElementA elementA) {
        System.out.println("Visitor B visits Element A");
    }

    public void visit(ConcreteElementB elementB) {
        System.out.println("Visitor B visits Element B");
    }
}

// 元素接口
interface Element {
    void accept(Visitor visitor);
}

// 具体元素A
class ConcreteElementA implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public void operationA() {
        System.out.println("Element A operation");
    }
}

// 具体元素B
class ConcreteElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public void operationB() {
        System.out.println("Element B operation");
    }
}

// 对象结构类
class ObjectStructure {
    private List<Element> elements = new ArrayList<>();

    public void attach(Element element) {
        elements.add(element);
    }

    public void detach(Element element) {
        elements.remove(element);
    }

    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();

        ConcreteElementA elementA = new ConcreteElementA();
        ConcreteElementB elementB = new ConcreteElementB();

        objectStructure.attach(elementA);
        objectStructure.attach(elementB);

        Visitor visitorA = new ConcreteVisitorA();
        Visitor visitorB = new ConcreteVisitorB();

        elementA.accept(visitorA);
        elementA.accept(visitorB);

        elementB.accept(visitorA);
        elementB.accept(visitorB);
    }
}

解释器模式

解释器模式的定义：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。