软件设计试题记录

作者：@kuaiquxie
作者的github：https://github.com/bitebita
本文为作者原创，如需转载，请注明出处：https://www.cnblogs.com/dzwj/p/17111707.html

模式中的开-闭原则

 1.工厂方法（简单工厂 ）2. 抽象工厂 3. 建造者模式

1.桥接模式  2.外观模式

1.中介者模式 2.迭代器模式 3.策略模式（完美支持）

设计模式中，对迪米特法则进行应用的设计模式有外观模式和中介者模式

设计模式的两大主题：系统复用与系统扩展

填空题

1、设计模式分为创建型、结构型、行为型 三大类型。 2、设计模式中的七个原则包括：单一职责原则、开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、合成复用原则和迪米特法则 。

3、设计模式中，对**迪米特法则**进行应用的设计模式有**外观模式**和**中介者模式** 。

4、装饰模式 用于动态地给一个对象添加一些额外的职责。 5、外观模式 要求一个子系统的外表与其内部的通信必须通过一个统一的对象进行。 6、桥梁模式 的定义是将抽象和现实解耦，使得两者可以独立地变化。 7、观察者模式 定义对象间一种一对多的关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。 8、行为型模式 主要用于描述对类或对象怎样交互和怎样分配职责。 9、组合模式属于 结构型模式 、原型模式属于 创建型模式。 10、模板方法模式 定义一个操作中的算法框架，将一些步骤延迟到子类中实现。 11、策略模式 定义一组算法，将每个算法封装起来，并且使它们之间可以互换。 12、备忘录模式 捕获一个对象的内部状态，并在该对象之外保存这个状态，以后可以将该对象恢复到原先保存的状态。 13、适配器模式 将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。 14、简单工厂模式 可以根据参数的不同返回不同的实例。 15、MVC模型的基本工作原理是基于 观察者模式 ，实现是属于 命令模式 。 16、依赖倒转原则 要求抽象不应该依赖于细节，细节应当依赖于抽象。 17、里氏替换原则 的核心思想是在任何父类出现的地方都可以用它的子类来替代。 18、单一职责原则 的核心思想是系统中的每一个对象都应该只有一个单独的职责，而所有对象所关注的就是自身职责的完成。 19、适配器模式，分为类适配器和对象适配器两种实现。其中类适配器采用的是继承关系，而对象适配器采用的是 关联/委派关系。 20、Java数据库连接库JDBC使用的设计模式是桥接模式。

原文链接：https://blog.csdn.net/qq_44111805/article/details/122215073

1.Strategy意图是定义一系列的算法,把它们一个个(封装)起来, 并且使它们可相互替换。

2.（Strategy模式）模式是一种定义一系列算法的方法。

3.Adapter模式有两种类型有：对象Adapter模式、（类Adapter模式）。

4.（Adapter适配器）模式使原本接口不兼容而不能一起工作的类可以一起工作。

5.组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性。

6.桥接模式包括抽象类、扩充抽象类、实现类接口和(具体实现类 )四个角色。

7.状态模式的关键是引入了一个（**抽象类**）来专门表示对象的状态，这个类我们叫做抽象状态类，

8.享元模式的核心在于（**享元工厂类**）。

9.包括原发器、备忘录和负责人三个角色的模式是（备忘录模式）

10.（解释器）模式描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。

11.GOF总结出了（23）个模式。

12.GOF根据模式的目标将模式分为三个类目：创建型、（行为型）和结构型。

13.GOF总结出23个设计模式，其中有（7）个模式是结构型模式。

14.开闭原则中（**抽象化** ）是开闭原则的关键。

15.合成复用原则是指尽量使用对象组合，而不是（继承）来达到复用的目的。

16.面向对象的设计模式的原则是指“开－闭”原则、里氏代换原则和( 合成复用原则 )。

18.根据范围即模式主要是用于处理类之间关系还是处理对象之间的关系，可分为（类模式）和（对象模式）两种。

19.对象模式处理对象间的关系，这些关系在运行时刻变化，更具动态性。

20.类模式处理类和子类之间的关系，这些关系通过继承建立，在编译时刻就被确定下来，是属于静态的。

21.（）模式提供了管理相关的算法族的办法。策略

22.策略模式还简化了单元测试，因为第个算法都有自己的类，可以通过自己的（）单独测试。接口

23.策略模式将算法的选择和算法的（）相分离。实现

24.（）模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。 责任链

25.行为模式是对在不同的对象之间划分（）和（）抽象化。 责任算法

26.中介者模式又被称为（）模式。 调停者

27.中介者模式是一种（）模式。 对象行为

28.组合模式有时又称为（）模式。 部分－整体

29.软件模式的基本结构由4个部分组成，即问题描述、前提条件、（ ）和效果。 **解法**

30.设计模式一般包含模式名称、问题、目的、解决方案、效果、实例代码和（）。**相关设计模式**

31.设计模式根据设计目的分为创建型模式、结构型模式和（）。 行为型模式

33.GOF设计模式总共提供了（）种设计模式。 23

34.单一职责原则用于控制类的（）大小。粒度

35.开闭原则是指软件实体应当对（）开放，对修改关闭。扩展

36.（）模式让一个类的实例化延迟到其子类。工厂方法

37.抽象工厂模式是一种（）创建型模式。对象

38.（）模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。 抽象工厂

39.原型模式的结构中包含抽象原型类和（）。具体原型类

40.确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例的设计模式是（）模式。单例

41.装饰模式是属性于（）模式。 结构型

42.将抽象部分和它的实现部分解耦，使得两者都能够独立变化的设计模式是（）模式。桥接

43.（）模式让客户端可以统一对待单个对象和组合对象。组合

44.组合模式根据抽象构件类的定义形式可以分为透明组合模式和（）组合模式。安全

45.（）模式可以动态地给一个对象增加一些额外的职责。装饰

46.装饰模式又分透明装饰模式和（）装饰模式。半透明

47.享元模式是运用（）技术有效地支持大量细粒度对象的复用。共享

原文链接：https://blog.csdn.net/qq_41371349/article/details/104839456

选择题

原文链接：https://blog.csdn.net/qq_44111805/article/details/122215073

对于违反里氏替换原则的两个类，可以采用的候选解决方案错误的是：（） A、创建一个新的抽象类C，作为两个具体类的超类，将A和B共同的行为移动到C中，从而解决A和B行为不完全一致的问题。 B、将B到A的继承关系改组成委派关系。 C、区分是“Is-a”还是”Has－a”。如果是“Is-a”，可以使用继承关系，如果是”Has－a”应该改成委派关系 D、以上方案错误

答案：D

以下用来描述适配器模式的是（） A 、表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作（访问者模式） B 、定义一个用于创建对象的接口，让子类决定实例化哪一个类（工厂方法模式） C、将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作 D 、动态地给一个对象增加一些额外的职责（装饰模式）

以下用来描述命令模式是（） A、将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。 B 、定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换，本模式使得算法可独立于使用它的客户而变化（策略模式） C 、为其他对象提供一种代理以控制对这个对象的访问（代理模式） D 、保证一个类仅有一个实例，并提供一个访问它的全局访问点（单例模式）

以下用来描述装饰模式的是（） A 、运用共享技术有效地支持大量细粒度的对象（享元模式） B 、用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象（原型模式） C 、将抽象部分与它的实现部分分离，使它们都可以独立地变化（桥接模式） D、动态地给一个对象添加一些额外的职责

以下用来描述外观模式的是 ( ) A、为子系统中的一组接口提供一个一致的界面，本模式定义了一个高层接口，这个接口使得这一子系统更加容易使用 B 、定义一个用于创建对象的接口，让子类决定实例化哪一个类（工厂方法模式） C 、保证一个类仅有一个实例，并提供一个访问它的全局访问点（单例模式） D 、在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。样以后就可将该对象恢复到原先保存的状态（备忘录模式）

以下意图哪个是用来描述桥接模式（） A、提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类（抽象工厂模式） B、将抽象部分与它的实现部分分离，使它们都可以独立地变化 C、将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示（建造者模式） D、动态地给一个对象添加一些额外的职责（装饰模式）

以下哪个用来描述建造者模式（） A、定义一个用于创建对象的接口，让子类决定实例化哪一个类（工厂方法模式） B、保证一个类仅有一个实例，并提供一个访问它的全局访问点（单例模式） C、将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 D、运用共享技术有效地支持大量细粒度的对象（享元模式）

关于模式应用场景，在以下哪种情况适合使用组合模式（） A、你想使用一个已经存在的类，而它的接口不符合你的需求（适配器模式） B、当一个类的实例只能有几个不同状态组合中的一种时（原型模式） C、你想表示对象的部分-整体层次结构 D、一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变行为（状态模式）

以下意图哪个是用来描述抽象工厂模式（） A、提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类 B、定义一个用于创建对象的接口，让子类决定实例化哪一个类（工厂方法模式） C、将一个类的接口转换成客户希望的另外一个接口（适配器模式） D、表示一个作用于某对象结构中的各元素的操作（访问者模式）

设计模式具有的优点（A ）。

A．适应需求变化 B.程序易于理解

C．减少开发过程中的代码开发工作量 D.简化软件系统的设计

设计模式一般用来解决什么样的问题( A)。

A.同一问题的不同表相 B不同问题的同一表相

C.不同问题的不同表相 D.以上都不是

以下哪些问题通过应用设计模式不能够解决（C）

A）指定对象的接口 B）针对接口编程

C）确定软件的功能都正确实现 D）设计应支持变化

打印池在操作系统中是一个用于管理打印任务的应用程序，通过打印池用户可以删除、中止或者改变打印任务的优先级。我们可以使用（ D ）来模拟实现打印池的设计。

A.命令模式 B.桥接 C.责任链 D. 单例模式

论坛权限控制设计：在一个论坛中已注册用户和游客的权限不同，已注册的用户拥有发帖、修改自己的注册信息、修改自己的帖子等功能；而游客只能看到别人发的帖子，没有其他权限。使用（ B ）来设计该权限管理模块。

 A.工厂方法模式   B.代理模式    C.享元模式     D.外观模式

下列关于简单工厂模式与工厂方法模式表述错误的是（A）

A. 两者都满足开闭原则：简单工厂以if else 方式创建对象，增加需求看看时候会修改源代码

B. 简单工厂对具体产品的创建类别和创建时机的判断是混合在一起的，这点在工厂方法模式中已经克服

C.不能形成简单工厂的继承结构

D.在工厂方法模式中，对于存在继承等级结构的产品树，产品的创建是通过相应等级结构的工厂创建的。

简单工厂模式的核心是（C）

A.抽象产品 B.具体产品 C.简单工厂 D.消费者

工厂方法模式的核心是（A）

A.一个抽象工厂 B.一个具体工厂 C.一个接口 D.没有核心

在设计中如果一个对象请求另一个对象调用其方法到达某种目的，而不和请求的对象直接打交道，这种模式是（ B ）。

A.观察者模式 B.命令模式 C. 策略模式 D.责任链模式

( A )关于多个对象想知道一个对象中数据变化情况的一种成熟的模式。

A.观察者模式 B.命令模式 C. 策略模式 D.责任链模式

策略模式的结构中包括三种角色上下文、具体策略和抽象策略。抽象策略角色是一个（ C ）。

A.类 B抽象类 C.接口 D.子类

行为类模式使用( B )在类间分派行为。

A.接口 B.继承机制 C.对象组合 D.委托

以下哪个模式可以利用一个对象，快速地生成一批对象？（ C ）

A.抽象工厂模式 B.单例模式 C原型模式. D.简单工厂模式

模式设计题

1.排序策略问题策略模式

某系统提供了一个用于对数组数据进行操作的类，该类封装了对数组的常见操作，如查找数组元素、对数组元素进行排序等。现以排序操作为例，使用策略模式设计该数组操作类，使得客户端可以动态地更换排序算法，可以根据需要选择冒泡排序或选择排序或插入排序，也能够灵活地增加新的排序算法。

1.
public interface Sort
{
    public abstract int[] sort(int arr[]);
}

public class SelectionSort implements Sort
{
    public int[] sort(int arr[])
    {
       int len=arr.length;
       int temp;
       for(int i=0;i<len;i++)
       {
           temp=arr[i];
           int j;
           int samllestLocation=i;
           for(j=i+1;j<len;j++)
           {
              if(arr[j]<temp)
              {
                  temp=arr[j];
                  samllestLocation=j;
              }
           }
           arr[samllestLocation]=arr[i];
           arr[i]=temp;
       }
       System.out.println("选择排序");
       return arr;
    }
}

public class QuickSort implements Sort
{
    public int[] sort(int arr[])
    {
        System.out.println("快速排序");
        sort(arr,0,arr.length-1);
        return arr;
    }
 
    public void sort(int arr[],int p, int r)
    {
        int q=0;
        if(p<r)
        {
            q=partition(arr,p,r);
            sort(arr,p,q-1);
            sort(arr,q+1,r);
        }
    }
    
    public int partition(int[] a, int p, int r)
    {
        int x=a[r];
        int j=p-1;
        for(int i=p;i<=r-1;i++)
        {
            if(a[i]<=x)
            {
                j++;
                swap(a,j,i);
            }
        }
        swap(a,j+1,r);
        return j+1; 
    }
    
    public void swap(int[] a, int i, int j) 
    {   
        int t = a[i];   
        a[i] = a[j];   
        a[j] = t;   
    }
}

public class InsertionSort implements Sort
{
    public int[] sort(int arr[])
    {
       int len=arr.length;
       for(int i=1;i<len;i++)
       {
           int j;
           int temp=arr[i];
           for(j=i;j>0;j--)
           {
              if(arr[j-1]>temp)
              {
                  arr[j]=arr[j-1];
                  
              }else
                  break;
           }
           arr[j]=temp;
        }
        System.out.println("插入排序");
        return arr;
    }
}


2.
public class ArrayHandler
{
    private Sort sortObj;//关联接口
    
    //设置具体策略
    public void setSortObj(Sort sortObj) {
        this.sortObj = sortObj; 
    }
    
public int[] sort(int arr[])
    {
sortObj.sort(arr);
return arr;
    }
   
}

3.
public class Client
{
public static void main(String args[])
    {
       int arr[]={1,4,6,2,5,3,7,10,9};
       int result[];
       ArrayHandler ah=new ArrayHandler();
       
       Sort sort;
       sort=(Sort)XMLUtil.getBean();
       
       ah.setSortObj(sort); //设置具体策略
       result=ah.sort(arr);
       
       for(int i=0;i<result.length;i++)
       {
            System.out.print(result[i] + ",");
       }
    }
}

4.
配置文件config.xml：
<?xml version="1.0"?>
<config>
    <className>QuickSort</className>
</config>
    
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
public static Object getBean()
    {
try
    {
//创建文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("config.xml")); 

//获取包含类名的文本节点
NodeList nl = doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName=classNode.getNodeValue();
            
            //通过类名生成实例对象并将其返回
            Class c=Class.forName(cName);
      Object obj=c.newInstance();
            return obj;
           }   
           catch(Exception e)
            {
           e.printStackTrace();
           return null;
            }
    }
}

2.电视机工厂工厂方法模式

有一电视机工厂，生产各种电视机。现要将原有的工厂进行分割，为每种品牌的电视机提供一个子工厂，海尔工厂专门负责生产海尔电视机，海信工厂专门负责生产海信电视机；如果需要生产其他某个品牌电视机，只需要对应增加一个新的该品牌电视机工厂即可，而原有的工厂无须做任何修改，使得整个系统具有更加的灵活性和可扩展性。请使用工厂方法模式设计电视机工厂，要求画出模式结构和代码设计。

类似于水果工厂

3.windows回收站单例模式

windows回收站的创建模拟在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个唯一的实例，不管如何双击“回收站”图标，打开的回收站窗口始终是唯一的一个。请使用单例模式模拟windows回收站的创建。画出UML图、指出模式角色对应的类及java代码实现

public class RecycleBin{
    //首先，由于每次使用 new 关键字来实例化 RecycleBin 类时，都会产生一个新对象，为了确保实例的唯一性，我们得将 RecycleBin 的构造函数可见性改为 private。
    private RecycleBin() {} //初始化窗口
    
    //其次，虽然将可见性改为 private，可是内部还是可以创建的，因此我们需要定义一个静态的私有成员变量。
    private static RecycleBin recycle = null;
    
    //为了保证封装性，我们得把私有成员变量也改为 private，但外界该如何使用它呢？答案是增加一个公有的静态方法。
    public static RecycleBin getInstance(){
        if (recycle == null){
            recycle = new RecycleBin();
        }
        return recycle;
    }
    //需要注意的是 getInstance()方法的修饰符，它使用了 static 关键字，即它是一个静态方法，在类外可以直接通过类名来访问，而无须创建 RecycleBin 对象。


}
https://blog.51cto.com/u_15009303/2552816

4.KFC套餐建造者模式 OK

建造者模式可以用于描述KFC如何创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客。画出UML图、指出各角色及对应的类，并使用java代码编写模拟程序。

参考建造者模式的代码实现

5. 机器人适配器模式

现需要设计一个可以模拟各种动物行为的机器人，在机器人中定义了一系列方法，如机器人叫喊方法cry()、机器人移动方法move()等。如果希望在不修改已有代码的基础上使得机器人能够像狗一样叫，像狗一样跑，使用适配器模式进行系统设计。


//1.机器人
public interface Robot {
    public void cry();
    public void move();
}

//2.狗
public class Dog {
    public void wang(){
        System.out.println("dog wangwangwang");
    }
    public void run(){
        System.out.println("dog run");
    }
}

//3.对象适配器
public class DogAdapter implements Robot{

    Dog dog;
    
    public DogAdapter(Dog dog){ //取得要适配的对象的引用
        this.dog = dog;
    }
    
    @Override
    public void cry() {
        dog.wang();
        System.out.println("Robot cry");
    }

    @Override
    public void move() {
        dog.run();
        System.out.println("Robot move");
    }

}

//结果
public class main {
    public static void main(String[] args) {
        Dog dog =new Dog();
        Robot dogRobot = new DogAdapter(dog);

        dogRobot.cry();
        dogRobot.move();
    }
}

结果：

6.水果盘组合模式

在水果盘(Plate)中有一些水果，如苹果(Apple)、香蕉(Banana)、梨子(Pear)，当然大水果盘中还可以有小水果盘，现需要对盘中的水果进行遍历（吃），当然如果对一个水果盘执行“吃”方法，实际上就是吃其中的水果。使用组合模式模拟该场景。


public abstract class MyElement
{
    public abstract void eat();
}

public class Apple extends MyElement
{
    public void eat()
    {
        System.out.println("吃苹果！");
    }
}

public class Banana extends MyElement
{
    public void eat()
    {
        System.out.println("吃香蕉！");
    }
}

public class Pear extends MyElement
{
    public void eat()
    {
        System.out.println("吃梨子！");
    }
}


public class Plate extends MyElement
{
    private ArrayList list=new ArrayList();

    public void add(MyElement element)
    {
        list.add(element);  
    }

    public void delete(MyElement element)
    {
        list.remove(element);
    }

    public void eat()
    {
        for(Object object:list)
        {
            ((MyElement)object).eat();
        }
    }
}

public class Client
{
    public static void main(String a[])
    {
        MyElement obj1,obj2,obj3,obj4,obj5;
        Plate plate1,plate2,plate3;

        obj1=new Apple();
        obj2=new Pear();
        plate1=new Plate();
        plate1.add(obj1);
        plate1.add(obj2);

        obj3=new Banana();
        obj4=new Banana();
        plate2=new Plate();
        plate2.add(obj3);
        plate2.add(obj4);

        obj5=new Apple();
        plate3=new Plate();
        plate3.add(plate1);
        plate3.add(plate2);
        plate3.add(obj5);

        plate3.eat();
    }
}

7.票务中心代购车票代理模式

过年加班比较忙，没空去买火车票，这时可以打个电话到附近的票务中心，叫他们帮忙买张回家的火车票，当然这会附加额外的劳务费。但要清楚票务中心自己并不卖票，只有火车站才真正卖票，票务中心卖给你的票其实是到火车站买的。请使用代理模式模拟购票过程。

8.审批假条职责链模式

某OA系统需要提供一个假条审批的模块，如果员工请假天数小于3天，主任可以审批该假条；如果员工请假天数大于等于3天，小于10天，经理可以审批；如果员工请假天数大于等于10天，小于30天，总经理可以审批；如果超过30天，总经理也不能审批，提示相应的拒绝信息。

9.网站计数器单例模式

网站计数器是WEB应用程序的一项基本功能，用于统计使用网站或者应用程序的人数，可反映出网站或者应用程序的受欢迎程序，对于电子商务网站可信度的研究有一定的参考价值。请使用单例模式编写网站计数器程序。画出UML图、java代码实现。

10. 职责链模式

设计一个类，该类创建的对象使用BigInteger对象计算阶乘，特点是占用内存多，但是能计算任意大的整数的阶乘，计算速度相对较慢。要求使用责任链模式将上面的对象组成一个责任链，要求责任链上对象的顺序是：首先是使用int型数据计算阶乘的对象，然后是使用long型数据计算阶乘的对象，最后是使用BigInteger对象计算阶乘的对象。用户可以请求责任链计算一个整数的阶乘。

一级一级写