.class
.jar
.java
.exe
Java 源代码通常保存为 .java 文件；编译后的字节码通常是 .class 文件。
java Hello.java
jar Hello.java
jdb Hello.java
javac Hello.java
javac 是 Java 编译器命令，负责把源文件编译为字节码。
public void main(String[] args)
public static void main(String[] args)
public static main(String[] args)
static void main()
传统标准入口方法是 public static void main(String[] args)，其中 static 表示无需创建对象即可调用。
JDK 包含 JRE，JRE 包含 JVM
"},{"key":"B","text":"JRE 包含 JDK，JDK 包含 JVM","html":"JRE 包含 JDK，JDK 包含 JVM
"},{"key":"C","text":"JDK 只包含 JVM，不包含 JRE","html":"JDK 只包含 JVM，不包含 JRE
"},{"key":"D","text":"JVM 包含 JDK 和 JRE","html":"JVM 包含 JDK 和 JRE
"}],"answer":"A","answerText":"A JDK 包含 JRE，JRE 包含 JVM","explanation":"按照常见的概念关系，JDK 包含运行环境，JRE 包含 JVM；新版本 JDK 的实际目录结构可能不同。","explanationHtml":"按照常见的概念关系，JDK 包含运行环境，JRE 包含 JVM；新版本 JDK 的实际目录结构可能不同。
","important":false},{"id":"java-q5","number":5,"type":"choice","chapter":"Java 基础与开发环境","title":"下列各项中，不属于 Java 语言特点的是（ ）。","titleHtml":"下列各项中，不属于 Java 语言特点的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"支持运算符重载","html":"支持运算符重载
"},{"key":"B","text":"面向对象","html":"面向对象
"},{"key":"C","text":"跨平台","html":"跨平台
"},{"key":"D","text":"自动垃圾回收","html":"自动垃圾回收
"}],"answer":"A","answerText":"A 支持运算符重载","explanation":"Java 不支持用户自定义的运算符重载；面向对象、跨平台和自动垃圾回收都是其典型特点。","explanationHtml":"Java 不支持用户自定义的运算符重载；面向对象、跨平台和自动垃圾回收都是其典型特点。
","important":false},{"id":"java-q6","number":6,"type":"choice","chapter":"Java 基础与开发环境","title":"Hello.class 已经存在，执行命令 java Hello 时，下列说法正确的是（ ）。","titleHtml":"Hello.class 已经存在，执行命令 java Hello 时，下列说法正确的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"重新编译 Hello.java 并生成新的字节码","html":"重新编译 Hello.java 并生成新的字节码
"},{"key":"B","text":"启动 JVM，加载并运行 Hello 类的 main 方法","html":"启动 JVM，加载并运行 Hello 类的 main 方法
"},{"key":"C","text":"只检查 Hello.java 的语法，不执行程序","html":"只检查 Hello.java 的语法，不执行程序
"},{"key":"D","text":"把 Hello.class 反编译为 Hello.java","html":"把 Hello.class 反编译为 Hello.java
"}],"answer":"B","answerText":"B 启动 JVM，加载并运行 Hello 类的 main 方法","explanation":"java Hello 启动 JVM，加载 Hello 类并执行其入口方法，而不是重新编译源码。","explanationHtml":"java Hello 启动 JVM，加载 Hello 类并执行其入口方法，而不是重新编译源码。
编译成功，生成 Hello.class
"},{"key":"B","text":"编译成功，生成 Test.class","html":"编译成功，生成 Test.class
"},{"key":"C","text":"编译错误，public 类名必须与源文件名一致","html":"编译错误，public 类名必须与源文件名一致
"},{"key":"D","text":"编译成功，但运行时必须使用 Test 类名","html":"编译成功，但运行时必须使用 Test 类名
"}],"answer":"C","answerText":"C 编译错误，public 类名必须与源文件名一致","explanation":"顶级 public 类 Hello 必须声明在名为 Hello.java 的源文件中。","explanationHtml":"顶级 public 类 Hello 必须声明在名为 Hello.java 的源文件中。
JDK 安装目录下的 bin 目录
"},{"key":"B","text":"任意一个包含 .java 文件的目录","html":"任意一个包含 .java 文件的目录
"},{"key":"C","text":"项目的 src 目录","html":"项目的 src 目录
"},{"key":"D","text":"JDK 的安装根目录","html":"JDK 的安装根目录
"}],"answer":"D","answerText":"D JDK 的安装根目录","explanation":"JAVA_HOME 一般设置为 JDK 的安装根目录；需要使用命令行工具时，通常将其 bin 目录加入 PATH。","explanationHtml":"JAVA_HOME 一般设置为 JDK 的安装根目录；需要使用命令行工具时，通常将其 bin 目录加入 PATH。
Java 源程序无需编译即可在所有操作系统上直接运行
"},{"key":"B","text":"JDK 会为每个操作系统自动生成对应的 .exe 文件","html":"JDK 会为每个操作系统自动生成对应的 .exe 文件
"},{"key":"C","text":"Java 语言没有数据类型，因此不存在平台差异","html":"Java 语言没有数据类型，因此不存在平台差异
"},{"key":"D","text":"Java 源程序被编译为平台无关的字节码，由各平台上的 JVM 负责执行","html":"Java 源程序被编译为平台无关的字节码，由各平台上的 JVM 负责执行
"}],"answer":"D","answerText":"D Java 源程序被编译为平台无关的字节码，由各平台上的 JVM 负责执行","explanation":"源码编译为平台无关的字节码，操作系统上对应的 JVM 执行字节码。","explanationHtml":"源码编译为平台无关的字节码，操作系统上对应的 JVM 执行字节码。
","important":false},{"id":"java-q10","number":10,"type":"choice","chapter":"Java 基础与开发环境","title":"某源文件首行为 package com.demo;，编译后的 Hello.class 位于 com\\demo 目录中。在 com 目录的父目录下，运行该类的正确命令是（ ）。","titleHtml":"某源文件首行为 package com.demo;，编译后的 Hello.class 位于 com\\demo 目录中。在 com 目录的父目录下，运行该类的正确命令是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"java com\\demo\\Hello.java","html":"java com\\demo\\Hello.java
javac com.demo.Hello
java com.demo.Hello
java Hello
包中的类应使用完全限定类名 com.demo.Hello 启动，且类路径根目录应是 com 的父目录。
2sum
sum-1
class
_sum1
标识符不能以数字开头、不能含减号、不能使用关键字；_sum1 符合规则。
class
String
main
args
class 是定义类的关键字，String 是类名，main 和 args 不是关键字。
/* 注释内容 */
// 注释内容
（原文件缺失）
"},{"key":"D","text":"# 注释内容","html":"# 注释内容
Java 单行注释以 // 开始；/* ... */ 属于块注释语法。原文件缺少 C 选项。
const double PI = 3.14;
final double PI = 3.14;
static PI = 3.14;
int PI = 3.14;
使用 final 修饰变量可限制其再次赋值；const 不是 Java 中使用的变量声明关键字。
double
float
int
long
没有 f 或 F 后缀的十进制浮点字面量默认是 double。
int x = 3.9;
int x = (int) 3.9;
int x = 3.9f;
int x = Integer(3.9);
从 double 到 int 属于窄化转换，需要显式强制转换；结果为 3，不会四舍五入。
3.33
4
1
3
两个 int 相除仍执行整数除法，10 / 3 舍弃小数部分得到 3。
0
3
1
3.33
% 返回整数除法的余数，10 = 3 × 3 + 1。
true
编译错误
"},{"key":"C","text":"false","html":"false
1
逻辑与 && 要求两边均为 true 才为真，因此结果为 false。
int a[5];
int[] a = new int(5);
int a = new int[5];
int[] a = new int[5];
定义数组时方括号表示数组类型，new int[5] 才表示创建长度为 5 的整型数组。
1
-1
0
数组长度
"}],"answer":"C","answerText":"C 0","explanation":"Java 数组从索引 0 开始，最后一个有效索引是 length - 1。","explanationHtml":"Java 数组从索引 0 开始，最后一个有效索引是 length - 1。
2
4
编译错误
"},{"key":"D","text":"3","html":"3
数组初始化器中有三个元素，所以 a.length 为 3。
int
String
任意类型
"},{"key":"D","text":"boolean","html":"boolean
Java 的 if 条件必须是 boolean 表达式，不接受整数代替布尔值。
3 次
"},{"key":"B","text":"2 次","html":"2 次
"},{"key":"C","text":"4 次","html":"4 次
"},{"key":"D","text":"0 次","html":"0 次
"}],"answer":"A","answerText":"A 3 次","explanation":"循环变量依次为 0、1、2，共执行三次。","explanationHtml":"循环变量依次为 0、1、2，共执行三次。
int
char
double
String
switch 支持整数相关类型、char、String、枚举等，但不支持 double。
byte b = 10;\nb = b + 1;编译成功，b 的值为 11
"},{"key":"B","text":"编译错误，b + 1 的结果类型为 int，赋值给 byte 需要强制类型转换","html":"编译错误，b + 1 的结果类型为 int，赋值给 byte 需要强制类型转换
"},{"key":"C","text":"编译成功，但运行时抛出异常","html":"编译成功，但运行时抛出异常
"},{"key":"D","text":"编译成功，b 的值溢出为 0","html":"编译成功，b 的值溢出为 0
"}],"answer":"B","answerText":"B 编译错误，b + 1 的结果类型为 int，赋值给 byte 需要强制类型转换","explanation":"表达式 b + 1 会发生整数提升，结果是 int，不能直接赋给 byte。","explanationHtml":"表达式 b + 1 会发生整数提升，结果是 int，不能直接赋给 byte。
System.out.println(1 + 2 + "3");33
123
6
编译错误
"}],"answer":"A","answerText":"A 33","explanation":"先计算 1 + 2 得到 3，再与字符串 \"3\" 连接，输出 33。","explanationHtml":"先计算 1 + 2 得到 3，再与字符串 "3" 连接，输出 33。
null、null、null
1、2、3
0、0、0
随机值
"}],"answer":"C","answerText":"C 0、0、0","explanation":"新创建的 int 数组元素具有默认值 0，而不是未初始化的随机值。","explanationHtml":"新创建的 int 数组元素具有默认值 0，而不是未初始化的随机值。
5
6
2
3
外层数组长度为 2，首个内层数组长度为 3，因此结果为 5。
int x = 2;\nswitch (x) {\n case 1: System.out.print("A");\n case 2: System.out.print("B");\n case 3: System.out.print("C"); break;\n default: System.out.print("D");\n}AB
BC
BCD
C
匹配 case 2 后输出 B，由于没有 break 继续执行 case 3 输出 C，随后退出。
int i = 0;\nwhile (i < 5) {\n i += 2;\n}\nSystem.out.println(i);6
4
5
0
i 依次变为 2、4、6，达到 6 后循环条件为假。
int i = 5;\ndo {\n System.out.print(i);\n i++;\n} while (i < 3);不输出任何内容
"},{"key":"B","text":"56","html":"56
5
无限循环
"}],"answer":"C","answerText":"C 5","explanation":"do-while 先执行循环体，再检查条件，所以即使初始条件不成立也会输出一次 5。","explanationHtml":"do-while 先执行循环体，再检查条件，所以即使初始条件不成立也会输出一次 5。
for (int i = 1; i <= 5; i++) {\n if (i % 2 == 0) continue;\n System.out.print(i);\n}12345
24
135
1234
continue 跳过偶数对应的打印操作，因此仅输出 1、3、5。
for (int i = 1; i <= 5; i++) {\n if (i == 3) break;\n System.out.print(i);\n}123
1245
3
12
当 i == 3 时先执行 break，因此只输出 1、2。
int x = 5;\nint y = 2 + 3 * 4 > 10 && 5 != 5 ? 1 : 0;1
14
编译错误
"},{"key":"D","text":"0","html":"0
2 + 3 * 4 > 10 为真，但 5 != 5 为假，&& 得到假，三元表达式取 0。
int[] a = {1, 2, 3};\nint[] b = a;\nb[0] = 9;\nSystem.out.println(a[0]);1
9
3
编译错误
"}],"answer":"B","answerText":"B 9","explanation":"a 与 b 指向同一个数组，修改 b[0] 会影响 a[0]。","explanationHtml":"a 与 b 指向同一个数组，修改 b[0] 会影响 a[0]。
Scanner sc = new Scanner(System.in);\nint age = sc.nextInt();\nString name = sc.nextLine();\nSystem.out.println(name.length());3
0
18
运行时抛出异常
"}],"answer":"B","answerText":"B 0","explanation":"nextInt() 读取 18 后没有消费行末换行符，紧接着的 nextLine() 读取空行，长度为 0。","explanationHtml":"nextInt() 读取 18 后没有消费行末换行符，紧接着的 nextLine() 读取空行，长度为 0。
System.out.println('A' + 1);B
65
66
编译错误
"}],"answer":"C","answerText":"C 66","explanation":"char 与整数进行算术运算时转换为数值，字符 A 的编码值是 65，加 1 为 66。","explanationHtml":"char 与整数进行算术运算时转换为数值，字符 A 的编码值是 65，加 1 为 66。
int i = 0;\nboolean flag = (i++ > 0) && (++i > 0);\nSystem.out.println(i + "," + flag);0,false
2,false
2,true
1,false
i++ > 0 用旧值 0 比较，结果为假，但 i 变为 1；&& 短路，右侧不执行。
outer:\nfor (int i = 1; i <= 3; i++) {\n for (int j = 1; j <= 3; j++) {\n if (i * j > 4) break outer;\n System.out.print(i * j + " ");\n }\n}1 2 3 2 4 6
1 2 3 2 4
1 2 3 4
1 2 3 2 4 6 9
依次输出 1 2 3 2 4，遇到 2 × 3 > 4 时执行 break outer，直接退出两层循环。
class
Class
struct
interface
类声明使用小写关键字 class，Java 区分大小写。
Person p = new Person();
Person p = Person();
new Person p;
Person p = new();
new Person() 调用无参构造方法，生成 Person 对象，并可将引用赋给变量 p。
null
void
int
empty
不返回结果的方法声明返回类型为 void。
结束当前方法的执行，并将控制权返回调用处
"},{"key":"B","text":"只能出现在 main 方法中","html":"只能出现在 main 方法中
"},{"key":"C","text":"结束整个 Java 程序的运行","html":"结束整个 Java 程序的运行
"},{"key":"D","text":"只能用于返回字符串","html":"只能用于返回字符串
"}],"answer":"A","answerText":"A 结束当前方法的执行，并将控制权返回调用处","explanation":"return 立即结束当前方法并返回调用位置；它不必然终止整个程序。","explanationHtml":"return 立即结束当前方法并返回调用位置；它不必然终止整个程序。
与所在类的类名相同
"},{"key":"B","text":"与所在类的对象名相同","html":"与所在类的对象名相同
"},{"key":"C","text":"固定为 init","html":"固定为 init
"},{"key":"D","text":"与所在类的父类名相同","html":"与所在类的父类名相同
"}],"answer":"A","answerText":"A 与所在类的类名相同","explanation":"构造方法必须与所在类同名，并且没有返回类型。","explanationHtml":"构造方法必须与所在类同名，并且没有返回类型。
","important":false},{"id":"java-q46","number":46,"type":"choice","chapter":"类、对象、方法与访问权限","title":"如果一个类没有显式定义任何构造方法，则 Java 会（ ）。","titleHtml":"如果一个类没有显式定义任何构造方法，则 Java 会（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"不提供任何构造方法，因此无法创建对象","html":"不提供任何构造方法，因此无法创建对象
"},{"key":"B","text":"自动提供一个带一个 int 参数的构造方法","html":"自动提供一个带一个 int 参数的构造方法
"},{"key":"C","text":"直接导致编译错误","html":"直接导致编译错误
"},{"key":"D","text":"自动提供一个无参的默认构造方法","html":"自动提供一个无参的默认构造方法
"}],"answer":"D","answerText":"D 自动提供一个无参的默认构造方法","explanation":"如果一个类未声明任何构造方法，编译器会提供默认无参构造方法。","explanationHtml":"如果一个类未声明任何构造方法，编译器会提供默认无参构造方法。
","important":false},{"id":"java-q47","number":47,"type":"choice","chapter":"类、对象、方法与访问权限","title":"方法重载指的是（ ）。","titleHtml":"方法重载指的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"方法名不同而参数列表相同","html":"方法名不同而参数列表相同
"},{"key":"B","text":"只有返回值类型不同","html":"只有返回值类型不同
"},{"key":"C","text":"在同一个类中，方法名相同而参数列表不同","html":"在同一个类中，方法名相同而参数列表不同
"},{"key":"D","text":"子类对父类方法重新实现","html":"子类对父类方法重新实现
"}],"answer":"C","answerText":"C 在同一个类中，方法名相同而参数列表不同","explanation":"重载要求方法名相同、参数列表不同；仅更换返回类型不能构成重载。","explanationHtml":"重载要求方法名相同、参数列表不同；仅更换返回类型不能构成重载。
","important":false},{"id":"java-q48","number":48,"type":"choice","chapter":"类、对象、方法与访问权限","title":"在 Java 源文件开头声明包 com.demo，正确的语句是（ ）。","titleHtml":"在 Java 源文件开头声明包 com.demo，正确的语句是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"package com.demo;","html":"package com.demo;
import com.demo;
namespace com.demo;
class com.demo;
声明包使用 package，通常放在源文件的开头（注释除外）。
package java.util.Scanner;
import java.util.Scanner;
using java.util.Scanner;
include java.util.Scanner;
Scanner 的完整类名是 java.util.Scanner，通过 import 导入。
public
protected
private
默认(不写修饰符)
"}],"answer":"C","answerText":"C private","explanation":"private 将成员访问限制在声明类的访问范围内，通常比包访问、protected 和 public 更严格。","explanationHtml":"private 将成员访问限制在声明类的访问范围内，通常比包访问、protected 和 public 更严格。
new Person().getName()
Person->getName()
getName()
Person.getName()
静态成员归类所有，应优先使用 Person.getName() 的“类名.方法名”形式调用。
每个对象各有一份副本
"},{"key":"B","text":"被该类的所有对象共享","html":"被该类的所有对象共享
"},{"key":"C","text":"只能在构造方法中访问","html":"只能在构造方法中访问
"},{"key":"D","text":"必须同时用 final 修饰","html":"必须同时用 final 修饰
"}],"answer":"B","answerText":"B 被该类的所有对象共享","explanation":"static 字段属于类；对象不是各自维护独立的字段副本。","explanationHtml":"static 字段属于类；对象不是各自维护独立的字段副本。
从声明处开始，到所在方法或代码块结束
"},{"key":"B","text":"整个 Java 程序","html":"整个 Java 程序
"},{"key":"C","text":"该类的所有对象","html":"该类的所有对象
"},{"key":"D","text":"父类和子类","html":"父类和子类
"}],"answer":"A","answerText":"A 从声明处开始，到所在方法或代码块结束","explanation":"局部变量一般从声明位置开始，在所属作用域结束时不再可见。","explanationHtml":"局部变量一般从声明位置开始，在所属作用域结束时不再可见。
","important":false},{"id":"java-q54","number":54,"type":"choice","chapter":"类、对象、方法与访问权限","title":"已知对象 p 有可访问的成员变量 name，访问该成员变量的正确写法是（ ）。","titleHtml":"已知对象 p 有可访问的成员变量 name，访问该成员变量的正确写法是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"p->name","html":"p->name
p::name
p[name]
p.name
Java 使用点号 . 访问对象的可访问成员。
每次创建对象时执行
"},{"key":"B","text":"类加载时执行，并且只执行一次","html":"类加载时执行，并且只执行一次
"},{"key":"C","text":"每次调用静态方法时执行","html":"每次调用静态方法时执行
"},{"key":"D","text":"程序退出时执行","html":"程序退出时执行
"}],"answer":"B","answerText":"B 类加载时执行，并且只执行一次","explanation":"静态初始化块随类初始化执行，正常情况下每个类加载器只执行一次；准确地说是“类初始化时”，而不只是装载字节码时。","explanationHtml":"静态初始化块随类初始化执行，正常情况下每个类加载器只执行一次；准确地说是“类初始化时”，而不只是装载字节码时。
","important":false},{"id":"java-q56","number":56,"type":"choice","chapter":"类、对象、方法与访问权限","title":"下列哪一组方法构成了合法的重载（ ）。","titleHtml":"下列哪一组方法构成了合法的重载（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"void print(int x) 与 void print(String s)","html":"void print(int x) 与 void print(String s)
"},{"key":"B","text":"void print(int x) 与 int print(int x)","html":"void print(int x) 与 int print(int x)
"},{"key":"C","text":"void print(int x) 与 void print(int y)","html":"void print(int x) 与 void print(int y)
"},{"key":"D","text":"void print(int x) 与 static void print(int x)","html":"void print(int x) 与 static void print(int x)
"}],"answer":"A","answerText":"A void print(int x) 与 void print(String s)","explanation":"print(int) 与 print(String) 方法名相同，但参数类型不同，构成合法重载。","explanationHtml":"print(int) 与 print(String) 方法名相同，但参数类型不同，构成合法重载。
class Test {\n int x = 10;\n static void show() {\n System.out.println(x);\n }\n}输出 10
"},{"key":"B","text":"输出 0","html":"输出 0
"},{"key":"C","text":"编译错误，静态方法不能直接访问实例变量 x","html":"编译错误，静态方法不能直接访问实例变量 x
"},{"key":"D","text":"运行时抛出 NullPointerException","html":"运行时抛出 NullPointerException
"}],"answer":"C","answerText":"C 编译错误，静态方法不能直接访问实例变量 x","explanation":"实例字段 x 依附于对象；静态方法中没有 this，不能直接读取 x。","explanationHtml":"实例字段 x 依附于对象；静态方法中没有 this，不能直接读取 x。
class Init {\n static int a = 1;\n static { a = 2; }\n static { a += 3; }\n public static void main(String[] args) {\n System.out.println(a);\n }\n}1
2
3
5
类初始化按代码顺序进行：a 先为 1，再赋为 2，最后增加 3 得到 5。
class Demo {\n static void change(int x) {\n x = 100;\n }\n public static void main(String[] args) {\n int a = 10;\n change(a);\n System.out.println(a);\n }\n}100
10
0
编译错误
"}],"answer":"B","answerText":"B 10","explanation":"Java 使用值传递，change 修改的只是形参 x，原变量 a 仍为 10。","explanationHtml":"Java 使用值传递，change 修改的只是形参 x，原变量 a 仍为 10。
class Demo {\n static void change(int[] arr) {\n arr[0] = 100;\n }\n public static void main(String[] args) {\n int[] a = {1, 2};\n change(a);\n System.out.println(a[0]);\n }\n}100
1
2
编译错误
"}],"answer":"A","answerText":"A 100","explanation":"传入的是数组引用的副本，两个引用指向同一数组；修改数组元素会反映到调用者。","explanationHtml":"传入的是数组引用的副本，两个引用指向同一数组；修改数组元素会反映到调用者。
","important":false},{"id":"java-q61","number":61,"type":"choice","chapter":"类、对象、方法与访问权限","title":"类 A 和类 B 位于同一个包中。类 A 中有一个不使用访问修饰符的成员变量 x，则类 B（ ）。","titleHtml":"类 A 和类 B 位于同一个包中。类 A 中有一个不使用访问修饰符的成员变量 x，则类 B（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"不能访问 x，因为 x 是私有的","html":"不能访问 x，因为 x 是私有的
"},{"key":"B","text":"只有在继承 A 后才能访问 x","html":"只有在继承 A 后才能访问 x
"},{"key":"C","text":"必须通过反射才能访问 x","html":"必须通过反射才能访问 x
"},{"key":"D","text":"可以直接访问 x","html":"可以直接访问 x
"}],"answer":"D","answerText":"D 可以直接访问 x","explanation":"不写访问修饰符表示包级访问权限，同包中的其他类可以访问该成员（仍需适当的对象引用）。","explanationHtml":"不写访问修饰符表示包级访问权限，同包中的其他类可以访问该成员（仍需适当的对象引用）。
","important":false},{"id":"java-q62","number":62,"type":"choice","chapter":"类、对象、方法与访问权限","title":"一个被 private 修饰的成员变量，可以被哪些类直接访问（ ）。","titleHtml":"一个被 private 修饰的成员变量，可以被哪些类直接访问（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"同包中的所有类","html":"同包中的所有类
"},{"key":"B","text":"该类的所有子类","html":"该类的所有子类
"},{"key":"C","text":"只有声明该成员变量的类","html":"只有声明该成员变量的类
"},{"key":"D","text":"任何类","html":"任何类
"}],"answer":"C","answerText":"C 只有声明该成员变量的类","explanation":"本题考查 private 的一般限制：外部普通类不能直接访问该字段；嵌套类之间存在特殊访问规则。","explanationHtml":"本题考查 private 的一般限制：外部普通类不能直接访问该字段；嵌套类之间存在特殊访问规则。
int sign(int x) {\n if (x > 0) return 1;\n else if (x < 0) return -1;\n}编译成功，x 等于 0 时自动返回 0
"},{"key":"B","text":"编译成功，x 等于 0 时返回 -1","html":"编译成功，x 等于 0 时返回 -1
"},{"key":"C","text":"该代码编译错误，因为 x 等于 0 时没有返回值","html":"该代码编译错误，因为 x 等于 0 时没有返回值
"},{"key":"D","text":"编译可以通过，只有运行时才可能出错","html":"编译可以通过，只有运行时才可能出错
"}],"answer":"C","answerText":"C 该代码编译错误，因为 x 等于 0 时没有返回值","explanation":"当 x == 0 时两个分支都不返回值，而方法声明返回 int，故编译时会报“缺少返回语句”。","explanationHtml":"当 x == 0 时两个分支都不返回值，而方法声明返回 int，故编译时会报“缺少返回语句”。
Person[] ps = new Person[3];\nSystem.out.println(ps[0]);编译错误
"},{"key":"B","text":"null","html":"null
0
一个默认创建的 Person 对象
"}],"answer":"B","answerText":"B null","explanation":"new Person[3] 只创建保存引用的数组，不会自动实例化三个 Person 对象；各元素初值为 null。","explanationHtml":"new Person[3] 只创建保存引用的数组，不会自动实例化三个 Person 对象；各元素初值为 null。
class Data {\n int x;\n boolean flag;\n String s;\n}x 为 0，flag 为 true，s 为空字符串
"},{"key":"B","text":"x 为 0，flag 为 false，s 为 null","html":"x 为 0，flag 为 false，s 为 null
"},{"key":"C","text":"x 为 1，flag 为 false，s 为 null","html":"x 为 1，flag 为 false，s 为 null
"},{"key":"D","text":"三个变量都未初始化，无法访问","html":"三个变量都未初始化，无法访问
"}],"answer":"B","answerText":"B x 为 0，flag 为 false，s 为 null","explanation":"实例字段的默认值分别为：int → 0，boolean → false，引用类型 String → null。","explanationHtml":"实例字段的默认值分别为：int → 0，boolean → false，引用类型 String → null。
A a = new A(); a.f();
A.f;
new A().f;
A->f();
Java 允许经由对象引用调用可访问的静态方法，因此 A 能运行；规范写法是 A.f()。
class A {\n static int x = 1;\n void show() {\n System.out.println(x);\n }\n public static void main(String[] args) {\n new A().show();\n }\n}0
编译错误，实例方法不能访问静态变量
"},{"key":"C","text":"1","html":"1
运行时异常
"}],"answer":"C","answerText":"C 1","explanation":"实例方法可以访问类的静态变量，因此 show() 输出 1。","explanationHtml":"实例方法可以访问类的静态变量，因此 show() 输出 1。
class Init {\n static int a = 10;\n static { a = 20; }\n static int b = a + 5;\n static { b++; }\n public static void main(String[] args) {\n System.out.println(a + "," + b);\n }\n}20,25
10,15
20,26
10,16
先得 a = 20，接着计算 b = a + 5 = 25，最后静态块执行 b++，所以输出 20,26。
class Demo {\n void f(Object o) { System.out.print("Object"); }\n void f(String s) { System.out.print("String"); }\n public static void main(String[] args) {\n new Demo().f(null);\n }\n}Object
编译错误，调用存在歧义
"},{"key":"C","text":"运行时抛出 NullPointerException","html":"运行时抛出 NullPointerException
"},{"key":"D","text":"String","html":"String
实参 null 同时匹配 Object 和 String，编译器优先选择参数类型更具体的 f(String)。
class Box {\n int v;\n Box(int value) { v = value; }\n}\nclass Demo {\n static void change(Box b) {\n b = new Box(99);\n }\n public static void main(String[] args) {\n Box b = new Box(1);\n change(b);\n System.out.println(b.v);\n }\n}99
0
1
编译错误
"}],"answer":"C","answerText":"C 1","explanation":"change 中只是让形参 b 指向新对象，调用者的变量仍指向 Box(1)，所以输出 1。","explanationHtml":"change 中只是让形参 b 指向新对象，调用者的变量仍指向 Box(1)，所以输出 1。
extends
implements
import
super
Java 中类继承类使用 extends；实现接口用 implements。
不能直接访问，但父类提供的公共访问方法可以间接操作它
"},{"key":"B","text":"可以直接访问","html":"可以直接访问
"},{"key":"C","text":"只能通过 super 直接访问","html":"只能通过 super 直接访问
"},{"key":"D","text":"会自动变为 protected","html":"会自动变为 protected
"}],"answer":"A","answerText":"A 不能直接访问，但父类提供的公共访问方法可以间接操作它","explanation":"父类的 private 字段无法在子类代码中直接访问，但可借助父类公开的访问方法间接使用。","explanationHtml":"父类的 private 字段无法在子类代码中直接访问，但可借助父类公开的访问方法间接使用。
方法名相同即可，参数列表可以不同
"},{"key":"B","text":"方法名和参数列表相同，返回类型相同或是父类方法返回类型的子类型","html":"方法名和参数列表相同，返回类型相同或是父类方法返回类型的子类型
"},{"key":"C","text":"返回值类型必须与父类方法完全相同","html":"返回值类型必须与父类方法完全相同
"},{"key":"D","text":"重写方法必须使用 static 修饰","html":"重写方法必须使用 static 修饰
"}],"answer":"B","answerText":"B 方法名和参数列表相同，返回类型相同或是父类方法返回类型的子类型","explanation":"重写通常要求相同方法名和参数列表；引用类型的返回值可以采用协变返回类型，另有访问权限等限制。","explanationHtml":"重写通常要求相同方法名和参数列表；引用类型的返回值可以采用协变返回类型，另有访问权限等限制。
","important":false},{"id":"java-q74","number":74,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"在子类构造方法中，使用 super(参数) 的作用是（ ）。","titleHtml":"在子类构造方法中，使用 super(参数) 的作用是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"调用当前类的其他构造方法","html":"调用当前类的其他构造方法
"},{"key":"B","text":"创建父类的一个独立对象","html":"创建父类的一个独立对象
"},{"key":"C","text":"调用父类对应的构造方法","html":"调用父类对应的构造方法
"},{"key":"D","text":"调用父类的静态方法","html":"调用父类的静态方法
"}],"answer":"C","answerText":"C 调用父类对应的构造方法","explanation":"super(参数) 在子类构造过程调用匹配的父类构造方法。","explanationHtml":"super(参数) 在子类构造过程调用匹配的父类构造方法。
当前类的父类对象
"},{"key":"B","text":"当前类的 Class 对象","html":"当前类的 Class 对象
"},{"key":"C","text":"任意一个子类对象","html":"任意一个子类对象
"},{"key":"D","text":"当前对象","html":"当前对象
"}],"answer":"D","answerText":"D 当前对象","explanation":"实例方法中的 this 指向当前正在调用该方法的对象。","explanationHtml":"实例方法中的 this 指向当前正在调用该方法的对象。
Animal a = new Animal();
Dog d = new Animal();
Animal a = new Dog();
Dog d = (Dog) new Animal();
子类对象可以自动转换为父类引用，Animal a = new Dog() 就是向上转型。
直接赋值，无需任何转换
"},{"key":"B","text":"进行强制类型转换，并确保对象实际是子类类型","html":"进行强制类型转换，并确保对象实际是子类类型
"},{"key":"C","text":"调用 super 方法","html":"调用 super 方法
"},{"key":"D","text":"把父类声明为 abstract","html":"把父类声明为 abstract
"}],"answer":"B","answerText":"B 进行强制类型转换，并确保对象实际是子类类型","explanation":"向下转型通常需强制类型转换，运行时对象还必须与目标子类类型兼容。","explanationHtml":"向下转型通常需强制类型转换，运行时对象还必须与目标子类类型兼容。
","important":false},{"id":"java-q78","number":78,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"关于抽象类，下列说法正确的是（ ）。","titleHtml":"关于抽象类，下列说法正确的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"抽象类只能用 final 修饰","html":"抽象类只能用 final 修饰
"},{"key":"B","text":"抽象类中不能有构造方法","html":"抽象类中不能有构造方法
"},{"key":"C","text":"抽象类中所有方法都必须是抽象方法","html":"抽象类中所有方法都必须是抽象方法
"},{"key":"D","text":"抽象类不能直接实例化，但可以声明引用变量","html":"抽象类不能直接实例化，但可以声明引用变量
"}],"answer":"D","answerText":"D 抽象类不能直接实例化，但可以声明引用变量","explanation":"抽象类可以声明变量、包含普通方法和构造方法，但不能直接 new 一个抽象类对象。","explanationHtml":"抽象类可以声明变量、包含普通方法和构造方法，但不能直接 new 一个抽象类对象。
必须有方法体，但方法体为空
"},{"key":"B","text":"只能定义在接口中","html":"只能定义在接口中
"},{"key":"C","text":"必须用 static 修饰","html":"必须用 static 修饰
"},{"key":"D","text":"只有方法声明，没有方法体，以分号结束","html":"只有方法声明，没有方法体，以分号结束
"}],"answer":"D","answerText":"D 只有方法声明，没有方法体，以分号结束","explanation":"抽象方法只有声明、没有实现体，以分号结尾，通常由非抽象子类实现。","explanationHtml":"抽象方法只有声明、没有实现体，以分号结尾，通常由非抽象子类实现。
","important":false},{"id":"java-q80","number":80,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"类实现接口使用的关键字是（ ）。","titleHtml":"类实现接口使用的关键字是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"implements","html":"implements
extends
import
interface
Java 类通过 implements 声明实现接口。
interface C extends A, B {}
interface C implements A, B {}
class C extends A, B {}
interface C import A, B {}
接口可以使用 extends A, B 同时继承多个接口。
父类引用指向子类对象，调用被重写的方法时执行子类版本
"},{"key":"B","text":"一个类只能有一个对象","html":"一个类只能有一个对象
"},{"key":"C","text":"子类自动继承父类的 private 方法","html":"子类自动继承父类的 private 方法
"},{"key":"D","text":"所有方法都必须在编译时确定版本","html":"所有方法都必须在编译时确定版本
"}],"answer":"A","answerText":"A 父类引用指向子类对象，调用被重写的方法时执行子类版本","explanation":"多态下，父类引用指向子类对象时，对可重写实例方法的调用会动态分派到子类实现。","explanationHtml":"多态下，父类引用指向子类对象时，对可重写实例方法的调用会动态分派到子类实现。
","important":false},{"id":"java-q83","number":83,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"instanceof 运算符的返回类型是（ ）。","titleHtml":"instanceof 运算符的返回类型是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"int","html":"int
Object
void
boolean
instanceof 用于判断对象是否属于兼容类型，结果为布尔值。
(a, b) -> a + b
a, b -> a + b
(a, b) => a + b
lambda(a, b) { return a + b; }
多参数 Lambda 使用 (a, b) -> 表达式，参数列表必须带圆括号。
只包含一个成员变量的接口
"},{"key":"B","text":"所有方法都必须用 static 修饰的接口","html":"所有方法都必须用 static 修饰的接口
"},{"key":"C","text":"只能被一个类实现的接口","html":"只能被一个类实现的接口
"},{"key":"D","text":"只包含一个抽象方法的接口(可包含默认方法和静态方法)","html":"只包含一个抽象方法的接口(可包含默认方法和静态方法)
"}],"answer":"D","answerText":"D 只包含一个抽象方法的接口(可包含默认方法和静态方法)","explanation":"函数式接口只有一个需要实现的抽象方法，还允许存在默认方法、静态方法等。","explanationHtml":"函数式接口只有一个需要实现的抽象方法，还允许存在默认方法、静态方法等。
","important":false},{"id":"java-q86","number":86,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"下列代码的输出结果是（ ）。","titleHtml":"下列代码的输出结果是（ ）。","stem":"class A {\n A() { System.out.print(\"A\"); }\n}\nclass B extends A {\n B() { System.out.print(\"B\"); }\n}\npublic class Demo {\n public static void main(String[] args) {\n new B();\n }\n}","stemHtml":"class A {\n A() { System.out.print("A"); }\n}\nclass B extends A {\n B() { System.out.print("B"); }\n}\npublic class Demo {\n public static void main(String[] args) {\n new B();\n }\n}BA
AB
A
B
创建 B 对象时，先隐式调用父类 A() 输出 A，再执行 B() 输出 B。
class A {\n void f() { System.out.print("A"); }\n}\nclass B extends A {\n void f() { System.out.print("B"); }\n}\npublic class Demo {\n public static void main(String[] args) {\n A a = new B();\n a.f();\n }\n}A
B
AB
编译错误
"}],"answer":"B","answerText":"B B","explanation":"引用变量静态类型是 A，实际对象为 B；重写方法按实际对象类型动态调用，因此输出 B。","explanationHtml":"引用变量静态类型是 A，实际对象为 B；重写方法按实际对象类型动态调用，因此输出 B。
class A {\n void f() { System.out.print("A"); }\n}\nclass B extends A {\n void f() {\n super.f();\n System.out.print("B");\n }\n}\npublic class Demo {\n public static void main(String[] args) {\n new B().f();\n }\n}AB
BA
B
A
子类方法先调用 super.f() 输出 A，再输出 B，最终为 AB。
class A {\n A() {\n this(5);\n System.out.print("A");\n }\n A(int x) {\n System.out.print("B");\n }\n}\npublic class Demo {\n public static void main(String[] args) {\n new A();\n }\n}AB
BA
B
编译错误，this(5) 必须位于第一行
"}],"answer":"B","answerText":"B BA","explanation":"无参构造方法先使用 this(5) 调用另一构造方法输出 B，随后自身输出 A。","explanationHtml":"无参构造方法先使用 this(5) 调用另一构造方法输出 B，随后自身输出 A。
class A { }\nclass B extends A { }\npublic class Demo {\n public static void main(String[] args) {\n A a = new A();\n B b = (B) a;\n }\n}编译错误
"},{"key":"B","text":"正常运行，b 为 null","html":"正常运行，b 为 null
"},{"key":"C","text":"正常运行，b 指向新建的 B 对象","html":"正常运行，b 指向新建的 B 对象
"},{"key":"D","text":"运行时抛出 ClassCastException","html":"运行时抛出 ClassCastException
"}],"answer":"D","answerText":"D 运行时抛出 ClassCastException","explanation":"变量 a 实际指向 A 对象，不是 B 对象；强转语法可通过，但运行时抛出 ClassCastException。","explanationHtml":"变量 a 实际指向 A 对象，不是 B 对象；强转语法可通过，但运行时抛出 ClassCastException。
抽象类不能有构造方法
"},{"key":"B","text":"抽象类可以有构造方法，由子类创建对象时通过 super 调用","html":"抽象类可以有构造方法，由子类创建对象时通过 super 调用
"},{"key":"C","text":"抽象类的构造方法只能被 main 方法调用","html":"抽象类的构造方法只能被 main 方法调用
"},{"key":"D","text":"抽象类构造方法必须声明为 abstract","html":"抽象类构造方法必须声明为 abstract
"}],"answer":"B","answerText":"B 抽象类可以有构造方法，由子类创建对象时通过 super 调用","explanation":"抽象类可以定义构造方法，子类实例化时会执行父类构造过程。","explanationHtml":"抽象类可以定义构造方法，子类实例化时会执行父类构造过程。
","important":false},{"id":"java-q92","number":92,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"下列代码的输出结果是（ ）。","titleHtml":"下列代码的输出结果是（ ）。","stem":"interface I {\n default void f() { System.out.print(\"I\"); }\n}\nclass C implements I {}\npublic class Demo {\n public static void main(String[] args) {\n new C().f();\n }\n}","stemHtml":"interface I {\n default void f() { System.out.print("I"); }\n}\nclass C implements I {}\npublic class Demo {\n public static void main(String[] args) {\n new C().f();\n }\n}编译错误，C 没有实现 f
"},{"key":"B","text":"运行时抛出异常","html":"运行时抛出异常
"},{"key":"C","text":"不输出任何内容","html":"不输出任何内容
"},{"key":"D","text":"I","html":"I
C 自动继承接口 I 的默认方法 f()，因此输出 I。
new I().f();
new C().f();
I.f();
C.f();
接口静态方法属于接口本身，使用接口名 I.f() 调用，不能通过实现类继承调用。
interface A {\n default void f() { System.out.print("A"); }\n}\ninterface B {\n default void f() { System.out.print("B"); }\n}\nclass C implements A, B {}输出 A
"},{"key":"B","text":"输出 B","html":"输出 B
"},{"key":"C","text":"输出 AB","html":"输出 AB
"},{"key":"D","text":"编译错误，C 必须重写 f 以解决冲突","html":"编译错误，C 必须重写 f 以解决冲突
"}],"answer":"D","answerText":"D 编译错误，C 必须重写 f 以解决冲突","explanation":"A 和 B 提供签名相同的默认方法，C 必须自行重写 f() 消除冲突。","explanationHtml":"A 和 B 提供签名相同的默认方法，C 必须自行重写 f() 消除冲突。
它在定义类的同时创建对象，通常用于实现接口或继承类的一次性子类
"},{"key":"B","text":"它必须显式定义类名","html":"它必须显式定义类名
"},{"key":"C","text":"它只能继承抽象类，不能实现接口","html":"它只能继承抽象类，不能实现接口
"},{"key":"D","text":"它不能访问外部类的成员","html":"它不能访问外部类的成员
"}],"answer":"A","answerText":"A 它在定义类的同时创建对象，通常用于实现接口或继承类的一次性子类","explanation":"匿名内部类没有显式类名，常在表达式中定义并实例化一次性实现类或子类。","explanationHtml":"匿名内部类没有显式类名，常在表达式中定义并实例化一次性实现类或子类。
","important":false},{"id":"java-q96","number":96,"type":"choice","chapter":"继承、多态、接口与 Lambda","title":"表达式 Comparator c = (a, b) -> a - b; 实现了 Comparator 接口中的哪个方法（ ）。","titleHtml":"表达式 Comparator c = (a, b) -> a - b; 实现了 Comparator 接口中的哪个方法（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"boolean equals(Object obj)","html":"boolean equals(Object obj)
void run()
int compare(Integer a, Integer b)
Integer apply(Integer a, Integer b)
（出题意图；原代码不能编译）
\n题目意图是 Comparator 的函数式方法 compare(T, T)，按选项选 C；但原题使用原生类型 Comparator，Lambda 形参被视为 Object，不能做减法，因此原代码实际无法编译。应改为 Comparator<Integer> c = (a, b) -> a - b;，此时才匹配选项 C。
建议修正版：
\nComparator<Integer> c = (a, b) -> a - b;其中应导入 java.util.Comparator。修正后，Lambda 对应 Comparator<Integer> 的 compare(Integer a, Integer b) 方法。
class Outer {\n int x = 10;\n class Inner {\n void show() { System.out.println(x); }\n }\n}\npublic class Demo {\n public static void main(String[] args) {\n Outer.Inner i = new Outer().new Inner();\n i.show();\n }\n}0
10
编译错误，内部类不能访问外部类成员
"},{"key":"D","text":"运行时抛出 NullPointerException","html":"运行时抛出 NullPointerException
"}],"answer":"B","answerText":"B 10","explanation":"非静态成员内部类可以直接访问所属外部类对象的实例变量 x，所以输出 10。","explanationHtml":"非静态成员内部类可以直接访问所属外部类对象的实例变量 x，所以输出 10。
class A {\n A() { show(); }\n void show() { System.out.print("A"); }\n}\nclass B extends A {\n int x = 10;\n B() { x = 20; }\n void show() { System.out.print("B" + x); }\n}\npublic class Demo {\n public static void main(String[] args) {\n new B();\n }\n}B10
B20
B0
A0
父类构造方法执行 show() 时会动态调用子类重写版本，但子类的 x = 10 还没执行，x 仍为默认值 0。
interface A {\n default void f() { System.out.print("A"); }\n}\ninterface B extends A {\n default void f() { System.out.print("B"); }\n}\nclass C implements A, B {\n public void f() { B.super.f(); }\n}\npublic class Demo {\n public static void main(String[] args) {\n new C().f();\n }\n}A
B
AB
编译错误，B.super.f() 不能调用
"}],"answer":"B","answerText":"B B","explanation":"B 重写了继承自 A 的默认方法；B.super.f() 明确调用 B 的默认版本，输出 B。","explanationHtml":"B 重写了继承自 A 的默认方法；B.super.f() 明确调用 B 的默认版本，输出 B。
void test() {\n int x = 10;\n Runnable r = () -> System.out.println(x);\n x = 20;\n r.run();\n}输出 10
"},{"key":"B","text":"输出 20","html":"输出 20
"},{"key":"C","text":"编译错误，Lambda 引用的局部变量 x 不是有效 final","html":"编译错误，Lambda 引用的局部变量 x 不是有效 final
"},{"key":"D","text":"运行时抛出异常","html":"运行时抛出异常
"}],"answer":"C","answerText":"C 编译错误，Lambda 引用的局部变量 x 不是有效 final","explanation":"Lambda 捕获的局部变量必须是 final 或“有效 final”；x 后续重新赋值，因此编译失败。","explanationHtml":"Lambda 捕获的局部变量必须是 final 或“有效 final”；x 后续重新赋值，因此编译失败。
String[]、f( )）按代码语义恢复为 String[]、f()，不改变题目的预期行为。A、B 与选项字母混排；根据上下文恢复构造方法、类声明和变量声明。C*，详细解释中说明原代码不能编译及建议修正方式。| 知识点 | 建议掌握的内容 |
|---|---|
| 编译与运行 | javac 编译；java 运行；JDK、JRE 与 JVM 的作用 |
| 基本语法 | 数据类型、类型转换、运算符优先级、字符串拼接 |
| 数组与流程 | 数组默认值与引用、switch 穿透、循环、break/continue |
| 类与对象 | 构造方法、方法重载、this、static、访问权限 |
| 参数传递 | Java 一律值传递；对象引用的副本仍可修改同一对象的状态 |
| 继承与多态 | extends、super、方法重写、动态分派、类型转换 |
| 接口与 Lambda | 默认方法、静态方法、函数式接口、有效 final |
容易失分的重点题号： 26、30、37、39、40、58、59、60、68、69、70、86—90、94、96、98、100。
"},{"id":"se","name":"软件工程","shortName":"软件工程","subtitle":"梳理概念，串联方法。让每一次复习都有所收获。","source":"软件工程_期中考试高概率押题与答案.md","questions":[{"id":"se-s1","number":1,"type":"short","chapter":"简答题 · 核心押题","title":"软件危机是什么？如何解决软件危机？软件工程的三要素是什么？","titleHtml":"软件危机是什么？如何解决软件危机？软件工程的三要素是什么？","stem":"","stemHtml":"","options":[],"answer":"参考答案","answerText":"1. 软件危机：指软件开发和维护过程中出现的一系列难以控制的问题。\n2. 解决途径（3点）：①选择好的技术与方法；②使用好的开发工具，提高效率；③进行良好的组织与严密管理。\n3. 软件工程：指导计算机软件开发和维护的学科。\n4. 软件工程三要素：过程、方法、工具。\n背诵口诀：危机“难控制”；解决“技术、工具、管理”；三要素“过程、方法、工具”。","explanation":"1. 软件危机：指软件开发和维护过程中出现的一系列难以控制的问题。\n2. 解决途径（3点）：①选择好的技术与方法；②使用好的开发工具，提高效率；③进行良好的组织与严密管理。\n3. 软件工程：指导计算机软件开发和维护的学科。\n4. 软件工程三要素：过程、方法、工具。\n背诵口诀：危机“难控制”；解决“技术、工具、管理”；三要素“过程、方法、工具”。","explanationHtml":"硬件、网络、数据库
"},{"key":"B","text":"程序、数据、文档","html":"程序、数据、文档
"},{"key":"C","text":"算法、编译器、操作系统","html":"算法、编译器、操作系统
"},{"key":"D","text":"用户、开发者、测试者","html":"用户、开发者、测试者
"}],"answer":"B","answerText":"B 程序、数据、文档","explanation":"提纲第1条直接列出软件的三个组成部分。","explanationHtml":"提纲第1条直接列出软件的三个组成部分。
","important":false},{"id":"se-q2","number":2,"type":"choice","chapter":"单选题 · 核心押题","title":"软件工程的三要素是（ ）。","titleHtml":"软件工程的三要素是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"人员、成本、进度","html":"人员、成本、进度
"},{"key":"B","text":"设计、编码、调试","html":"设计、编码、调试
"},{"key":"C","text":"需求、数据、程序","html":"需求、数据、程序
"},{"key":"D","text":"过程、方法、工具","html":"过程、方法、工具
"}],"answer":"D","answerText":"D 过程、方法、工具","explanation":"注意“软件的三部分组成”和“软件工程三要素”不是同一道题。","explanationHtml":"注意“软件的三部分组成”和“软件工程三要素”不是同一道题。
","important":false},{"id":"se-q3","number":3,"type":"choice","chapter":"单选题 · 核心押题","title":"下列对“软件危机”的解释，最符合复习提纲的是（ ）。","titleHtml":"下列对“软件危机”的解释，最符合复习提纲的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"软件的病毒感染","html":"软件的病毒感染
"},{"key":"B","text":"计算机硬件突然损坏","html":"计算机硬件突然损坏
"},{"key":"C","text":"软件开发和维护中出现的一系列难以控制的问题","html":"软件开发和维护中出现的一系列难以控制的问题
"},{"key":"D","text":"软件用户数量迅速增长","html":"软件用户数量迅速增长
"}],"answer":"C","answerText":"C 软件开发和维护中出现的一系列难以控制的问题","explanation":"软件危机不仅涉及开发，也涉及维护。","explanationHtml":"软件危机不仅涉及开发，也涉及维护。
","important":false},{"id":"se-q4","number":4,"type":"choice","chapter":"单选题 · 核心押题","title":"软件立项的前提是（ ）。","titleHtml":"软件立项的前提是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"可行性研究","html":"可行性研究
"},{"key":"B","text":"软件测试","html":"软件测试
"},{"key":"C","text":"详细设计","html":"详细设计
"},{"key":"D","text":"编码实现","html":"编码实现
"}],"answer":"A","answerText":"A 可行性研究","explanation":"提纲明确：可行性研究是软件立项的前提。","explanationHtml":"提纲明确：可行性研究是软件立项的前提。
","important":false},{"id":"se-q5","number":5,"type":"choice","chapter":"单选题 · 核心押题","title":"下列哪组最完整地概括了提纲列出的可行性研究内容？","titleHtml":"下列哪组最完整地概括了提纲列出的可行性研究内容？","stem":"","stemHtml":"","options":[{"key":"A","text":"进度、代码、测试、发布","html":"进度、代码、测试、发布
"},{"key":"B","text":"输入、处理、输出、维护","html":"输入、处理、输出、维护
"},{"key":"C","text":"技术、经济、社会、软件开发风险","html":"技术、经济、社会、软件开发风险
"},{"key":"D","text":"数据库、网络、接口、算法","html":"数据库、网络、接口、算法
"}],"answer":"C","answerText":"C 技术、经济、社会、软件开发风险","explanation":"四项内容缺一不可。","explanationHtml":"四项内容缺一不可。
","important":false},{"id":"se-q6","number":6,"type":"choice","chapter":"单选题 · 核心押题","title":"根据复习提纲，需求分析的输入是（ ）。","titleHtml":"根据复习提纲，需求分析的输入是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"软件测试报告","html":"软件测试报告
"},{"key":"B","text":"可行性分析报告","html":"可行性分析报告
"},{"key":"C","text":"概要设计说明书","html":"概要设计说明书
"},{"key":"D","text":"用户操作手册","html":"用户操作手册
"}],"answer":"B","answerText":"B 可行性分析报告","explanation":"按课程提纲记忆输入项。","explanationHtml":"按课程提纲记忆输入项。
","important":false},{"id":"se-q7","number":7,"type":"choice","chapter":"单选题 · 核心押题","title":"需求分析的两项主要输出是（ ）。","titleHtml":"需求分析的两项主要输出是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"用户需求报告与需求分析规格说明书","html":"用户需求报告与需求分析规格说明书
"},{"key":"B","text":"详细设计说明书与源代码","html":"详细设计说明书与源代码
"},{"key":"C","text":"测试计划与测试用例","html":"测试计划与测试用例
"},{"key":"D","text":"部署方案与维护日志","html":"部署方案与维护日志
"}],"answer":"A","answerText":"A 用户需求报告与需求分析规格说明书","explanation":"一份面向用户，一份面向开发者。","explanationHtml":"一份面向用户，一份面向开发者。
","important":false},{"id":"se-q8","number":8,"type":"choice","chapter":"单选题 · 核心押题","title":"复习提纲称软件生命周期的第一个里程碑是（ ）。","titleHtml":"复习提纲称软件生命周期的第一个里程碑是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"软件开发计划","html":"软件开发计划
"},{"key":"B","text":"概要设计说明书","html":"概要设计说明书
"},{"key":"C","text":"软件测试报告","html":"软件测试报告
"},{"key":"D","text":"需求分析规格说明书","html":"需求分析规格说明书
"}],"answer":"D","answerText":"D 需求分析规格说明书","explanation":"这是提纲明确强调的里程碑考点。","explanationHtml":"这是提纲明确强调的里程碑考点。
","important":false},{"id":"se-q9","number":9,"type":"choice","chapter":"单选题 · 核心押题","title":"《用户需求报告》主要面向（ ），内容包括运行环境、业务流程和业务功能。","titleHtml":"《用户需求报告》主要面向（ ），内容包括运行环境、业务流程和业务功能。","stem":"","stemHtml":"","options":[{"key":"A","text":"系统管理员","html":"系统管理员
"},{"key":"B","text":"用户","html":"用户
"},{"key":"C","text":"编译器","html":"编译器
"},{"key":"D","text":"测试工具","html":"测试工具
"}],"answer":"B","answerText":"B 用户","explanation":"“用户需求报告→用户”；另一份面向开发者。","explanationHtml":"“用户需求报告→用户”；另一份面向开发者。
","important":false},{"id":"se-q10","number":10,"type":"choice","chapter":"单选题 · 核心押题","title":"根据提纲，《需求分析规格说明书》主要包括（ ）。","titleHtml":"根据提纲，《需求分析规格说明书》主要包括（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"成本模型、进度模型、人员模型","html":"成本模型、进度模型、人员模型
"},{"key":"B","text":"业务模型、功能模型、接口模型","html":"业务模型、功能模型、接口模型
"},{"key":"C","text":"硬件模型、网络模型、部署模型","html":"硬件模型、网络模型、部署模型
"},{"key":"D","text":"测试模型、维护模型、验收模型","html":"测试模型、维护模型、验收模型
"}],"answer":"B","answerText":"B 业务模型、功能模型、接口模型","explanation":"考“业务、功能、接口”三项模型。","explanationHtml":"考“业务、功能、接口”三项模型。
","important":false},{"id":"se-q11","number":11,"type":"choice","chapter":"单选题 · 核心押题","title":"需求可分为（ ）。","titleHtml":"需求可分为（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"静态需求和动态需求","html":"静态需求和动态需求
"},{"key":"B","text":"初级需求和高级需求","html":"初级需求和高级需求
"},{"key":"C","text":"功能性需求和非功能性需求","html":"功能性需求和非功能性需求
"},{"key":"D","text":"本地需求和远程需求","html":"本地需求和远程需求
"}],"answer":"C","answerText":"C 功能性需求和非功能性需求","explanation":"这是需求分类的基础题。","explanationHtml":"这是需求分类的基础题。
","important":false},{"id":"se-q12","number":12,"type":"choice","chapter":"单选题 · 核心押题","title":"下列哪组工作属于本提纲划分的“计划阶段”？","titleHtml":"下列哪组工作属于本提纲划分的“计划阶段”？","stem":"","stemHtml":"","options":[{"key":"A","text":"可行性研究与需求分析","html":"可行性研究与需求分析
"},{"key":"B","text":"概要设计与详细设计","html":"概要设计与详细设计
"},{"key":"C","text":"编码与测试","html":"编码与测试
"},{"key":"D","text":"软件运行与维护","html":"软件运行与维护
"}],"answer":"A","answerText":"A 可行性研究与需求分析","explanation":"严格依照本课程提纲的三阶段划分。","explanationHtml":"严格依照本课程提纲的三阶段划分。
","important":false},{"id":"se-q13","number":13,"type":"choice","chapter":"单选题 · 核心押题","title":"下列哪组工作全部处于提纲所列的“开发阶段”？","titleHtml":"下列哪组工作全部处于提纲所列的“开发阶段”？","stem":"","stemHtml":"","options":[{"key":"A","text":"可行性研究、需求分析","html":"可行性研究、需求分析
"},{"key":"B","text":"运营、维护、升级","html":"运营、维护、升级
"},{"key":"C","text":"市场调研、需求分析、验收","html":"市场调研、需求分析、验收
"},{"key":"D","text":"概要设计、详细设计、编码设计、软件测试","html":"概要设计、详细设计、编码设计、软件测试
"}],"answer":"D","answerText":"D 概要设计、详细设计、编码设计、软件测试","explanation":"开发阶段列出的四项工作需要完整记忆。","explanationHtml":"开发阶段列出的四项工作需要完整记忆。
","important":false},{"id":"se-q14","number":14,"type":"choice","chapter":"单选题 · 核心押题","title":"软件生命周期三个阶段中的最后一个阶段是（ ）。","titleHtml":"软件生命周期三个阶段中的最后一个阶段是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"可行性研究阶段","html":"可行性研究阶段
"},{"key":"B","text":"编码阶段","html":"编码阶段
"},{"key":"C","text":"运行维护阶段","html":"运行维护阶段
"},{"key":"D","text":"需求分析阶段","html":"需求分析阶段
"}],"answer":"C","answerText":"C 运行维护阶段","explanation":"三大阶段：计划→开发→运行维护。","explanationHtml":"三大阶段：计划→开发→运行维护。
","important":false},{"id":"se-q15","number":15,"type":"choice","chapter":"单选题 · 核心押题","title":"概要设计的输入是（ ）。","titleHtml":"概要设计的输入是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"需求规格说明书","html":"需求规格说明书
"},{"key":"B","text":"软件维护报告","html":"软件维护报告
"},{"key":"C","text":"源代码文件","html":"源代码文件
"},{"key":"D","text":"测试缺陷报告","html":"测试缺陷报告
"}],"answer":"A","answerText":"A 需求规格说明书","explanation":"“需求规格说明书”是提纲第15条的称谓。","explanationHtml":"“需求规格说明书”是提纲第15条的称谓。
","important":false},{"id":"se-q16","number":16,"type":"choice","chapter":"单选题 · 核心押题","title":"概要设计的输出是（ ）。","titleHtml":"概要设计的输出是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"用户需求报告","html":"用户需求报告
"},{"key":"B","text":"工程进度计划","html":"工程进度计划
"},{"key":"C","text":"概要设计说明书","html":"概要设计说明书
"},{"key":"D","text":"详细测试日志","html":"详细测试日志
"}],"answer":"C","answerText":"C 概要设计说明书","explanation":"一进一出是常见选择题。","explanationHtml":"一进一出是常见选择题。
","important":false},{"id":"se-q17","number":17,"type":"choice","chapter":"单选题 · 核心押题","title":"提纲列出的概要设计方法包括（ ）。","titleHtml":"提纲列出的概要设计方法包括（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"只采用面向对象编码法","html":"只采用面向对象编码法
"},{"key":"B","text":"只采用人工测试法","html":"只采用人工测试法
"},{"key":"C","text":"面向过程调试法与黑盒测试法","html":"面向过程调试法与黑盒测试法
"},{"key":"D","text":"结构化（面向数据流）设计方法与面向数据结构设计方法","html":"结构化（面向数据流）设计方法与面向数据结构设计方法
"}],"answer":"D","answerText":"D 结构化（面向数据流）设计方法与面向数据结构设计方法","explanation":"不要把“设计方法”与“测试方法”混淆。","explanationHtml":"不要把“设计方法”与“测试方法”混淆。
","important":false},{"id":"se-q18","number":18,"type":"choice","chapter":"单选题 · 核心押题","title":"用来描述模块之间调用关系的图形工具是（ ）。","titleHtml":"用来描述模块之间调用关系的图形工具是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"ER图","html":"ER图
"},{"key":"B","text":"结构图","html":"结构图
"},{"key":"C","text":"甘特图","html":"甘特图
"},{"key":"D","text":"数据字典","html":"数据字典
"}],"answer":"B","answerText":"B 结构图","explanation":"层次图着重层次；结构图着重调用。","explanationHtml":"层次图着重层次；结构图着重调用。
","important":false},{"id":"se-q19","number":19,"type":"choice","chapter":"单选题 · 核心押题","title":"模块化设计应尽量做到（ ）。","titleHtml":"模块化设计应尽量做到（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"高内聚、低耦合","html":"高内聚、低耦合
"},{"key":"B","text":"低内聚、高耦合","html":"低内聚、高耦合
"},{"key":"C","text":"高内聚、高耦合","html":"高内聚、高耦合
"},{"key":"D","text":"低内聚、低耦合","html":"低内聚、低耦合
"}],"answer":"A","answerText":"A 高内聚、低耦合","explanation":"最核心的设计口号之一。","explanationHtml":"最核心的设计口号之一。
","important":false},{"id":"se-q20","number":20,"type":"choice","chapter":"单选题 · 核心押题","title":"在提纲列出的内聚类型中，内聚性最强的是（ ）。","titleHtml":"在提纲列出的内聚类型中，内聚性最强的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"偶然内聚","html":"偶然内聚
"},{"key":"B","text":"逻辑内聚","html":"逻辑内聚
"},{"key":"C","text":"功能内聚","html":"功能内聚
"},{"key":"D","text":"时间内聚","html":"时间内聚
"}],"answer":"C","answerText":"C 功能内聚","explanation":"内聚由低到高以“功能内聚”为终点。","explanationHtml":"内聚由低到高以“功能内聚”为终点。
","important":false},{"id":"se-q21","number":21,"type":"choice","chapter":"单选题 · 核心押题","title":"按照常见教材中提纲列出的四种类型，耦合最强的是（ ）。","titleHtml":"按照常见教材中提纲列出的四种类型，耦合最强的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"数据耦合","html":"数据耦合
"},{"key":"B","text":"控制耦合","html":"控制耦合
"},{"key":"C","text":"公共环境耦合","html":"公共环境耦合
"},{"key":"D","text":"内容耦合","html":"内容耦合
"}],"answer":"D","answerText":"D 内容耦合","explanation":"此题按常见教材理解；提纲“由高到低”方向可能误写，见避坑说明。","explanationHtml":"此题按常见教材理解；提纲“由高到低”方向可能误写，见避坑说明。
","important":true},{"id":"se-q22","number":22,"type":"choice","chapter":"单选题 · 核心押题","title":"需求分析文档评审的主要内容是（ ）。","titleHtml":"需求分析文档评审的主要内容是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"一致性、完整性、现实性、有效性","html":"一致性、完整性、现实性、有效性
"},{"key":"B","text":"速度、容量、耗电、成本","html":"速度、容量、耗电、成本
"},{"key":"C","text":"语法、缩进、注释、命名","html":"语法、缩进、注释、命名
"},{"key":"D","text":"安全、加密、审计、备份","html":"安全、加密、审计、备份
"}],"answer":"A","answerText":"A 一致性、完整性、现实性、有效性","explanation":"四个词需要逐字记忆。","explanationHtml":"四个词需要逐字记忆。
","important":false},{"id":"se-q23","number":23,"type":"choice","chapter":"单选题 · 核心押题","title":"面向对象分析建立的三个模型是（ ）。","titleHtml":"面向对象分析建立的三个模型是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"数据库模型、网络模型、硬件模型","html":"数据库模型、网络模型、硬件模型
"},{"key":"B","text":"对象模型、动态模型、功能模型","html":"对象模型、动态模型、功能模型
"},{"key":"C","text":"概念模型、逻辑模型、物理模型","html":"概念模型、逻辑模型、物理模型
"},{"key":"D","text":"层次模型、关系模型、网状模型","html":"层次模型、关系模型、网状模型
"}],"answer":"B","answerText":"B 对象模型、动态模型、功能模型","explanation":"不要与数据库设计三阶段混淆。","explanationHtml":"不要与数据库设计三阶段混淆。
","important":false},{"id":"se-q24","number":24,"type":"choice","chapter":"单选题 · 核心押题","title":"提纲列出的面向对象方法中类之间的关系包括（ ）。","titleHtml":"提纲列出的面向对象方法中类之间的关系包括（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"顺序、选择、循环","html":"顺序、选择、循环
"},{"key":"B","text":"输入、加工、输出","html":"输入、加工、输出
"},{"key":"C","text":"静态、动态、物理","html":"静态、动态、物理
"},{"key":"D","text":"关联、整体—部分、一般—特殊","html":"关联、整体—部分、一般—特殊
"}],"answer":"D","answerText":"D 关联、整体—部分、一般—特殊","explanation":"三个名称与对象模型的三类模型不同。","explanationHtml":"三个名称与对象模型的三类模型不同。
","important":false},{"id":"se-q25","number":25,"type":"choice","chapter":"单选题 · 核心押题","title":"根据提纲，数据库设计阶段与软件阶段的对应关系正确的是（ ）。","titleHtml":"根据提纲，数据库设计阶段与软件阶段的对应关系正确的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"概念设计—需求分析；逻辑设计—概要设计；物理设计—详细设计","html":"概念设计—需求分析；逻辑设计—概要设计；物理设计—详细设计
"},{"key":"B","text":"概念设计—编码；逻辑设计—测试；物理设计—维护","html":"概念设计—编码；逻辑设计—测试；物理设计—维护
"},{"key":"C","text":"概念设计—概要设计；逻辑设计—详细设计；物理设计—需求分析","html":"概念设计—概要设计；逻辑设计—详细设计；物理设计—需求分析
"},{"key":"D","text":"概念设计—维护；逻辑设计—编码；物理设计—测试","html":"概念设计—维护；逻辑设计—编码；物理设计—测试
"}],"answer":"A","answerText":"A 概念设计—需求分析；逻辑设计—概要设计；物理设计—详细设计","explanation":"三组对应关系直接背下来。","explanationHtml":"三组对应关系直接背下来。
","important":false},{"id":"se-t1","number":1,"type":"judge","chapter":"判断题 · 核心押题","title":"软件包括程序、数据和文档。","titleHtml":"软件包括程序、数据和文档。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第1条。","explanationHtml":"提纲第1条。
","important":false},{"id":"se-t2","number":2,"type":"judge","chapter":"判断题 · 核心押题","title":"软件可行性研究是在软件正式立项之后才进行的。","titleHtml":"软件可行性研究是在软件正式立项之后才进行的。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"提纲明确说可行性研究是软件立项的前提。","explanationHtml":"提纲明确说可行性研究是软件立项的前提。
","important":false},{"id":"se-t3","number":3,"type":"judge","chapter":"判断题 · 核心押题","title":"需求分析只需考虑功能性需求，不必考虑非功能性需求。","titleHtml":"需求分析只需考虑功能性需求，不必考虑非功能性需求。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"需求分析分为功能性需求和非功能性需求。","explanationHtml":"需求分析分为功能性需求和非功能性需求。
","important":false},{"id":"se-t4","number":4,"type":"judge","chapter":"判断题 · 核心押题","title":"提纲把《需求分析规格说明书》称为软件生命周期的第一个里程碑。","titleHtml":"提纲把《需求分析规格说明书》称为软件生命周期的第一个里程碑。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"注意不是《用户需求报告》。","explanationHtml":"注意不是《用户需求报告》。
","important":false},{"id":"se-t5","number":5,"type":"judge","chapter":"判断题 · 核心押题","title":"按照提纲，开发阶段包括概要设计、详细设计、编码设计和软件测试。","titleHtml":"按照提纲，开发阶段包括概要设计、详细设计、编码设计和软件测试。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第8条。","explanationHtml":"提纲第8条。
","important":false},{"id":"se-t6","number":6,"type":"judge","chapter":"判断题 · 核心押题","title":"模块化设计越是低内聚、高耦合越好。","titleHtml":"模块化设计越是低内聚、高耦合越好。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"应为高内聚、低耦合。","explanationHtml":"应为高内聚、低耦合。
","important":false},{"id":"se-t7","number":7,"type":"judge","chapter":"判断题 · 核心押题","title":"在提纲列出的六种内聚中，功能内聚强于偶然内聚。","titleHtml":"在提纲列出的六种内聚中，功能内聚强于偶然内聚。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"功能内聚最强，偶然内聚最弱。","explanationHtml":"功能内聚最强，偶然内聚最弱。
","important":false},{"id":"se-t8","number":8,"type":"judge","chapter":"判断题 · 核心押题","title":"面向对象方法将数据与处理相结合，并强调以数据为核心。","titleHtml":"面向对象方法将数据与处理相结合，并强调以数据为核心。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第19条。","explanationHtml":"提纲第19条。
","important":false},{"id":"se-t9","number":9,"type":"judge","chapter":"判断题 · 核心押题","title":"根据提纲，数据库逻辑设计对应详细设计阶段。","titleHtml":"根据提纲，数据库逻辑设计对应详细设计阶段。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"逻辑设计对应概要设计，物理设计才对应详细设计。","explanationHtml":"逻辑设计对应概要设计，物理设计才对应详细设计。
","important":false},{"id":"se-t10","number":10,"type":"judge","chapter":"判断题 · 核心押题","title":"可行性研究包括技术可行性、经济可行性、社会可行性和软件开发风险。","titleHtml":"可行性研究包括技术可行性、经济可行性、社会可行性和软件开发风险。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第18条完整列出四项。","explanationHtml":"提纲第18条完整列出四项。
","important":false},{"id":"se-s6","number":6,"type":"short","chapter":"简答题 · 高频替补","title":"比较瀑布模型、快速原型模型和增量模型的特点及适用场景。","titleHtml":"比较瀑布模型、快速原型模型和增量模型的特点及适用场景。","stem":"","stemHtml":"","options":[],"answer":"参考答案","answerText":"1. 瀑布模型：开发活动按阶段顺序推进，强调文档和阶段成果；适合需求比较明确、稳定的项目；缺点是面对需求变更时调整成本较高。\n2. 快速原型模型：先构建可供用户体验的原型，通过用户反馈澄清和完善需求；适合需求不够明确、交互需求较强的项目；注意原型不等于经过充分工程化的最终产品。\n3. 增量模型：把系统划分为若干增量，分批开发、测试和交付可用功能；适合希望尽早交付核心功能并持续扩展的项目；需要注意整体架构和增量间集成。\n4. 对比关键词：瀑布＝阶段顺序；快速原型＝原型与反馈；增量＝分批交付。\n说明：第28条明确点名了三种模型，但提纲没有给出定义、优缺点，以上为补充预测答案；考试表述以老师课件为准。","explanation":"1. 瀑布模型：开发活动按阶段顺序推进，强调文档和阶段成果；适合需求比较明确、稳定的项目；缺点是面对需求变更时调整成本较高。\n2. 快速原型模型：先构建可供用户体验的原型，通过用户反馈澄清和完善需求；适合需求不够明确、交互需求较强的项目；注意原型不等于经过充分工程化的最终产品。\n3. 增量模型：把系统划分为若干增量，分批开发、测试和交付可用功能；适合希望尽早交付核心功能并持续扩展的项目；需要注意整体架构和增量间集成。\n4. 对比关键词：瀑布＝阶段顺序；快速原型＝原型与反馈；增量＝分批交付。\n说明：第28条明确点名了三种模型，但提纲没有给出定义、优缺点，以上为补充预测答案；考试表述以老师课件为准。","explanationHtml":"ER图和用例图
"},{"key":"B","text":"甘特图和工程网络图","html":"甘特图和工程网络图
"},{"key":"C","text":"状态转换图和类图","html":"状态转换图和类图
"},{"key":"D","text":"数据字典和流程表","html":"数据字典和流程表
"}],"answer":"B","answerText":"B 甘特图和工程网络图","explanation":"提纲第14条。","explanationHtml":"提纲第14条。
","important":false},{"id":"se-q27","number":27,"type":"choice","chapter":"单选题 · 加练题库","title":"处理多对多实体联系时，提纲提到的方法是（ ）。","titleHtml":"处理多对多实体联系时，提纲提到的方法是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"自顶向下分解法","html":"自顶向下分解法
"},{"key":"B","text":"黑盒测试法","html":"黑盒测试法
"},{"key":"C","text":"第三者插足模式","html":"第三者插足模式
"},{"key":"D","text":"代码重构法","html":"代码重构法
"}],"answer":"C","answerText":"C 第三者插足模式","explanation":"通过中间实体/中间表转化关系。","explanationHtml":"通过中间实体/中间表转化关系。
","important":false},{"id":"se-q28","number":28,"type":"choice","chapter":"单选题 · 加练题库","title":"描述数据对象及其相互联系的模型通常用（ ）。","titleHtml":"描述数据对象及其相互联系的模型通常用（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"实体—联系图（ER图）","html":"实体—联系图（ER图）
"},{"key":"B","text":"甘特图","html":"甘特图
"},{"key":"C","text":"程序流程图","html":"程序流程图
"},{"key":"D","text":"工程网络图","html":"工程网络图
"}],"answer":"A","answerText":"A 实体—联系图（ER图）","explanation":"ER图是数据模型的重要描述工具。","explanationHtml":"ER图是数据模型的重要描述工具。
","important":false},{"id":"se-q29","number":29,"type":"choice","chapter":"单选题 · 加练题库","title":"在常见ER图记法中，菱形通常表示（ ）。","titleHtml":"在常见ER图记法中，菱形通常表示（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"实体","html":"实体
"},{"key":"B","text":"联系","html":"联系
"},{"key":"C","text":"属性","html":"属性
"},{"key":"D","text":"数据流","html":"数据流
"}],"answer":"B","answerText":"B 联系","explanation":"一般矩形为实体、椭圆为属性；具体看课件。","explanationHtml":"一般矩形为实体、椭圆为属性；具体看课件。
","important":false},{"id":"se-q30","number":30,"type":"choice","chapter":"单选题 · 加练题库","title":"在常见UML用例图中，用椭圆表示的是（ ）。","titleHtml":"在常见UML用例图中，用椭圆表示的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"演员/参与者","html":"演员/参与者
"},{"key":"B","text":"类","html":"类
"},{"key":"C","text":"数据存储","html":"数据存储
"},{"key":"D","text":"用例","html":"用例
"}],"answer":"D","answerText":"D 用例","explanation":"参与者常用小人表示；符号细节为通行UML记法。","explanationHtml":"参与者常用小人表示；符号细节为通行UML记法。
","important":false},{"id":"se-q31","number":31,"type":"choice","chapter":"单选题 · 加练题库","title":"在常见数据流图中，带箭头的连线通常表示（ ）。","titleHtml":"在常见数据流图中，带箭头的连线通常表示（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"程序调用","html":"程序调用
"},{"key":"B","text":"继承关系","html":"继承关系
"},{"key":"C","text":"数据流","html":"数据流
"},{"key":"D","text":"物理设备","html":"物理设备
"}],"answer":"C","answerText":"C 数据流","explanation":"区分数据流图与模块结构图。","explanationHtml":"区分数据流图与模块结构图。
","important":false},{"id":"se-q32","number":32,"type":"choice","chapter":"单选题 · 加练题库","title":"下列哪一项不属于提纲列举的需求分析阶段常用分析工具？","titleHtml":"下列哪一项不属于提纲列举的需求分析阶段常用分析工具？","stem":"","stemHtml":"","options":[{"key":"A","text":"数据字典","html":"数据字典
"},{"key":"B","text":"ER图","html":"ER图
"},{"key":"C","text":"状态转换图","html":"状态转换图
"},{"key":"D","text":"甘特图","html":"甘特图
"}],"answer":"D","answerText":"D 甘特图","explanation":"甘特图侧重进度计划。","explanationHtml":"甘特图侧重进度计划。
","important":false},{"id":"se-q33","number":33,"type":"choice","chapter":"单选题 · 加练题库","title":"需求分析的描述形式主要有（ ）。","titleHtml":"需求分析的描述形式主要有（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"文字、图形、表格","html":"文字、图形、表格
"},{"key":"B","text":"声音、视频、动画","html":"声音、视频、动画
"},{"key":"C","text":"数据库、网络、硬件","html":"数据库、网络、硬件
"},{"key":"D","text":"开发、测试、部署","html":"开发、测试、部署
"}],"answer":"A","answerText":"A 文字、图形、表格","explanation":"记住文字、图形、表格三种形式。","explanationHtml":"记住文字、图形、表格三种形式。
","important":false},{"id":"se-q34","number":34,"type":"choice","chapter":"单选题 · 加练题库","title":"下列哪一组是软件结构设计的基本原理？","titleHtml":"下列哪一组是软件结构设计的基本原理？","stem":"","stemHtml":"","options":[{"key":"A","text":"可行性、经济性、社会性、风险","html":"可行性、经济性、社会性、风险
"},{"key":"B","text":"信息隐蔽、模块化、抽象、信息传递","html":"信息隐蔽、模块化、抽象、信息传递
"},{"key":"C","text":"编译、连接、执行、调试","html":"编译、连接、执行、调试
"},{"key":"D","text":"安全、效率、美观、低成本","html":"安全、效率、美观、低成本
"}],"answer":"B","answerText":"B 信息隐蔽、模块化、抽象、信息传递","explanation":"与软件工程三要素区别开。","explanationHtml":"与软件工程三要素区别开。
","important":false},{"id":"se-q35","number":35,"type":"choice","chapter":"单选题 · 加练题库","title":"需求分析首先需要从用户端弄清楚（ ）。","titleHtml":"需求分析首先需要从用户端弄清楚（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"开发工具有多先进","html":"开发工具有多先进
"},{"key":"B","text":"软件代码怎样编写","html":"软件代码怎样编写
"},{"key":"C","text":"软件应该做什么","html":"软件应该做什么
"},{"key":"D","text":"服务器放在哪里","html":"服务器放在哪里
"}],"answer":"C","answerText":"C 软件应该做什么","explanation":"需求分析强调“做什么”，设计阶段进一步考虑“怎么做”。","explanationHtml":"需求分析强调“做什么”，设计阶段进一步考虑“怎么做”。
","important":false},{"id":"se-q36","number":36,"type":"choice","chapter":"单选题 · 加练题库","title":"在提纲中，主要呈现自上而下层次结构的是（ ）。","titleHtml":"在提纲中，主要呈现自上而下层次结构的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"层次图","html":"层次图
"},{"key":"B","text":"结构图","html":"结构图
"},{"key":"C","text":"ER图","html":"ER图
"},{"key":"D","text":"甘特图","html":"甘特图
"}],"answer":"A","answerText":"A 层次图","explanation":"与结构图的调用关系考点互补。","explanationHtml":"与结构图的调用关系考点互补。
","important":false},{"id":"se-q37","number":37,"type":"choice","chapter":"单选题 · 加练题库","title":"根据提纲所列的内聚类型，内聚性最弱的是（ ）。","titleHtml":"根据提纲所列的内聚类型，内聚性最弱的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"通信内聚","html":"通信内聚
"},{"key":"B","text":"功能内聚","html":"功能内聚
"},{"key":"C","text":"顺序内聚","html":"顺序内聚
"},{"key":"D","text":"偶然内聚","html":"偶然内聚
"}],"answer":"D","answerText":"D 偶然内聚","explanation":"偶然内聚最弱、功能内聚最强。","explanationHtml":"偶然内聚最弱、功能内聚最强。
","important":false},{"id":"se-q38","number":38,"type":"choice","chapter":"单选题 · 加练题库","title":"在提纲列出的四种耦合类型中，按常见教材，耦合最弱的是（ ）。","titleHtml":"在提纲列出的四种耦合类型中，按常见教材，耦合最弱的是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"控制耦合","html":"控制耦合
"},{"key":"B","text":"数据耦合","html":"数据耦合
"},{"key":"C","text":"内容耦合","html":"内容耦合
"},{"key":"D","text":"公共环境耦合","html":"公共环境耦合
"}],"answer":"B","answerText":"B 数据耦合","explanation":"按通常排序“数据＜控制＜公共环境＜内容”；注意提纲方向疑点。","explanationHtml":"按通常排序“数据＜控制＜公共环境＜内容”；注意提纲方向疑点。
","important":true},{"id":"se-q39","number":39,"type":"choice","chapter":"单选题 · 加练题库","title":"根据提纲，软件开发计划一般采用（ ）。","titleHtml":"根据提纲，软件开发计划一般采用（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"三三制原则","html":"三三制原则
"},{"key":"B","text":"先进先出原则","html":"先进先出原则
"},{"key":"C","text":"二八定律原则","html":"二八定律原则
"},{"key":"D","text":"单一职责原则","html":"单一职责原则
"}],"answer":"C","answerText":"C 二八定律原则","explanation":"提纲只给出“二八定律原则”名称，未阐述具体应用。","explanationHtml":"提纲只给出“二八定律原则”名称，未阐述具体应用。
","important":false},{"id":"se-q40","number":40,"type":"choice","chapter":"单选题 · 加练题库","title":"数据库的物理设计在本提纲中对应（ ）。","titleHtml":"数据库的物理设计在本提纲中对应（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"详细设计阶段","html":"详细设计阶段
"},{"key":"B","text":"需求分析阶段","html":"需求分析阶段
"},{"key":"C","text":"运行维护阶段","html":"运行维护阶段
"},{"key":"D","text":"可行性研究阶段","html":"可行性研究阶段
"}],"answer":"A","answerText":"A 详细设计阶段","explanation":"与选择题25相互印证。","explanationHtml":"与选择题25相互印证。
","important":false},{"id":"se-q41","number":41,"type":"choice","chapter":"单选题 · 加练题库","title":"（补充）通常按顺序推进阶段、强调阶段文档的过程模型是（ ）。","titleHtml":"（补充）通常按顺序推进阶段、强调阶段文档的过程模型是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"增量模型","html":"增量模型
"},{"key":"B","text":"快速原型模型","html":"快速原型模型
"},{"key":"C","text":"螺旋模型","html":"螺旋模型
"},{"key":"D","text":"瀑布模型","html":"瀑布模型
"}],"answer":"D","answerText":"D 瀑布模型","explanation":"提纲只点名模型，此定义来自通行教材。","explanationHtml":"提纲只点名模型，此定义来自通行教材。
","important":false},{"id":"se-q42","number":42,"type":"choice","chapter":"单选题 · 加练题库","title":"（补充）通过尽早制作原型并收集用户反馈来澄清需求的模型是（ ）。","titleHtml":"（补充）通过尽早制作原型并收集用户反馈来澄清需求的模型是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"瀑布模型","html":"瀑布模型
"},{"key":"B","text":"快速原型模型","html":"快速原型模型
"},{"key":"C","text":"增量模型","html":"增量模型
"},{"key":"D","text":"V模型","html":"V模型
"}],"answer":"B","answerText":"B 快速原型模型","explanation":"关键词：原型、反馈、澄清需求。","explanationHtml":"关键词：原型、反馈、澄清需求。
","important":false},{"id":"se-q43","number":43,"type":"choice","chapter":"单选题 · 加练题库","title":"（补充）把系统分成可逐步交付的若干增量的模型是（ ）。","titleHtml":"（补充）把系统分成可逐步交付的若干增量的模型是（ ）。","stem":"","stemHtml":"","options":[{"key":"A","text":"增量模型","html":"增量模型
"},{"key":"B","text":"瀑布模型","html":"瀑布模型
"},{"key":"C","text":"单次大爆炸模型","html":"单次大爆炸模型
"},{"key":"D","text":"形式化模型","html":"形式化模型
"}],"answer":"A","answerText":"A 增量模型","explanation":"关键词：分批开发、逐步交付。","explanationHtml":"关键词：分批开发、逐步交付。
","important":false},{"id":"se-q44","number":44,"type":"choice","chapter":"单选题 · 加练题库","title":"下列哪一项不是提纲所列的软件危机解决途径？","titleHtml":"下列哪一项不是提纲所列的软件危机解决途径？","stem":"","stemHtml":"","options":[{"key":"A","text":"改善开发技术与方法","html":"改善开发技术与方法
"},{"key":"B","text":"采用好的开发工具","html":"采用好的开发工具
"},{"key":"C","text":"加强组织和管理","html":"加强组织和管理
"},{"key":"D","text":"取消开发过程中的组织管理","html":"取消开发过程中的组织管理
"}],"answer":"D","answerText":"D 取消开发过程中的组织管理","explanation":"解决软件危机需要技术、工具和管理。","explanationHtml":"解决软件危机需要技术、工具和管理。
","important":false},{"id":"se-q45","number":45,"type":"choice","chapter":"单选题 · 加练题库","title":"面向对象方法在本提纲中强调以（ ）为核心。","titleHtml":"面向对象方法在本提纲中强调以（ ）为核心。","stem":"","stemHtml":"","options":[{"key":"A","text":"项目进度","html":"项目进度
"},{"key":"B","text":"数据","html":"数据
"},{"key":"C","text":"硬件","html":"硬件
"},{"key":"D","text":"测试用例","html":"测试用例
"}],"answer":"B","answerText":"B 数据","explanation":"提纲第19条：数据与处理相结合，以数据为核心。","explanationHtml":"提纲第19条：数据与处理相结合，以数据为核心。
","important":false},{"id":"se-t11","number":11,"type":"judge","chapter":"判断题 · 加练题库","title":"软件工程只研究软件开发，不涉及软件维护。","titleHtml":"软件工程只研究软件开发，不涉及软件维护。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"定义中明确包括开发和维护。","explanationHtml":"定义中明确包括开发和维护。
","important":false},{"id":"se-t12","number":12,"type":"judge","chapter":"判断题 · 加练题库","title":"《用户需求报告》面向开发者，其主要内容是业务模型、功能模型和接口模型。","titleHtml":"《用户需求报告》面向开发者，其主要内容是业务模型、功能模型和接口模型。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"这是两份需求文档的对象和内容混淆：用户报告面向用户。","explanationHtml":"这是两份需求文档的对象和内容混淆：用户报告面向用户。
","important":false},{"id":"se-t13","number":13,"type":"judge","chapter":"判断题 · 加练题库","title":"需求分析文档评审包括一致性、完整性、现实性和有效性。","titleHtml":"需求分析文档评审包括一致性、完整性、现实性和有效性。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第17条。","explanationHtml":"提纲第17条。
","important":false},{"id":"se-t14","number":14,"type":"judge","chapter":"判断题 · 加练题库","title":"结构图主要用于表示各模块之间的调用关系。","titleHtml":"结构图主要用于表示各模块之间的调用关系。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"层次图则侧重自上而下的层次结构。","explanationHtml":"层次图则侧重自上而下的层次结构。
","important":false},{"id":"se-t15","number":15,"type":"judge","chapter":"判断题 · 加练题库","title":"ER图用于描述数据对象以及数据对象之间的联系。","titleHtml":"ER图用于描述数据对象以及数据对象之间的联系。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第27条。","explanationHtml":"提纲第27条。
","important":false},{"id":"se-t16","number":16,"type":"judge","chapter":"判断题 · 加练题库","title":"软件结构设计基本原理包括信息隐蔽、模块化、抽象和信息传递。","titleHtml":"软件结构设计基本原理包括信息隐蔽、模块化、抽象和信息传递。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"提纲第23条。","explanationHtml":"提纲第23条。
","important":false},{"id":"se-t17","number":17,"type":"judge","chapter":"判断题 · 加练题库","title":"按照通行教材的四类耦合强弱排序，数据耦合比内容耦合更强。","titleHtml":"按照通行教材的四类耦合强弱排序，数据耦合比内容耦合更强。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"通常数据耦合更弱、内容耦合更强；提纲存在方向性笔误疑点。","explanationHtml":"通常数据耦合更弱、内容耦合更强；提纲存在方向性笔误疑点。
","important":true},{"id":"se-t18","number":18,"type":"judge","chapter":"判断题 · 加练题库","title":"通过引入中间实体（第三者插足），可以处理多对多实体联系。","titleHtml":"通过引入中间实体（第三者插足），可以处理多对多实体联系。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"这是对第9条术语的常见数据库设计解释。","explanationHtml":"这是对第9条术语的常见数据库设计解释。
","important":false},{"id":"se-t19","number":19,"type":"judge","chapter":"判断题 · 加练题库","title":"（补充）增量模型要求首次交付就必须包含全部系统功能。","titleHtml":"（补充）增量模型要求首次交付就必须包含全部系统功能。","stem":"","stemHtml":"","options":[],"answer":"×","answerText":"×","explanation":"增量模型强调按增量逐步交付。提纲只点名模型，解释来自通行教材。","explanationHtml":"增量模型强调按增量逐步交付。提纲只点名模型，解释来自通行教材。
","important":false},{"id":"se-t20","number":20,"type":"judge","chapter":"判断题 · 加练题库","title":"（补充）快速原型模型可以通过用户反馈帮助澄清不明确的需求。","titleHtml":"（补充）快速原型模型可以通过用户反馈帮助澄清不明确的需求。","stem":"","stemHtml":"","options":[],"answer":"√","answerText":"√","explanation":"关键词是“先做原型，再获取反馈”。","explanationHtml":"关键词是“先做原型，再获取反馈”。
","important":false}],"notesHtml":"题目根据复习提纲推测，不是老师原题或命中保证；补充内容与方向疑点已保留，请以课堂材料为准。\n
| 优先级 | 预测考点 | 对应提纲 | 建议重点题型 |
|---|---|---|---|
| ★★★★★ | 需求分析：输入输出、双文档、里程碑、评审 | 5、6、7、17、25、26 | 简答＋选择＋判断 |
| ★★★★★ | 软件工程、软件危机、三要素及解决办法 | 4、12、13、28 | 简答＋选择 |
| ★★★★★ | 软件结构设计、模块化、高内聚低耦合 | 11、16、23、28 | 简答＋选择＋判断 |
| ★★★★★ | 瀑布、快速原型、增量模型 | 28（仅列名称） | 简答或比较题（需参考课堂材料） |
| ★★★★☆ | 软件生命周期与阶段划分 | 8 | 简答＋选择＋判断 |
| ★★★★☆ | 可行性研究的地位及四方面 | 2、18、28 | 简答＋选择＋判断 |
| ★★★★☆ | 概要设计的输入、输出、方法、图形工具 | 10、11、15 | 选择＋简答 |
| ★★★★☆ | 面向对象的三模型与三类关系 | 19、21、22 | 选择＋简答 |
| ★★★★☆ | 数据库设计阶段与ER图 | 9、20、24、27 | 选择＋判断＋识图 |
| ★★★☆☆ | 进度图、二八定律、具体图形记号 | 3、14、20 | 选择＋判断 |
判断预测优先级的方法：提纲中反复出现的主题，以及第28条末尾再度点名的概念，优先考虑；仅出现一次的事实性考点更适合选择/判断。此优先级为学习建议，不是概率统计。
\n提纲第20条仅写出“ER图图标、用例图图标、数据流图图标”，没有附对应图例。以下为通行的常见记法，属于补充知识；具体形状若与课堂PPT不同，以课堂PPT为准。\n
| 图 | 常见符号/元素 | 作用与识别点 |
|---|---|---|
| ER图 | 矩形＝实体；菱形＝联系；椭圆＝属性 | 描述数据对象及对象间的联系 |
| UML用例图 | 小人＝参与者（Actor）；椭圆＝用例；矩形框＝系统边界（常见） | 描述参与者与系统功能之间的关系 |
| 数据流图（DFD） | 箭头＝数据流；圆形/圆角图形＝加工；矩形＝外部实体；双平行线/开口矩形＝数据存储（符号因记法而异） | 描述数据如何在加工、数据存储和外部实体间流动 |
| 层次图 | 自上而下分层排列 | 展示层次结构，提纲第11条 |
| 结构图 | 表示模块及模块间的调用关系 | 不要与数据流图混淆 |
| 考点 | 一句话答案 |
|---|---|
| 软件组成 | 程序＋数据＋文档 |
| 软件工程 | 指导软件开发与维护的学科 |
| 软件工程三要素 | 过程＋方法＋工具 |
| 软件危机解决 | 技术方法＋开发工具＋组织管理 |
| 可行性研究 | 立项前提；技术＋经济＋社会＋软件开发风险 |
| 需求分析输入/输出 | 可行性分析报告 → 用户需求报告＋需求分析规格说明书 |
| 需求分析的两大类需求 | 功能性＋非功能性 |
| 两份需求报告 | 面向用户：环境/流程/功能；面向开发：业务/功能/接口模型 |
| 需求文档评审 | 一致性＋完整性＋现实性＋有效性 |
| 生命周期 | 计划（可研、需求）→开发（概设、详设、编码、测试）→运行维护 |
| 概要设计 | 输入需求规格说明书；输出概要设计说明书 |
| 概要设计方法 | 面向数据流设计＋面向数据结构设计 |
| 层次图与结构图 | 层次图：上下层次；结构图：模块调用 |
| 模块化原则 | 高内聚＋低耦合 |
| 内聚由弱到强 | 偶然→逻辑→时间→通信→顺序→功能 |
| 耦合由弱到强（通行教材） | 数据→控制→公共环境→内容（原提纲方向存疑） |
| 结构设计四原理 | 信息隐蔽＋模块化＋抽象＋信息传递 |
| 面向对象三模型 | 对象＋动态＋功能 |
| 类之间三关系 | 关联＋整体部分＋一般特殊 |
| 数据库三设计阶段 | 概念/需求＋逻辑/概要＋物理/详细 |
| 多对多实体关系 | 第三者插足模式（中间实体/表） |
| 需求分析工具 | 数据流图＋IPO图＋状态转换图＋数据字典＋ER图 |
| 三种过程模型（通行教材补充） | 瀑布：顺序阶段；快速原型：反馈澄清；增量：分批交付 |
| 软件开发进度图 | 甘特图＋工程网络图 |
| 软件开发计划原则 | 二八定律原则（按提纲原文） |
建议刷题顺序：S1—S5 → 选择01—25 → 判断01—10 → S6（过程模型）→ 加练题 → 图形记号。复习时先遮住答案作答，再用解析纠错；简答题尽量练习用关键词分点书写。
\n整理依据：用户上传的《软件工程》期中复习提纲。提纲未给出、但为识图或过程模型题所需的知识，已标注“通行教材补充”，未伪装为原文。
"}]}