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

已于 2023-04-27 20:10:52 修改
阅读量1.4k 收藏 16
点赞数 7
分类专栏： 【软件中级设计师】 文章标签： java android 设计模式 经验分享
于 2023-04-26 21:12:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46374969/article/details/130272448
版权

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

一、设计模式的分类

在这里插入图片描述
在这里插入图片描述

背背背

在这里插入图片描述

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

在这里插入图片描述

37

在这里插入图片描述

Accept只在访问者模式出现

38

在这里插入图片描述
在这里插入图片描述

二十六、设计模式总和

在这里插入图片描述

39

在这里插入图片描述

40

在这里插入图片描述

41

在这里插入图片描述

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

42

在这里插入图片描述

43

在这里插入图片描述
在这里插入图片描述

44

在这里插入图片描述

45

在这里插入图片描述

46

在这里插入图片描述

本章完结撒花👏👏👏👏

王同学要努力
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
软考-中级软件设计师2004-2019年真题与答案解析汇总.zip
04-02
《软考-中级软件设计师2004-2019年真题与答案解析汇总》这个压缩包文件，集中了过去十五年间全国计算机技术与软件专业技术资格（水平）考试——中级软件设计师的历年真题及详尽解答，是备考者不可或缺的参考资料。...
软件设计师上午真题23套
11-09
《软件设计师上午真题23套》是一份针对软件设计师中级职称考试的复习资料，包含了23套完整的考试真题，旨在帮助考生充分准备并熟悉考试格式和内容。这一资源对于那些正在为软件设计师中级职称考试做准备的人们来说，...
软考中级软件设计师--7.设计模式
mjzhang1993的博客
10-29 1305
软考-软件设计师-设计模式
中级软件设计师考试（软考中级）设计模式分类及其典型特点
redrose2100的博客
10-29 901
本文详细介绍了软件设计师考试中设计模式的分类以及各自的典型特点
软考，软件设计师，设计模式整理：（持续中）
方方土的博客
05-14 282
设计模式整理：
软件设计师考试：设计模式
weixin_34248705的博客
05-06 144
在面向对象软件开发过程中，采用设计模式以复用成功的设计。 Brige（桥接）模式将对象的抽象和其现实分离，从而可以独立地改变它们，抽象类定义对该抽象的接口，而具体的子类则用不同的方式加以实现。 Composite（组合模式）是结构型对象模式的一个实例，它描述了如何构造一个类层次式结构。 单例Singleton模式保证一个类只产生唯一的一个实例。 ...
软件设计师考试 设计模式
几何之星
04-22 964
目录 第一种 行为模式 第二种 结构性模式 第三种 创建型模式 第一种 行为模式 1.Chaub of Responsibility（责任链） 意图：使多个对象都有机会处理请求。请求沿链传递，直到有一个对象处理这个请求。 适用性： 可处理一个请求的对象集合应被动态指定 ...
2020年软考软件设计师历年真题
07-30
《2020年软考软件设计师历年真题》是一个重要的资源，对于准备参加软件设计师考试的考生来说，具有极高的参考价值。这份资料包含了历年来的考试真题，且附带了答案讲解，有助于考生全面了解考试的题型、难度以及考察...
中级软件设计师真题及答案（2009-2018）
02-15
中级软件设计师考试是中国计算机技术职业资格认证中的一项重要考试，主要针对那些希望在软件开发、设计领域提升专业技能和获取职称的专业人士。本资源包含了2009年至2018年间历年考试的上午和下午全真试题以及答案...
软件设计师中级历年真题.zip
01-17
《软件设计师中级历年真题》是一个压缩包文件，包含了针对软件设计师中级职称考试的历年试题与答案解析。这个资源对于备考软件设计师中级资格认证的考生来说具有极高的价值，因为它可以帮助考生了解考试的题型、难度...
[架构之路-136]-《软考-系统架构设计师》-软件工程-6-软件系统设计-23种设计模式（面向对象的可复用设计）
文火冰糖（王文兵）的博客
03-14 627
设计模式（Design pattern） 是解决软件开发某些特定问题而提出的一些解决方案,也可以理解成解决问题的一些思路。通过设计模式可以帮助我们增强代码的可重用性、可扩充性、 可维护性、灵活性好。我们使用设计模式最终的目的是实现代码的高内聚和低耦合。创建性模式（新团队成员）：如何创建一组相互关联的对象。结构性模式（组织架构）：如何把多个对象组成成一个更大的组织静态架构。行为性模式（行为流程）：如何定义多个对象之间的行为方式，确保完成某种特定的职责。设计模式是探讨如何有效的组织大量的对象。
软件设计师(软考中级)_下午题Java题总结
Eleven的博客
02-05 4569
1、意图：提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类2、结构：AbstractFactory声明一个创建抽象产品对象的操作接口ConcreteFactory实现创建具体产品对象的操作。AbstractProduct为一类产品对象声明一个接口ConcreteProduct定义一个将被相应的具体工创建的产品对象，实现AbstractProduct接口Client仅使用由AbstractFactory和AbstractProduct接口。
【黑马程序员】23种设计模式——设计模式概述
weixin_54533016的博客
03-26 372
设计模式概述"设计模式"最初并不是出现在软件设计中，而是被用于建筑领域的设计中。1977年美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯夫·亚历山大(Christopher Alexander)在他的著作(建筑模式语言:城镇、建筑、构造》中描述了一些常见的建筑设计问题，并提出了 253 种关于对城镇、邻里、住宅、花园和房间等进行设计的基本模式。
通俗易懂的java设计模式之 --备忘录模式
zmxnn的博客
02-28 330
备忘录模式 ---给自己存个档
23种软件设计模式-中级
落日的博客
04-10 3974
提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。属于对象创建型模式。抽象工厂模式与工厂方法模式最大的区别:工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。
23种设计模式之关系模式
andryyu的博客
09-18 5162
C、关系模式（11种） 先来张图，看看这11中模式的关系： 第一类：通过父类与子类的关系进行实现。 第二类：两个类之间。 第三类：类的状态。 第四类：通过中间类 父类与子类关系 1、策略模式（strategy） 策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一
【愚公系列】软考中级-软件设计师 052-面向对象技术（设计模式-行为型）
最新发布
时光隧道
01-27 5万+
设计模式是在软件设计领域中，为解决常见问题而被反复使用、被广泛认可的一种设计思想。它是一种经过实践验证的，被认为是最佳解决方案的经验总结，可以帮助开发人员快速高效地解决软件设计中的一些固有问题。每一个设计模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动。设计模式的核心在于提供了相关问题的解决方案，使得人们可以更加简单方便的复用成功的设计和体系结构。特点描述在特定情况下被使用。
桥接，适配器，代理
旅途
03-11 699
适配器模式需要使两个接口不同的对象能够协同工作，因此需要改变对象的接口；而代理模式则需要保证代理与被代理接口一致，代理的对象在于控制被代理对象，被代理对象对客户是不透明的。桥模式和适配器模式，桥是将抽象和实现分离，从而使他们可以分别改变；而适配器则使两个接口不同的对象能够协同工作。 
软考中级-设计模式
Raynond的博客
03-26 2088
软考中级设计模式总结
2017上半年中级软件设计师上午试题解析
"中级软件设计师2017上半年上午试题，包含单项选择题，涉及计算机组成原理、数据运算基础知识和输入/输出控制方式等核心概念。" 中级软件设计师考试中的试题通常涵盖计算机体系结构、编程语言、操作系统、网络、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王同学要努力

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值