01-2023年上半年软件设计师考试java真题解析

1.真题内容

在某系统中，类 Interval(间隔) 代表由下界(lower bound(边界))上界(upper bound )定义的区间。
要求采用不同的格式显示区间范围。
如［lower bound , upper bound ]、[ lower bound … upper bound ]、[ lower bou nd - upper bound ］等。
现采用策略(strategy)模式实现该要求，得到如图5-1所示的类图。

2.策略模式(strategy) 191页

策略模式(strategy)：定义一系列算法，把它们一个个封装起来，并且使它们之间可以互相替换，从而让算法可以独立于使用它的用户而编号。

3.类图关系 167页

4.真题代码

import java.util.*;
enum TYPE { COMMA, DOTS, LINE };
interface PrintStrategy{      
    public (1) ;
}

class Interval  {
    private double lowerBound;   
    private double upperBound;  
    public Interval(double p_lower, double p_upper){lowerBound = p_lower; upperBound = p_upper;}
    public void printInterval(PrintStrategy ptr) {(2);} 
    public double getLower() { return lowerBound; }
    public double getUpper() { return upperBound; }
}

class PrintIntervalsComma implements PrintStrategy{ 
    public void doPrint(Interval val){System.out.println("[ " + val.getLower() + "," + val.getUpper()+"]");} 
}
class PrintIntervalsDots implements PrintStrategy {
    public void doPrint(Interval val) {System.out.println("[" + val.getLower() + "..." + val.getUpper() + "]"); }
}
class PrintIntervalsLine implements PrintStrategy {
    public void doPrint(Interval val) {System.out.println("[" + val.getLower() + "-" + val.getUpper() + "]");} 
}

class Strategy {
public static PrintStrategy getStrategy(TYPE type) {
    PrintStrategy st = null;
    switch (type) {
        case COMMA: 
            (3) 
            break;
        case DOTS:
            (4)
            break;
        case LINE:
            (5)
            break;
        }
    return st;
    }
}

public static void main(String[] args) {
    Interval a = new Interval(1.7, 2.1);
    a.printInterval(getStrategy(TYPE.COMMA));
    a.printInterval(getStrategy(TYPE.DOTS));
    a.printInterval(getStrategy(TYPE.LINE)); 
    }
}

5.题目解析

由图可知，PrintStrategy（打印策略）父类，它有3个子类。
分别为PrintIntervalsComma（打印间隔逗号）、PrintIntervalsDots（打印间隔点）、PrintIntervalsLine（打印间隔线）。

通过实心的菱形箭头判断，Interval(间隔)和PrintStrategy(打印策略)有一个1对多的关系。
推测，Interval(整体)里可能会有PrintStrategy(部分)。

观察代码：
enum TYPE { COMMA, DOTS, LINE }定义了一个枚举，枚举通常是常量。

PrintStrategy父接口缺失一个方法。
父接口中缺失的方法去它的子类中寻找。
在Comma中找到public void doPrint(Interval val)方法。
3个子类都有这个方法。
因此(1)void doPrint(Interval val)

Interval类中有一个public void printInterval方法，该方法传入了一个PrintStrategy对象ptr。
那第2空就是要调ptr做事情，ptr是PrintStrategy的对象，PrintStrategy只有一个方法doPrint。
doPrint方法需要传入Interval参数，现在就在Interval中，因此用this。
(2)ptr.doPrint(this)

用父接口PrintStrategy定义了一个变量st。
父接口定义的变量肯定是要去接子对象的。
这里是null，表示一会肯定有一个意义的参数要传进来。
如果type传进来的是COMMA，则把COMMA这个儿子传给父接口st。

6.代码解析

import java.util.*;
# import 是关键字，用于导入包或类。
# java.util 是包的名称，表示我们要导入的是 java.util包。
# * 是一个通配符，表示导入该包中的所有类。

enum TYPE { COMMA, DOTS, LINE };
# enum（枚举）是一种特殊的类，用于表示一组固定的常量值
# 三个枚举常量：COMMA（逗号）、DOTS（点）、LINE（线）

interface PrintStrategy{  
# interface: 关键字，用于定义一个接口。
# PrintStrategyt（打印策略）: 接口名。    
    public void doPrint(Interval val); // (1) 添加方法声明 答案在实现接口中找 
    # 父接口PrintStrategy中缺失的方法去它的子类中寻找。
    # 去class PrintIntervalsComma implements PrintStrateg找方法
    # 子类中只有public void doPrint(Interval val)1个方法
    # 因此(1)void doPrint(Interval val)
    # public: 这是一个访问修饰符，表示这个方法可以被任何其他类访问。
    # 因为interface里面的方法默认是public abstract的，因此这里public也可以省略， 
    # void：返回类型为，表示不返回任何值。
    # Interval：参数类型
    # val：参数名
    # 该方法接受一个名为 val（单位）的Interval（间隔）类型的参数
}

class Interval  {
# Interval:类名 

    private double lowerBound;  
    private double upperBound;  
    # 声明了一个名为 lowerBound 的私有成员变量。 
    # private：访问修饰符，表示这个变量只能在它所在的类内部访问。
    # 当一个类成员被声明为private时，外部类和对象无法直接访问或修改这个变量。
    # double是一种基本数据类型，用于表示双精度浮点数。
    # lowerBound(下边界) upperBound（上边界） 是私有实例变量。
    # lowerBound下界 upperBound上界
    
    public Interval(double p_lower, double p_upper){lowerBound = p_lower; upperBound = p_upper;}
    # 定义了一个构造函数，用于初始化 Interval 类的实例。
    # 构造函数语法示例：第一行class Person 第二行 public Person(String name) {this.name = name;}
    # 构造函数是一种特殊的方法，它的名字与类名相同，并且没有返回类型。
    # 这个构造函数允许在创建 Interval 类的实例时，通过参数直接设置 lowerBound 和 upperBound 的初始值。
    # 这个构造函数接收两个双精度浮点数 p_lower 和 p_upper，然后将它们分别赋值给类的成员变量 lowerBound 和 upperBound
    # Interval：构造函数
    # double p_lower, double p_upper参数列表
    # lowerBound、upperBound类的实例变量
    # p_lower、p_upper传入的参数

    public void printInterval(PrintStrategy ptr){ptr.doPrint(this);} // (2) 调用doPrint方法并传递当前对象
    # 定义一个名为 printInterval的方法，该方法接受一个PrintStrategy类型的参数ptr。
    # 调用该参数的 doPrint 方法，将当前对象（即 this）作为参数传递给 doPrint 方法。
    # printInterval方法传入了一个ptr对象，后面通常就要去调ptr的方法。
    # 去PrintStrategy中寻找，它只有一个方法doPrint。
    # doPrint需要传入Interval类型的参数。    
    # this 关键字引用的是当前对象，因为代码就在Interval类里。
    # 注意Interval val是定义的时候设置的形参，实际调用的时候用具体的数据传进去。
    # 当doPrint方法需要访问当前 Interval 对象的数据，可以使用this。
    # printInterval：方法名
    # PrintStrategy：参数类型
    # ptr：对象名
    # doPrint：方法名

    public double getLower() { return lowerBound; }
    public double getUpper() { return upperBound; }
    # public:表示该方法可以被任何其他类访问
    # double:这方法的返回类型，表示该方法将返回一个双精度浮点数（double）
    # getLower:方法的名。根据命名约定，方法名通常以小写字母开头，并使用驼峰命名法（camelCase）
    # 在这个例子中，getLower 暗示了这个方法的作用是获取某个值的下限（lower bound）
    # ():圆括号内可以包含参数列表。圆括号是空的，表示这个方法不接受任何参数

    # 花括号 {} 包围的方法体，包含了方法的具体实现
    # return lowerBound; 是方法体中的一条语句，表示返回一个名为 lowerBound 的变量的值。
    # 这个变量应该是在类的其他地方定义的一个成员变量     
}


class PrintIntervalsComma implements PrintStrategy{ 
# 具体的实现类
# PrintIntervalsComma:类的名称。
# implements:表示一个类实现了某个接口。接口定义了一组方法，这些方法必须在实现该接口的类中被实现。
# PrintStrategy:这是接口的名称。接口是一种抽象类型，定义了一组方法，但不提供其具体实现。

    public void doPrint(Interval val){System.out.println("[ " + val.getLower() + "," + val.getUpper()+"]");} 
}
# doPrint:方法名。在这个例子中，doPrint 暗示这个方法的作用是执行打印操作。
# Interval：参数类型。
# val：参数名。
# doPrint方法接受一个名为 val 的参数，其类型是 Interval。

# System.out.println 是一个标准输出方法，用于将文本输出到控制台。
# "[ " + val.getLower() + "," + val.getUpper()+"]" 是拼接字符串，表示要输出的内容。
# val.getLower() 调用 val 对象的 getLower 方法，获取区间的下界。

class PrintIntervalsDots implements PrintStrategy {
    public void doPrint(Interval val) {System.out.println("[" + val.getLower() + "..." + val.getUpper() + "]"); }
}
class PrintIntervalsLine implements PrintStrategy {
    public void doPrint(Interval val) {System.out.println("[" + val.getLower() + "-" + val.getUpper() + "]");} 
}

class Strategy {
    public static PrintStrategy getStrategy(TYPE type) {
    # getStrategy方法接受一个TYPE枚举值作为参数，并根据这个值返回相应的PrintStrategy实现类。
    # static:关键字，表示该方法属于类本身，而不是类的实例。静态方法可以直接通过类名调用，而不需要创建类的实例。
    # 如果PrintStrategy是一个工具类，你可以直接使用PrintStrategy getStrategy(type)来获取策略。
    # 而不需要先创建一个PrintStrategy对象。
    # PrintStrategy:这是方法的返回类型，表示该方法将返回一个 PrintStrategy类型的对象。
    # getStrategy:方法名。在这个例子中，getStrategy 表示这个方法的作用是根据传入的类型获取相应的打印策略。
    # TYPE：参数类型
    # type：参数名

    PrintStrategy st = null;
    # 声明并初始化一个名为 st 的变量。
    # PrintStrategy：类型声明。
    # PrintStrategy 是一个类或接口的名称，它表示变量 st 的类型。
    # 在 Java 中，类型可以是基本数据类型（如 int, double），也可以是用户定义的类或接口。
    # st 是变量的名称
    # null 是变量 st 的初始值。null 是一个特殊的字面量，表示对象引用不指向任何对象。

    switch (type) {
    # switch ：控制流语句，根据变量的值执行不同的代码块。
    # 在这里，它基于 type 的值选择不同的分支。

        case COMMA: 
        # case 关键字用于定义 switch 语句的一个分支。
        # 如果 type 的值是 COMMA，则执行该分支内的代码。

            st = new PrintIntervalsComma(); // (3) 实例化正确的类
            #如果 type 的值是 COMMA，则实例化一个 PrintIntervalsComma 对象，并将其赋值给 st 变量。
            # st是PrintStrategy类型的
            # PrintIntervalsComma是一个实现了 PrintStrategy接口的类
            # 推测（3）是要创建一个具体的实例化对象
            break;
            # break 语句用于终止当前的 case 分支，防止继续执行后续的 case 分支。       
       
        case DOTS:
            st = new PrintIntervalsDots(); // (4) 实例化正确的类
            break;
        case LINE:
            st = new PrintIntervalsLine(); // (5) 实例化正确的类
            break;
        }
    return st;
    }
}

public static void main(String[] args) {
# 程序入口点
    Interval a = new Interval(1.7, 2.1);
    # 声明一个名为a的变量，其类型为 Interval。
    # 使用 new 关键字调用Interval类的构造函数，并传递两个参数 1.7和2.1。
    # 将创建的 Interval对象赋值给变量a。   
   
    a.printInterval(getStrategy(TYPE.COMMA));
    a.printInterval(getStrategy(TYPE.DOTS));
    a.printInterval(getStrategy(TYPE.LINE)); 
    # 调用 a 对象的 printInterval 方法。
    # 将 getStrategy(TYPE.LINE) 的返回值作为参数传递给 printInterval 方法。
    # a：变量名
    # printInterval：方法名，用于打印区间信息。
    # getStrategy(TYPE.LINE)方法调用，调用 getStrategy方法，并传递 TYPE.LINE 作为参数。
    # 这个方法返回一个实现了某个策略接口或抽象类的实例。
    # TYPE.LINE： 枚举常量
    }
}