【中级软件设计师】—（针对上午题）二十三种设计模式（三十九）-阿里云开发者社区

一、设计模式的分类

背背背

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

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

一、设计模式的分类

背背背

1

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

三、简单工厂模式

四、工厂方法模式

五、抽象工厂模式

2

3

六、生成器模式

4

5

6

七、原型模式

八、单例模式

7

8

9

结构型设计模式（7种）

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

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

九、适配器模式

10

十、桥接模式

11

12

13

十一、组合模式

14

15

16

十二、装饰器模式

17

十三、外观模式

18

19

十四、享元模式

20

十五、代理模式

21

行为型设计模式（11种）

十六、责任链模式

十七、命令模式

22

23

十八、解释器模式

十九、迭代器模式

二十、中介者模式

24

二十一、备忘录模式

二十一、观察者模式

25

26

27

28

29

30

31

二十二、状态模式

32

33

二十三、策略模式

34

35

36

二十四、模板方法模式

二十五、访问者模式

37

38

二十六、设计模式总和

39

40

41

42

43

44

45

46

本章完结撒花👏👏👏👏