0
点赞
收藏
分享

微信扫一扫

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


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

一、设计模式的分类

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


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

背背背

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_03

1

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

二、创建型设计模式(5种)

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_05

三、简单工厂模式

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


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

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

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

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

四、工厂方法模式

📢意图要背

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


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


工厂方法代码实现如下:

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

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

五、抽象工厂模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_12

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_13

抽象工厂模式代码如下:

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

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

2

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

3

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_16

六、生成器模式

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


生成器模式代码如下:

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

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_18

4

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_19

5

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

6

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_21


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

七、原型模式

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


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

原型模式代码实现如下:

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

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_25

八、单例模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_26


单例模式代码如下:

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

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_27

7

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_28

8

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_29

9

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

结构型设计模式(7种)

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

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

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_31

九、适配器模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_32

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("特殊请求");
    }
}

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_33

10

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_34

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

十、桥接模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_36


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


桥接模式代码实现如下:

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+":蓝色");
        }
    }

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

11

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

12

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_40

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_41

13

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


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

十一、组合模式

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


组合模式添加和删除代码实现:

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

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

14

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_46

15

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_47

16

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_48

十二、装饰器模式

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

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


装饰器模式代码实现:

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+"的职责:学习");
    }


}

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_51

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

17

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_53

十三、外观模式

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


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

外观模式代码实现:

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

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

18

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

19

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

十四、享元模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_59


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

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

20

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

十五、代理模式

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


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


代理模式代码实现:

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

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

21

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_66

行为型设计模式(11种)

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_67

十六、责任链模式

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


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

代码实现:

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_70

十七、命令模式

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


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

22

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

23

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


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

十八、解释器模式

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


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


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_78

十九、迭代器模式

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

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

二十、中介者模式

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

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

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

}

    }
}

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_83

24

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

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

二十一、备忘录模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_86


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

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

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

二十一、观察者模式

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


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


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_91


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

25

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

26

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_94

27

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_95

28

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

29

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

30

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


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_99

31

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_100

二十二、状态模式

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_101


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_102

代码实现:

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

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


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_104

33

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


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


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_107

44-47 B A D C

二十三、策略模式

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


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_109

34

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

35

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

36

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

二十四、模板方法模式

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


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

二十五、访问者模式

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


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

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_117


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

代码实现:

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

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

37

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_120

Accept只在访问者模式出现

38

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_121


【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_经验分享_122

二十六、设计模式总和

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

39

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

40

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

41

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_126

结构型:适配桥想组装外带

42

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

43

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_128


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

44

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_130

45

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

46

【中级软件设计师】—(针对上午题)二十三种设计模式(三十九)_设计模式_132

本章完结撒花👏👏👏👏


举报

相关推荐

0 条评论