【中级软件设计师】—（针对上午题）二十三种设计模式（三十九）

一、设计模式的分类

在这里插入图片描述

背背背

在这里插入图片描述

1

在这里插入图片描述

二、创建型设计模式（5种）

在这里插入图片描述

三、简单工厂模式

在这里插入图片描述

简单工厂模式代码实现如下：

/**
 * @author：CaiCai
 * @date ： 2023/4/26 9:11
 * 
 */

/*
简单工厂模式
*  */
public class SimpleFactory {

    public static void main(String[] args){
        Product productA=Factory.createProduct("A");
        productA.info();

        Product productB=Factory.createProduct("B");
        productB.info();
    }

}
class Factory {
    public static Product createProduct(String type){
        Product product =null;
        switch (type){
            case "A":
                product=new ProductA();
                break;
            case "B":
                product=new ProductB();
                break;
            default:
                System.out.println("没有"+ type +"类型的产品！");
                break;
        }
        return product;
    }
}

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

class ProductA extends  Product{
    @Override
    public  void info(){
        System.out.println("产品信息：A");
    }
}
class ProductB extends  Product{
    @Override
    public  void info(){
        System.out.println("产品信息：B");
    }
}

在这里插入图片描述

四、工厂方法模式

📢意图要背
在这里插入图片描述

工厂方法代码实现如下：

/**
 * @author ：CaiCai
 * @date ： 2023/4/26 11:54
 */
public class FactoryMethods {
    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();
    }
}


//class Factory
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();
    }
}


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");
    }
}

在这里插入图片描述

五、抽象工厂模式

在这里插入图片描述

抽象工厂模式代码如下：

/**
 * @author ：CaiCai
 * @date ： 2023/4/26 11:54
 */
public class AbstractFactory {
    public static void main(String[] args) {

        Factory factory1=new Factory1();
        ProductA productA=factory1.createProductA();
        productA.info();

        Factory factory2=new Factory2();
        ProductB productB=factory2.createProductB();
        productB.info();
    }
}


//class Factory
interface Factory{
    public ProductA createProductA();
    public 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();
    }
}


interface ProductA{
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");
    }
}


interface ProductB{
    public void info();
}
class ProductB1 implements ProductB{
    @Override
    public void info(){
        System.out.println("产品的信息：B1");
    }
}
class ProductB2 implements ProductB{
    @Override
    public void info(){
        System.out.println("产品的信息：B2");
    }
}

在这里插入图片描述

2

在这里插入图片描述

3

在这里插入图片描述

六、生成器模式

在这里插入图片描述
生成器模式代码如下：

import java.util.ArrayList;
import java.util.List;

/**
 * @author     ：CaiCai
 * @date       ： 2023/4/26 13:49
 * 
 */public class Main {
    public static void main(String[] args) {
        Director director=new Director();
        Builder builder1=new Builder1();
        director.Construct(builder1);
        Product product1=builder1.getResult();
        product1.show();

        Builder builder2=new Builder2();
        director.Construct(builder2);
        Product product2=builder2.getResult();
        product2.show();

    }
}
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.Add("A");
         product.Add("B");
         product.Add("C");
         product.Add("D");
     }

    @Override
    public Product getResult(){
         return product;

    }
}


class Builder2 extends Builder{
    Product product=new Product();
    @Override
    public void BuildPart(){
        product.Add("A");
        product.Add("B");
        product.Add("C");

    }

    @Override
    public Product getResult(){
        return product;

    }
}



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

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

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

         System.out.print("\n");
     }
}

在这里插入图片描述

4

在这里插入图片描述

5

在这里插入图片描述

6

在这里插入图片描述

七、原型模式

在这里插入图片描述

原型模式代码实现如下：

public class Main {
    public static void main(String[] args) {
        Product product1=new Product(2023,4.26);
        System.out.println(product1.getId()+"  "+product1.getPrice());

        Product product2=(Product)product1.Clone();
        System.out.println(product2.getId()+"  "+product2.getPrice());
    }
}

interface Prototype{
public  Object Clone();
}

class Product implements Prototype{
    private int id;
    private double price;
    public Product(){}

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

    }
    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;
    }
}

在这里插入图片描述

八、单例模式

在这里插入图片描述
单例模式代码如下：

public class SingletonPattern {
    public static void main(String[] args) {

        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        Singleton singleton3=Singleton.getInstance();
        System.out.println(singleton1.getNumber()+" "+singleton2.getNumber()+" "+singleton3.getNumber());

        singleton1.setNumber(2024);
        System.out.println(singleton1.getNumber()+" "+singleton2.getNumber()+" "+singleton3.getNumber());

    }

}

class Singleton{
    private  int number=2023;
    public void setNumber(int number){
        this.number=number;
    }
    public int getNumber(){
        return number;
    }
 private static Singleton instance=new Singleton();

    private Singleton(){}

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

在这里插入图片描述

7

在这里插入图片描述

8

在这里插入图片描述

9

在这里插入图片描述

结构型设计模式（7种）

结构型速记：桥代理组装适配器，享元回家装饰外观

（乔丹代理了组合（两台）适配器），享元（人名）买回家装饰外观。

在这里插入图片描述

九、适配器模式

在这里插入图片描述

public class AdaptPattern {
    public static void main(String[] args) {
      Target target=new Adapter();
      target.Request();
    }

}

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

class Adapter extends Target{
    private Adapt adapt=new Adapt();
    @Override
    public void Request(){
        adapt.SpecificRequest();
    }
}

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

在这里插入图片描述

10

在这里插入图片描述

十、桥接模式

在这里插入图片描述

桥接模式代码实现如下：

public class BridgePattern {
    public static void main(String[] args) {
        Product productA1=new ProductA();
        Product productA2=new ProductA();
        Color red=new Red();

       productA1.setName("产品A1");
        productA1.setColor(red);
        productA1.Operation();

     Blue blue=new Blue();
        productA2.setName("产品A2");
        productA2.setColor(blue);
        productA2.Operation();
    }

}

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

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

    public String getName() {
        return name;
    }

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

    public abstract void Operation();
}


class ProductA extends Product {
    @Override
    public void Operation() {
        color.OperationImp(this.getName());
    }
}
    interface Color {
        public void OperationImp(String name);

    }
    class Red implements Color{
        @Override
        public void OperationImp(String name){
            System.out.println(name+":红色");
        }
    }
    class Blue implements Color{
        @Override
        public void OperationImp(String name){
            System.out.println(name+":蓝色");
        }
    }

在这里插入图片描述

11

在这里插入图片描述

12

在这里插入图片描述

13

在这里插入图片描述

十一、组合模式

在这里插入图片描述
组合模式添加和删除代码实现：

import java.util.ArrayList;
import java.util.List;

public class CompositePattern {
    public static void main(String[] args) {
        AbstractFile root=new Folder("root");
        AbstractFile folderA=new Folder("folderA");
        AbstractFile fileB=new File("fileB");
        System.out.println(root.Add(folderA));
        System.out.println(root.Add(fileB));

        System.out.println(root.Remove(fileB));
        System.out.println(root.Remove(fileB));

    }

}

abstract class AbstractFile{
    protected  String name;
    public void printName(){
        System.out.println(name);
    }

    public abstract boolean Add(AbstractFile file);
    public  abstract boolean Remove(AbstractFile file);
    //
}

class Folder extends AbstractFile{
    private List<AbstractFile> childrenList=new ArrayList<AbstractFile>();
    public Folder(String name) {
        this.name=name;
    }
    @Override
    public boolean Add(AbstractFile file){
   return childrenList.add(file);
    }

    @Override
    public boolean Remove(AbstractFile file){
     return  childrenList.remove(file);
    }
}


class File extends AbstractFile{
    public File(String name){
        this.name=name;
    }
    @Override
    public boolean Add(AbstractFile file){
        return false;
    }
    @Override
    public boolean Remove(AbstractFile file){
        return false;
    }
}

在这里插入图片描述

14

在这里插入图片描述

15

在这里插入图片描述

16

在这里插入图片描述

十二、装饰器模式

在这里插入图片描述

在这里插入图片描述
装饰器模式代码实现：


public class DecoratePattern {
    public static void main(String[] args) {
        Person zhangsan=new Student("张三");
        zhangsan.Operation();

        System.out.println("\n=======我是分割线=======");
   // Decorator decoratorA=new DecoratorA(zhangsan);
     //   decoratorA.Operation();
        zhangsan=new DecoratorA(zhangsan);
        zhangsan.Operation();


    }
}

abstract class Decorator extends Person{
    protected  Person person;
}

class DecoratorA extends Decorator{
    public DecoratorA(Person person){
        this.person=person;
    }

    @Override
    public void Operation(){//职责
        person.Operation();//原本的职责
        System.out.print("写作业");

    }

}
abstract class Person{
    protected String name;

    public abstract void Operation();//职责
}

class Student extends Person{
    public Student(String name)
    {
        this.name=name;
    }
    @Override
    public void Operation(){
        System.out.print(name+"的职责：学习");
    }


}

在这里插入图片描述

17

在这里插入图片描述

十三、外观模式

在这里插入图片描述

外观模式代码实现：

import javax.security.auth.Subject;

public class FacadePattern {
    public static void main(String[] args) {
         Facade facade=new Facade();

        facade.methodA();
        facade.methodB();
        facade.methodC();
    }
}
class Facade {
    SubSystemOne subSystemOne;
    SubSystemTwo subSystemTwo;
    SubSystemThree subSystemThree;


    public Facade() {
        subSystemOne = new SubSystemOne();
        subSystemTwo = new SubSystemTwo();
        subSystemThree = new SubSystemThree();

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

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

    }
    public void methodC(){
        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("执行子系统三的功能");
    }
}

在这里插入图片描述

18

在这里插入图片描述

19

在这里插入图片描述

十四、享元模式

在这里插入图片描述

20

在这里插入图片描述

十五、代理模式

在这里插入图片描述

代理模式代码实现：

public class ProxyPattern {
    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("付钱");
    }
}

在这里插入图片描述

21

在这里插入图片描述

行为型设计模式（11种）

在这里插入图片描述

十六、责任链模式

在这里插入图片描述

代码实现：
在这里插入图片描述

十七、命令模式

在这里插入图片描述

22

在这里插入图片描述

23

在这里插入图片描述

十八、解释器模式

在这里插入图片描述

十九、迭代器模式

在这里插入图片描述

二十、中介者模式

在这里插入图片描述


public class MediatorPattern {
    public static void main(String[] args) {
        ConcreteMediator mediator=new ConcreteMediator();

        Colleague1 colleague1=new Colleague1(mediator);
        Colleague2 colleague2=new Colleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("祝大家软考一次性通过！！");
        colleague2.sendMessage("2023年5月27软考");

    }

}

abstract class Colleague{
    protected Mediator mediator;
}

class Colleague1 extends Colleague{
    public Colleague1(Mediator mediator){
        this.mediator=mediator;

    }

    public  void sendMessage(String message){
        mediator.sendMessage(message,this);
    }
    public void Notify(String message){
        System.out.println("同事1收到消息："+ message);
    }
}

class Colleague2 extends Colleague{
    public Colleague2(Mediator mediator){
        this.mediator=mediator;
    }
    public  void sendMessage(String message){
        mediator.sendMessage(message,this);
    }
    public void Notify(String message){
        System.out.println("同事2收到消息："+message);
    }
}

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


class ConcreteMediator extends Mediator{
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    public void setColleague1(Colleague1 colleague1){
        this.colleague1=colleague1;
    }

    public void setColleague2(Colleague2 colleague2){
        this.colleague2=colleague2;
    }
    public void sendMessage(String message,Colleague colleague){
if(colleague==colleague1){
    //让同事2收到消息
    colleague2.Notify(message);
}else {
    //让同事1收到消息
    colleague1.Notify(message);

}

    }
}

在这里插入图片描述

24

在这里插入图片描述

二十一、备忘录模式

在这里插入图片描述

import java.util.ArrayList;
import java.util.List;

public class MementoPattern {
    public static void main(String[] args) {
        Caretaker caretaker=new Caretaker();
        Originator originator=new Originator();

        originator.setState("427");
        Memento backup1=originator.createMemento();
        caretaker.addMemento(backup1);

        originator.setState("428");
        Memento backup2=originator.createMemento();
        caretaker.addMemento(backup2);

        originator.setState("429");
        Memento backup3=originator.createMemento();
        caretaker.addMemento(backup3);

        System.out.println(originator.getState());

        caretaker.showMemento();

      Memento memento1=caretaker.getMemento(2);
      originator.setMemento(memento1);


      System.out.println("根据第2次备份还原之后的状态为："+originator.getState());

    }


}

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 setMemento(Memento memento){
        state=memento.getState();
    }

}

class Memento{//备忘录
    private String state;
    public Memento(String state){
        this.state=state;
    }

    public String getState(){
        return state;
    }
}
class Caretaker{//管理者
    private List<Memento> mementoList=new ArrayList<>();

    public void addMemento(Memento memento){
        mementoList.add(memento);
    }

    public Memento getMemento(int index){
        //判断参数是否合法
        if(index>=1 &&index<=mementoList.size()){
            return mementoList.get(index-1);
        }
        return null;
    }

    public void showMemento(){
        int cnt=1;
        for(Memento memento:mementoList){
            System.out.println("第" + cnt +" 次备份，状态为："+memento.getState());
        cnt++;
        }
    }
}

在这里插入图片描述

二十一、观察者模式

在这里插入图片描述

25

在这里插入图片描述

26

在这里插入图片描述

27

在这里插入图片描述

28

在这里插入图片描述

29

在这里插入图片描述

30

在这里插入图片描述

31

在这里插入图片描述

二十二、状态模式

在这里插入图片描述

代码实现：

public class StatePattern {
    public static void main(String[] args) {
        Context context=new Context();
        System.out.println(context.getState());
        context.Request();//2
        context.Request();//1
        context.Request();//0


        System.out.println(context.getState());
        context.Request();//无货
    }

}


class Context{//贩卖机
    private int count;

    private State state;

    public Context(){
        count=3;
        state=new StateA();
    }
    public int getCount(){
        return count;
    }

    public void setCount(int count){
        this.count=count;
    }
    public State getState(){
        return state;
    }
    public void getState(State state){
        this.state=state;
    }
    public void Request(){//购买一瓶饮料
        state.Handle(this);

    }


    public void setState(StateA stateA) {
    }

    public void SetState(StateB stateB) {
    }
}

interface State{
    public void Handle(Context context);
}


class StateA implements State{//有货
    @Override
    public void Handle(Context context){
int count=context.getCount();
if(count>=1){
    System.out.println("购买成功");
    context.setCount(count-1);

    if(context.getCount()==0){
        context.SetState(new StateB());
    }
}else{
    System.out.println("购买失败！");
}
    }

}

class StateB implements State{//无货
    @Override
    public void Handle(Context context){
int count=context.getCount();
        if(count==0){
            System.out.println("购买成功，等待补货");
            context.setCount(5);
            System.out.println("补货成功。请重新购买");
            context.setState(new StateA());
        }
    }

}

32

在这里插入图片描述

33

在这里插入图片描述

44-47 B A D C

二十三、策略模式

在这里插入图片描述

34

在这里插入图片描述

35

在这里插入图片描述

36

在这里插入图片描述

二十四、模板方法模式

在这里插入图片描述

二十五、访问者模式

在这里插入图片描述

代码实现：

import java.util.ArrayList;
import java.util.List;

public  class VisitorPattern {
    public static void main(String[] args) {
        PersonStructure structure=new PersonStructure();
       Visitor1 visitor1=new Visitor1();

        System.out.println("访问者1访问记录");
        structure.Accept(visitor1);
        System.out.println("===============");


        Visitor2 visitor2=new Visitor2();
        System.out.println("访问者2访问记录");

        structure.Accept(visitor2);
    }

}

interface Visitor{
    public void visitStudent(Student student);
    public void visitTeacher(Teacher teacher);
}

class Visitor1 implements Visitor{
    @Override
    public void visitStudent(Student student){
        System.out.println("访问者1访问学生"+student.name);
    }
    @Override
    public void visitTeacher(Teacher teacher){
        System.out.println("访问者1访问老师"+teacher.name);


    }
}
class Visitor2 implements Visitor{

    @Override
    public void visitStudent(Student student){
        System.out.println("访问者2访问学生"+student.name);
    }
    @Override
    public void visitTeacher(Teacher teacher){
        System.out.println("访问者2访问老师"+teacher.name);


    }
}
class PersonStructure{
    private List<Person> personList=new ArrayList<Person>();
public PersonStructure(){
    personList.add(new Student("张三"));
    personList.add(new Student("李四"));
    personList.add(new Student("王五"));

    personList.add(new Student("李老师"));
    personList.add(new Student("陈老师"));
    personList.add(new Student("刘老师"));
}

public void Accept(Visitor visitor){
    for(Person  person:personList){
        person.Accept(visitor);
    }
}
}
abstract class Person{
    public String name;

    public abstract void Accept(Visitor visitor);

}

class Student extends Person{
    public Student(String name){
        this.name=name;
    }
@Override
    public void Accept(Visitor visitor){
    visitor.visitStudent(this);
}
}

class Teacher extends Person{
    public Teacher(String name){
        this.name=name;
    }
    @Override
    public void Accept(Visitor visitor){
        visitor.visitTeacher(this);
    }
}