23 种设计模式

设计原则

单一职责原则：就一个类而言，有且只有一个原因引起类的变化,
开放-封闭原则：扩展开放，修改关闭
里氏替换原则：基类出现的地方，子类一定可以出现
依赖倒置原则：依赖于抽象而不依赖于实现
接口分离原则：依赖于抽象而不依赖于具体
共同重用原则：重用包中的一个类，就要重用包中的所有类
共同封闭原则：一个变化对一个包产生影响，则对该包中所有类有影响，但不对其他包影响

1+4 ，1+7，2+9

总结

创建型模式

用于创建对象的模式

创建型类模式

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

创建型对象模式

抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
构建器/生成器模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

结构型模式

主要处理类和对象的组合问题，让类或对象形成更大的结构提供相应的指导

结构型类模式

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

结构型对象模式

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
桥接模式（Bridge）：将抽象部分与其实现部分分离，使它们可以独立地变化。
组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
装饰模式（Decorator）：对对象进行包装，动态地给一个对象添加一些额外的职责。（给对象添加行为）
外观模式（Facade）：为子系统中的一组接口提供一个一致的界面。定义了一个高层接口，这个接口使得这一子系统更加容易使用。（简化接口）
享元模式（Flyweight）：运用共享技术有效地支持打两细粒度的对象。（对象共享）
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。

行为型模式

主要描述类或对象交互的情况以及职责的分配问题。

行为型类模式

模板方法（Template Method）：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
解释器模式（Interpreter）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。（用来表示解释语言）

行为型对象模式

责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
命令模式（Command）：将请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。使各对象不需要显式地相互引用，从而使耦合松散，而且可以独立地改变它们之间的交互。（中介对象封装对象交互）
备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可以将对象恢复到原先保存的状态。
观察者模式（Observer）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都能得到通知，并被自动更新。（通知所有依赖对象）
状态模式（State）：允许一个对象在其内部状态改变时改变它的行为。
策略模式（Strategy）：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。（封装算法）
访问者模式（Visitor）：标识一个作用于某对象结构中的各元素的操作，它允许在不改变各元素的类的前提下定义作用于这些元素的新操作。

1、创建型模式

功能：用于创建对象的模式

1.0 简单工厂模式

简单工厂模式是创建型设计模式，但不是23种设计模式之一。

定义：定义一个工厂类，它可以根据参数的不同，返回不同类的实例，被创建的实例通常有个共同父类。

在简单工厂模式中用于被创建实例的方法通常是静态方法( static )，因此简单工厂模式又叫静态工厂方法 ( Static Factory Method )

/**
 * @author : lyj
 * @Timer : 2022/3/31
 * @Description :
 */
public class SimpleFactory {
    public static void main(String[] args) {
        Factory.createProduct("A").info();
        Factory.createProduct("B").info();
        Factory.createProduct("C").info();
    }

}

abstract class Product{
    public abstract void info();
}

class Factory{
    public static Product createProduct(String type){
        Product product = null;
        if (type.equals("A")){
            product = new ProductA();
        }else if (type.equals("B")){
            product = new ProductB();
        }else {
            System.out.println("没有该类型："+type+" 的产品");
        }
        return product;
    }
}

class ProductA extends Product{

    @Override
    public void info() {
        System.out.println("我是产品: A");
    }
}

class ProductB extends Product{

    @Override
    public void info() {
        System.out.println("我是产品: B");
    }
}

缺点：违背了开放 - 封闭设计原则

1.1 工厂方法模式 Factory Method

工厂方法模式（Factory Method）

1）意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。

2）代码

/**
 * @author : lyj
 * @Timer : 2022/3/31
 * @Description :
 */
public class FactoryMethod {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.info();

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.info();
    }

}


interface Product{
    public void info();
}

class ProductA implements Product{

    @Override
    public void info() {
        System.out.println("我是产品A ");
    }
}

class ProductB implements Product{

    @Override
    public void info() {
        System.out.println("我是产品B ");
    }
}

interface Factory{
    public Product createProduct();
}

class FactoryA implements Factory{

    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory{

    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

3）适用性

当一个类不知道它所必须创建的对象的类的时候
当一个类希望由它的子类来指定它所创建的对象的时候
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

1.2 抽象工厂模式 Abstract Factory

抽象工厂模式（Abstract Factory）

1）意图：

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

2）结构

3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/3/31
 * @Description :
 */
public class AbstractFactory {
    public static void main(String[] args) {
        new Factory1().createProductA().info();
        new Factory1().createProductB().info();
        new Factory2().createProductA().info();
        new Factory2().createProductB().info();

    }

}

interface ProductA {
    public void info();
}

interface ProductB {
    public void info();
}

class ProductA1 implements ProductA {

    @Override
    public void info() {
        System.out.println("我是产品 A1 ");
    }
}

class ProductA2 implements ProductA {

    @Override
    public void info() {
        System.out.println("我是产品 A2 ");
    }
}

class ProductB1 implements ProductB {

    @Override
    public void info() {
        System.out.println("我是产品 B1 ");
    }
}

class ProductB2 implements ProductB {

    @Override
    public void info() {
        System.out.println("我是产品 B2 ");
    }
}

interface Factory {
    ProductA createProductA();

    ProductB createProductB();
}

class Factory1 implements Factory {

    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}


class Factory2 implements Factory {

    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

4）适用性

一个系统要独立于它的产品的创建、组合和表示时
一个系统要由多个产品系列中的一个来配置时
当要强调一系列相关的产品对象的设计以便进行联合使用时
当提供一个产品类库，只想显示它们的接口而不是实现时

1.3 生成器模式 Builder

构建器/生成器模式（Builder）

（1）意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

（2）结构

（3）代码

/**
 * @author : lyj
 * @Timer : 2022/4/4
 * @Description :
 */
public class BuilderMain {
    public static void main(String[] args) {
        Director director = new Director();
        Builder builder1 = new Builder1();
        Builder builder2 = new Builder2();
        director.construct(builder1);
        Product product1 = builder1.getResult();
        product1.showParts();
        director.construct(builder2);
        Product product2 = builder2.getResult();
        product2.showParts();
    }
}

class Director{
    public void construct(Builder builder){
        builder.buildPart();
    }
}

abstract class Builder {
    public abstract void buildPart();

    public abstract Product getResult();
}

class Builder1 extends Builder {
    Product product = new Product();

    @Override
    public void buildPart() {
        product.addPart("A1");
        product.addPart("B1");
        product.addPart("C1");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

class Builder2 extends Builder {
    Product product = new Product();

    @Override
    public void buildPart() {
        product.addPart("A2");
        product.addPart("B2");
        product.addPart("C2");
    }

    @Override
    public Product getResult() {
        return product;
    }
}


class Product {
    List<String> parts = new ArrayList<>();

    public void addPart(String part) {
        parts.add(part);
    }

    public void showParts() {
        System.out.print("产品的组成：");
        for (String part : parts) {
            System.out.print(part + " ");
        }
        System.out.println("");
    }
}

（4）适用性

当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时
当构造过程必须允许被构造的对象有不同的表示时

1.4 原型模式 Prototype

（1）意图：用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

（2）结构

（3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/4/4
 * @Description :
 */
public class PrototypeMain {
    public static void main(String[] args) {
        Product product1 = new Product(2022, 5.28);
        System.out.println("产品1的信息：" + product1.getId() + " " 
                           + product1.getPrice());

        Product product2 = (Product) product1.clone();
        System.out.println("产品2克隆产品1：" + product2.getId() + " " 
                           + product2.getPrice());
    }
}

interface Prototype {
    public Object clone();
}

class Product implements Prototype {
    private int id;
    private double price;

    public Product(int id, double price) {
        this.id = id;
        this.price = price;
    }

    public Product() {
    }


    public int getId() {
        return id;
    }

    public double getPrice() {
        return price;
    }


    @Override
    public Object clone() {
        Product object = new Product();
        object.id = this.id;
        object.price = this.price;
        return object;
    }
}

（4）适用性

当一个系统应该独立于它的产品创建、构成和表示时。
为了避免创建一个与产品类层次平行的工厂类层次时。
当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们，可能比每次用合适的状态手工实例化该类更方便一些。

1.5 单例模式 Singleton

（1）意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

（2）结构

（3）代码

/**
 * @author : lyj
 * @Timer : 2022/4/4
 * @Description :
 */
public class SingletonMain {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        Singleton instance3 = Singleton.getInstance();
        System.out.println("实例1的num：" + instance1.getNum());
        System.out.println("实例2的num：" + instance2.getNum());
        System.out.println("实例3的num：" + instance3.getNum());

        instance1.setNum(528);
        System.out.println("------ instance1.setNum(528); ------");
        System.out.println("实例1的num：" + instance1.getNum());
        System.out.println("实例2的num：" + instance2.getNum());
        System.out.println("实例3的num：" + instance3.getNum());

    }
}

class Singleton {
    private int num = 2022;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }


    private static Singleton singleton = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

（4）适用性

当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
当这个唯- - -实例应该是通过子类化可扩展的，并且客户无须更改代码就能使用一个扩展的实例时。

2、结构型模式

功能：主要处理类和对象的组合问题，让类或对象形成更大的结构提供相应的指导

2.1 适配器模式 Adapter

（1）意图

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

（2）结构（适配器）

（3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/4/6
 * @Description :
 */
public class AdapterMain {
   public static void main(String[] args) {
      USB typeC = new Adapter();
      typeC.Request();

   }
}

class USB {
   public void Request(){
      System.out.println("USB数据线");
   }
}

class TypeC {
   public void SpecificRequest(){
      System.out.println("Type-C数据线");
   }
}

class Adapter extends USB {
   private TypeC typeC =new TypeC();

   @Override
   public void Request() {
      typeC.SpecificRequest();
   }
}

（4）适用性

想使用一个已经存在的类。而它的接口不符合要求
想创建一个可以服用的类，该类可以与其他不相关类或不可预见的类（即那些接口可能不一定兼容的类）协同工作
（仅适用于对象Adapter）想使用同一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口

2.2 桥接模式 Bridge

（1）意图：

将抽象部分与其实现部分分离，使它们可以独立地变化。

（2）结构

（3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/4/6
 * @Description :
 */
public class BridgeMain {
    public static void main(String[] args) {
        Product productA = new ProductA();
        Color red = new Red();
        productA.setName("产品A");
        productA.setColor(red);
        productA.Operation();

        Product productB = new ProductB();
        Color blue = new Blue();
        productB.setName("产品B");
        productB.setColor(blue);
        productB.Operation();

    }
}

abstract class Product {
    private String name;
    protected Color color;

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void Operation();
}

class ProductA extends Product {

    @Override
    public void Operation() {
        color.OperationImpl(this.getName());
    }
}

class ProductB extends Product {

    @Override
    public void Operation() {
        color.OperationImpl(this.getName());
    }
}

interface Color {
    public void OperationImpl(String name);

}

class Red implements Color {

    @Override
    public void OperationImpl(String name) {
        System.out.println(name + " : 红色");
    }
}

class Blue implements Color {

    @Override
    public void OperationImpl(String name) {
        System.out.println(name + " : 蓝色");
    }
}

（4）适用性

不希望再抽象和它的实现部分之间有一个固定的绑定关系。例如，这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。
类的抽象以及它实现都应该可以通过生成子类的方法加以扩充。这是Bridge，模式使得开发者可以对不同的抽象接口和实现部分进行组合，并分别对他们进行扩充。
对一个抽象的实现部分的修改应对客户不产生影响，即客户代码不必重新编译
（C++）想对客户完全隐藏抽象的实现部分
有许多类要生成的类层次结构
想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点

2.3 组合模式 Composite

（1）意图：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

（2）结构

（3）代码示例

（4）适用性

2.4 装饰模式 Decorator

（1）意图：对对象进行包装，动态地给一个对象添加一些额外的职责。（给对象添加行为）

（2）结构

（3）代码示例

package j1015.design;

/**
 * @author : lyj
 * @Timer : 2022/10/22
 * @Description :
 */
public class DecorationPartten {
   public static void main(String[] args) {
      Invoice t = new Invoice();
      Invoice ticket;
      ticket = new HeadDecorate(new FooterDecorate(t));
      ticket.printInvoice();
      System.out.println("------------------");
      ticket = new FooterDecorate(new HeadDecorate(null));
      ticket.printInvoice();
   }
}
class Invoice{
   public void printInvoice(){
      System.out.println("this is the content of invoice");
   }
}
class Decorate extends Invoice{
   protected Invoice ticket;

   public Decorate(Invoice t) {
      this.ticket = t;
   }
   public void printInvoice(){
      if (ticket!=null){
         ticket.printInvoice();
      }
   }
}

class HeadDecorate extends Decorate{

   public HeadDecorate(Invoice t) {
      super(t);
   }
   public void printInvoice(){
      System.out.println("this is the head of invoice");
      super.printInvoice();
   }

}

class FooterDecorate extends Decorate{

   public FooterDecorate(Invoice t) {
      super(t);
   }
   public void printInvoice(){
      super.printInvoice();

      System.out.println("this is the footer of invoice");
   }

}

（4）适用性

2.5 外观模式 Facade

（1）意图：

为子系统中的一组接口提供一个一致的界面。定义了一个高层接口，这个接口使得这一子系统更加容易使用。（简化接口）

（2）结构

（3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/4/18
 * @Description :
 */
public class FacadeMain {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.method1();
        facade.method2();
        facade.method3();
    }
}

class  Facade{
    subSystemOne subSystemOne;
    subSystemTwo subSystemTwo;
    subSystemThree subSystemThree;

    public Facade() {
        subSystemOne = new subSystemOne();
        subSystemTwo = new subSystemTwo();
        subSystemThree = new subSystemThree();
    }

    public void method1(){
        subSystemOne.methodOne();
    }

    public void method2(){
        subSystemTwo.methodTwo();
    }

    public void method3
            (){
        subSystemThree.methodThree();
    }

}

class subSystemOne{
    public void methodOne(){
        System.out.println("执行子系统一功能");
    }
}
class subSystemTwo{
    public void methodTwo(){
        System.out.println("执行子系统二功能");
    }
}
class subSystemThree{
    public void methodThree(){
        System.out.println("执行子系统三功能");
    }
}

（4）适用性

要为一个复杂子系统提供一-一个简单接口时
客户程序与抽象类的实现部分之间存在着很大的依赖性。
当需要构建一个层次结构的子系统时，使用Facade模式定义子系统中每层的入口点。

2.6 享元模式 Flyweight

（1）意图：

运用共享技术有效地支持打两细粒度的对象。（对象共享）

（2）结构

（3）代码示例

（4）适用性

一个应用程序使用了大量的对象。
完全由于使用大量的对象，造成很大的存储开销。
对象的大多数状态都可变为外部状态。
如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。
应用程序不依赖于对象标识。于Flyweight 对象可以被共享，所以对于概念上明显
有别的对象，标识测试将返回真值。

2.7 代理模式 Proxy

（1）意图：

为其他对象提供一种代理以控制对这个对象的访问。

（2）结构

（3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/4/18
 * @Description :
 */
public class ProxyMain {
   public static void main(String[] args) {
      RealSubject realSubject = new RealSubject();
      Proxy proxy = new Proxy(realSubject);
      proxy.buy();

   }
}
interface subject{
   public void buy();
}
class Proxy implements subject{
   protected RealSubject realSubject;

   public Proxy(RealSubject realSubject) {
      this.realSubject = realSubject;
   }

   @Override
   public void buy() {
      System.out.println("办理购买前的手续");
      realSubject.buy(); // 付钱
      System.out.println("办理购买后的手续");
   }
}
class RealSubject implements subject{
   @Override
   public void buy() {
      System.out.println("付钱");
   }
}

（4）适用性

Proxy模式适用于在需要比较通用和复杂的对象指针代替简单的指针的时候,常见情况有:

远程代理(RemoteProxy) 为–个对象在不同地址空间提供局部代表。
虚代理(Virtual Proxy) 根据需要创建开销很大的对象。
保护代理( Protection Proxy) 控制对原始对象的访问，用于对象应该有不同的访问权限的时候。
智能引用(Smart Reference) 取代了简单的指针，它在访问对象时执行一-些附加操作。
典型用途包括:对指向实际对象的引用计数，这样当该对象没有引用时，可以被自动释放;当第- -次引用一个持久对象时，将它装入内存;在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。

3、行为型模式

功能：主要描述类或对象交互的情况以及职责的分配问题。

3.1 责任链模式 Chain of Responsibility

（1）意图：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

（2）结构

（3）代码示例

（4）适用性

3.2 命令模式 Command

（1）意图：将请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

（2）结构

（3）代码示例

（4）适用性

3.3 解释器模式 Interpreter

（1）意图：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。（用来表示解释语言）

（2）结构

（3）代码示例

（4）适用性

3.4 迭代器模式 Iterator

（1）意图：提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。

（2）结构

（3）代码示例

（4）适用性

3.5 中介者模式 Mediator

（1）意图：用一个中介对象来封装一系列的对象交互。使各对象不需要显式地相互引用，从而使耦合松散，而且可以独立地改变它们之间的交互。（中介对象封装对象交互）

（2）结构

（3）代码示例

（4）适用性

3.6 备忘录模式 Memento

（1）意图：在不破坏封装性的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可以将对象恢复到原先保存的状态。

（2）结构

（3）代码示例

（4）适用性

3.7 观察者模式 Observer

（1）意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都能得到通知，并被自动更新。（通知所有依赖对象）

（2）结构

（3）代码示例

（4）适用性

3.8 状态模式 State

（1）意图：允许一个对象在其内部状态改变时改变它的行为。

（2）结构

（3）代码示例

（4）适用性

3.9 策略模式 Strategy

（1）意图：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。（封装算法）

（2）结构

（3）代码示例

（4）适用性

3.10 模板方法 Template Method

（1）意图：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

（2）结构

（3）代码示例

/**
 * @author : lyj
 * @Timer : 2022/4/17
 * @Description :
 */
public class TemplateMethodMain {
    public static void main(String[] args) {
        System.out.println("学生");
        Person student = new Student();
        student.TemplateMethod();
        System.out.println("---------------------------");

        System.out.println("老师");
        Person teacher = new Teacher();
        teacher.TemplateMethod();
    }

}
abstract class Person{
    public void TemplateMethod(){
        System.out.println("1、上课 去教室");
        PrimitiveOperation1();
        System.out.println("3、下课 离开教师");
        PrimitiveOperation2();
    }
    public  abstract void PrimitiveOperation1(); // 原语操作1 上课： 学生听课 老师讲课
    public  abstract void PrimitiveOperation2(); // 原语操作1 作业： 学生写作业 老师改作业
}

class Student extends Person{

    @Override
    public void PrimitiveOperation1() {
        System.out.println("2、学生：听课");
    }

    @Override
    public void PrimitiveOperation2() {
        System.out.println("2、学生：写作业");
    }
}

class Teacher extends Person{

    @Override
    public void PrimitiveOperation1() {
        System.out.println("4、老师：讲课");
    }

    @Override
    public void PrimitiveOperation2() {
        System.out.println("4、老师：改作业");
    }
}

（4）适用性

一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
各子类中公共的行为应被提取出来并集中到一个公共父类中，以避免代码重复。
控制子类扩展。模板方法旨在特定点调用“hook" 操作(默认的行为，子类可以在必要时进行重定义扩展)，这就只允许在这些点进行扩展。

3.11 访问者模式 Visitor

（1）意图：标识一个作用于某对象结构中的各元素的操作，它允许在不改变各元素的类的前提下定义作用于这些元素的新操作。

（2）结构

（3）代码示例

（4）适用性

目录CONTENT

23 种设计模式

设计原则

总结

创建型模式

结构型模式

行为型模式

1、创建型模式

1.0 简单工厂模式

1.1 工厂方法模式 Factory Method

1.2 抽象工厂模式 Abstract Factory

1.3 生成器模式 Builder

1.4 原型模式 Prototype

1.5 单例模式 Singleton

2、结构型模式

2.1 适配器模式 Adapter

2.2 桥接模式 Bridge

2.3 组合模式 Composite

2.4 装饰模式 Decorator

2.5 外观模式 Facade

2.6 享元模式 Flyweight

2.7 代理模式 Proxy

3、行为型模式

3.1 责任链模式 Chain of Responsibility

3.2 命令模式 Command

3.3 解释器模式 Interpreter

3.4 迭代器模式 Iterator

3.5 中介者模式 Mediator

3.6 备忘录模式 Memento

3.7 观察者模式 Observer

3.8 状态模式 State

3.9 策略模式 Strategy

3.10 模板方法 Template Method

3.11 访问者模式 Visitor

评论区