2.4 程序设计语言（C / Java / Python / JavaScript）

2026-11-03 11:45:00上一篇 / 下一篇

本篇定位：计算机系统基础篇的程序设计部分。程序设计 9 年题量 2–9 题（2019 因 Java/C 代码题多达 9 题，其后回归 3–5 题），中低频但代码题是"会者得分"板块。考法：①语言特性辨析（Java vs C++、编译 vs 解释）；②代码阅读（自增、指针、数组求和、字符串==）；③面向对象概念（封装/继承/多态、类与对象）；④多语言扩展（2026 起 Python/JS 入卷）。2027 预测 3–5 题。数据依据：01-真题/考点汇总/ 9 份计算机考点汇总；答案以专业判断为准。阅读提示：编程规范与安全编程（7.1 安全编程原则）衔接；编译原理（编译/解释、语法错误）归本章。

一、考点定位（本章真题统计）

考点	真题锚点	频次	考法
C 语言	2018 单40、2019 单24/40/41/78、2024 单30/36	4 年 7 题	自增、指针定义、字符串长度、sizeof、字符输出
面向对象（Java/OOP）	2019 单25/42/65、2021 单33/34/35/多86/多87、2022 单35/39、2023 单31/32/33/34/36/多83、2024 单31、2025 单27/33	7 年 17 题	最大考点群：特性、类/对象/接口、构造方法、字符串==、抽象方法
编译与语言基础	2019 单67、2020 单43、2022 单36、2025 单31	4 年	控制结构、编译错误、程序入口、编译流程
Python / JavaScript	2026 单58、多89、多92	1 年 3 题	eval、JS 脚本能力、语言应用场景
编程规范	2020 单39	1	功能性注释

命题规律：程序设计两大主线——①Java/面向对象（7 年 17 题，最大考点群：构造方法、字符串 ==、接口、抽象类）；②C 语言代码阅读（自增、指针、sizeof）。2026 起 Python/JS 加入（语言应用场景多选），2027 预测：面向对象概念 + 代码阅读 + 多语言辨析。

二、知识框架（先搭骨架）

程序设计语言
├── 语言基础
│   ├── 分类：机器/汇编（低级）vs 高级；编译型 vs 解释型
│   ├── 编译流程：预处理→编译→汇编→链接（C/C++）
│   ├── 程序入口：C 从 main 开始、到 main 结束
│   ├── 三种控制结构：顺序、选择、循环
│   └── 编译错误：可发现全部语法错误+部分语义错误，不能发现逻辑错误
├── C 语言
│   ├── 指针：int *px=&a（变量名 px）；sizeof(指针)=指针大小
│   ├── 数组名作实参→传首地址；字符串长度函数（strlen 类）
│   ├── 自增：k=n++（先赋值后自增）vs ++n
│   └── 字符与 ASCII：'3'-'1'=2；printf %c
├── Java 与面向对象
│   ├── OOP 四特性：抽象/封装/继承/多态（继承最独特）
│   ├── 类与对象：对象=类的实例；三成分=标识/属性/方法
│   ├── 接口：List myList = new ArrayList()（接口指向实现类）
│   ├── 构造方法：可重载、无返回值、与类同名
│   ├── 字符串 ==：常量池同内容同对象→true；new 则 false
│   ├── 抽象方法：public abstract void m();（无方法体）
│   ├── 关键字：integer 不是 Java 关键字
│   └── Java vs C++：Java 纯面向对象、无指针（引用）、字节码 JVM
├── Python / JavaScript
│   ├── Python：eval("105")→整数 105；数据科学首选
│   ├── JS：可访问 cookie、可发 HTTP 请求；前端首选
│   └── 应用场景：JS 前端、C++ 系统/游戏、Python 数据科学、C 嵌入式首选
└── 编程规范
    ├── 注释：功能性注释说明程序段/语句功能
    └── 安全编程（衔接 7.1）：最小功能、不信任输入、考虑异常

一句话记忆：语言基础（编译解释/入口/控制结构）→ C（指针/自增/sizeof）→ Java OOP（四特性/类接口/构造/字符串）→ Python/JS（eval/场景）→ 规范（注释/安全）。

三、考点详解

3.1 程序设计语言基础

精确定义：

低级语言：机器语言（二进制）、汇编语言（助记符）。
高级语言：C、Java、Python 等（接近自然语言）。
编译型：一次性翻译成目标程序（C/C++）；解释型：逐句翻译执行（Python、早期 JS）。

编译流程（2025 单31）：预处理 → 编译 → 汇编 → 链接（C/C++ 四步）。

程序入口（2019 单24、2022 单36）：C 程序从 main 函数开始执行，到 main 函数结束。

三种控制结构（2019 单67）：顺序、选择（分支）、循环。

编译程序发现的错误（2020 单43）：编译程序可发现源程序的全部语法错误和部分语义错误（如类型不匹配），不能发现设计/逻辑错误（逻辑错误需运行期/测试发现）。

3.2 C 语言

指针定义（2019 单40）：int *px=&a; ——变量名为 px（* 只是说明 px 是指针类型）；*px 是解引用取 a 的值。

⚠️ 题干瑕疵（2026-10-10 复核）：该题真题原版题干为"…其中指令+变量的名字应该是（口径已核）"（"指令"疑为"操作符"的排版错，但"+"确在）→ 问的是「操作符＋变量名」这一组合，应选 A（*px）；只有读成"只问变量的名字"时才是 C（px）。上句"C 语言里变量名是 px"这个事实不变，只是本题的落点是"操作符+变量名"。

sizeof 指针（2024 单30）：char *ss="0123456789"; sizeof(ss) 返回指针本身的大小（32 位系统 4、64 位系统 8）——不是字符串长度（strlen 才是）。坑：sizeof(ss) 是指针大小，sizeof("...") 才是字符串数组大小。

自增运算（2018 单40）：k=n++ 等价于 k=n; n=n+1（先赋值后自增）；k=++n 是 n=n+1; k=n（先自增后赋值）。

数组名作实参（2021 单39）：实参为数组名时向函数传递数组首地址（传址/传引用，函数内修改影响原数组）。

字符串长度（2019 单78）：int abc(char *ps) 遍历至 '\0' 返回长度 → 实现求字符串长度（strlen 功能）。

字符与 ASCII（2024 单36）：printf("%c,", b++) 输出 '2'（先输出再自增）；b-a（'3'-'1'）＝ASCII 差值＝2 → 输出 2,2。口诀：'数字'-'数字' = 数字差值。

关系与逻辑表达式的值（2019 单41 补强）：C 中关系/逻辑表达式的运算结果是 int 型的 1（真）或 0（假），不是布尔类型。

例：(3!=4)>2 → 3!=4 得 1 → 1>2 得 0（整个表达式的值为 0）。坑：看到 3!=4 就判"真"，忘了它还要与 2 比较。

未初始化变量（2019 单66 补强，必背对照）：

语言 / 存储位置	未赋初值时的值
C 局部（自动）变量	不确定的"垃圾值"（栈上残留）——绝不能假设为 0
C 全局变量 / static 变量	自动初始化为 0（静态区）
Java 成员变量	有默认值（0 / false / null）
Java 局部变量	编译报错（必须先赋值）

变量与常量（2018 多79，⚠️ 与常见误选易混，本书判 AD）：变量有名字、地址、值、类型、作用域、生存期六项属性；常量同样占用存储单元、同样有类型（const int 占 4 字节、类型 int），只是值不可修改——"常量不占存储单元/常量没有类型"是错误说法。

存储区与 static 局部变量（必背）：

区域	存放什么
代码区	指令
静态区/全局区	全局变量、static 变量、字符串常量
栈区	局部变量、函数调用帧
堆区	malloc/new 申请的空间

static 局部变量：作用域仍在函数内，但生存期是整程序运行期、只初始化一次——"出身在函数、户口在全局"。
参数传递四机制（2024 多86）：

机制	传什么	能否改实参	语言
值调用	实参值的副本	不能	C 默认、Java 全部
引用调用	实参的引用	能	C++ 的 `&`、C# 的 `ref`
传地址	实参地址（显式指针）	能（解引用）	C 的 `swap(int *a)`
值—结果	副本传入、出口回写	能	Ada 的 in out

判断点：Java 只有值传递——对象传的是"引用的副本"，所以改对象字段会生效、给形参重新赋值不影响外部。2024 多86 的"形参与实参单向值传递"答"是"。

函数三条规定（2024 多86）：①先声明后使用（定义在后需原型声明）；②不可嵌套定义、可以嵌套调用；③void 函数可用 return; 提前返回、不能 return 值；main 正常结束等价于 return 0;。

3.3 Java 与面向对象

OOP 四特性（2019 单25、2023 单36）：抽象、封装、继承、多态——"不确定性""过程调用"不属于（2023 单36 考"不属于面向对象范畴"→过程调用）。

继承是 OOP 最主要特点（2021 单33）：继承性是面向对象语言不同于其他语言的最主要特点（子类复用父类）。

类与对象（2022 单39、2025 单33）：对象 = 类的实例；对象三成分＝标识（身份）、属性（状态）、方法（行为）。类 vs 对象：类是模板、对象是实例；"类封装比对象封装更具体"是错误说法（对象才是封装的具体单位，2021 多86）。

接口实例化（2021 单34）：List myList = new ArrayList(); 正确——接口引用指向实现类对象（多态）。

构造方法（2023 单31）：构造方法与类同名、无返回值、可重载（"不能重载"是错误说法）、创建对象时自动调用。

字符串 ==（2023 单32）：String a="abcdefg"; String b="abcdefg"; a==b → true——字符串常量池中同内容指向同一对象；若 new String 则 == 为 false（需 equals）。

抽象方法（2023 单34）：public abstract void method(); ——无方法体（abstract 修饰，子类必须实现）；抽象类不能实例化。

Java 关键字（2021 单35）：integer 不是 Java 关键字（double/float/default 是；Integer 是包装类）。

Java vs C++（2021 多87）：C++ 兼容 C；Java 纯面向对象；Java 用对象须先声明（引用）；Java 无指针（用引用）。

Java 字节码（2019 单65）：Java 源码编译为字节码（.class），由 **JVM（Java 虚拟机）**解释执行——"一次编译、到处运行"。

Applet 绘图（2025 单27）：用户自定义 Applet 子类常重载 paint() 方法显示文字/图形。

Java 开发环境（2023 多83）：至少需 JDK、数据库、JDBC 驱动、Web 容器（全选）。

多态的实现：动态绑定与虚函数（2019 单42 补强，必考）：

静态绑定（早绑定）：编译期就确定调用哪个方法——重载（overload）、static/private/final 方法、C 的普通函数调用。
动态绑定（晚绑定）：运行期按对象的实际类型决定调用哪个方法——覆盖（override） ＋虚函数机制，这是多态的实现基础。
C++ 的规则：基类函数加 virtual 才是虚函数（否则按声明类型静态绑定）；纯虚函数（= 0）使类成为抽象类、不可实例化；基类析构函数应为 虚析构（否则 delete 基类指针不会调用派生类析构）。
vtable（虚函数表）：每个含虚函数的类一张表，对象里存 vptr 指向本类的表；调虚函数时"经 vptr 查表"→ 运行期才定。
三种"同名"别混：重载＝同作用域同名不同参数（编译期选）；覆盖/重写＝派生类重定义基类虚函数且签名相同（运行期选）；隐藏＝派生类同名函数但非虚/签名不同（按作用域规则静态定）。
对象切片（slicing）：派生类对象按值赋给基类对象只保留基类部分，派生部分被"切掉"——用指针/引用才有多态。
一句话：声明类型决定"能不能调"，实际类型决定"调谁的"。

Java 代码阅读（2023 单33 补强）：读循环求和的题，按四步走——①看循环变量初值与条件；②看每次循环的边界是 < 还是 <=（决定是否多算一次）；③看累加/自增的先后（sum+=a[i++] 与 a[++i] 不同）；④把循环跑一遍小规模样例验算。

int[] a = {1,2,3,4,5}; int sum = 0;
for (int i = 0; i < a.length; i++) { sum += a[i]; }   // sum = 15
for (int i = 0; i < a.length; i += 2) { sum += a[i]; } // 额外加 1+3+5 = 9

Java 的"解释型"定性（2022 单35 补强）：Java 是编译 + 解释的混合型——源码先编译成字节码，再由 JVM 解释执行（热点代码由 JIT 编译）。题目问"Java 属于哪类语言"时按教材口径选解释型（相对 C 的纯编译型），但要知道它先编译成字节码这一步。

Java 基础补强：接口、类库类型名、关键字（2026-11-06 补 · 按实际卡点整理）

① 关键字 ≠ 类库里的类型名（最常混）

	关键字 keyword	接口名 / 类名
谁规定	Java 语言规范（语言本身）	JDK 类库；任何程序员都能定义
数量	50 个（＋保留字 `const`/`goto`；＋字面量 `true`/`false`/`null`）	成千上万，随 JDK 版本增加
拼写	固定、不可增删、不能当标识符	可 import、可自己定义同名接口
例子	`interface`、`class`、`new`、`public`、`static`、`final`、`int`、`void`、`extends`	`List`、`Set`、`Map`、`Runnable`、`String`

易错：List 不是关键字，interface 才是；new List() 编译报错的原因是"接口不能实例化"，不是拼写问题。

② 常见接口清单（记分组，不背全表）

集合：List、Set、Map、Queue、Deque、Collection、Iterator、Comparable、Comparator、Iterable
线程/并发：Runnable、Callable、Future、Executor
IO 与序列化：Serializable、Cloneable、Closeable、AutoCloseable、CharSequence（前两个是标记接口，一个方法都没有）
函数式（Java 8+）：Function、Consumer、Supplier、Predicate
JDBC（金融科技常遇）：Connection、Statement、PreparedStatement、ResultSet——全是接口，实现由数据库厂商驱动提供（面向接口编程的典型）

③ 三个判别法

-able 结尾几乎必是接口：Comparable、Runnable、Serializable、Cloneable、Iterable、AutoCloseable——因为接口描述"能做什么"（can-do），天然用形容词；类描述"是什么"，用名词。
集合框架的命名形态：概念名＝接口（List/Set/Map），概念名＋实现方式＝类（ArrayList/HashSet/LinkedList）。
能不能 new：new X() 报错 ⇒ 接口或抽象类。

④ 三组最易混的名字

Collection（接口，集合根） vs Collections（工具类，全静态方法）——只差一个 s。
String 不是接口，是 java.lang 里的 final 类（不可被继承）；StringBuilder／StringBuffer 是类。
Integer 是包装类（int 才是基本类型/关键字），integer 什么都不是（2021 单35 就考这个）。

⑤ 普通类 / 抽象类 / 接口三者对比

对比项	普通类	抽象类	接口
能否 `new`	能	不能	不能
方法体	有	可有可无	主要只有签名（Java 8+ 可有 default/static）
继承/实现	单继承	单继承	多实现
变量类型能否指向子类对象	能	能	能（这就是多态）

⑥ List myList = new ArrayList(); 的完整解读（2021 单34 的正确项）

语义：要一个列表（逻辑结构），用数组（顺序存储）来实现——对应数据结构 3.1 的"逻辑结构→接口、存储结构→实现类"。
两条铁规：声明类型（List）决定"能调什么"（只能调 add/get/size 等）；实际类型（ArrayList）决定"调的是谁"（运行期动态绑定＝多态）。
为什么不写 ArrayList myList = new ArrayList();：换实现（如 LinkedList）时只改 new 后面一处，用法一行不动；也不会误用实现类特有方法。
内存一行图：栈上 myList 存引用（地址） → 堆上是 ArrayList 对象。

写法	判定
`List l = new ArrayList();`	✓ 接口引用指向实现类对象
`List l = new List();`	✗ 接口不能实例化
`ArrayList l = new ArrayList();`	✓ 能跑，但耦合实现（不推荐）
`List<String> l = new ArrayList<>();`	✓ 推荐（泛型＋菱形推断）
`List l = new LinkedList();`	✓ 同接口换实现类

Python（2026 单58）：eval("105") 把字符串当表达式求值 → 返回整数 105（不是字符串 "105"）。

JavaScript 脚本能力（2026 多89）：JS 脚本可访问 cookie、可发送 HTTP 请求（AJAX）——客户端脚本语言。

语言应用场景（2026 多92）：JS 前端、C++ 系统/游戏、Python 数据科学——"Java 是嵌入式首选"是错误（C 语言才是嵌入式首选）。

3.4 Python 基础（四容器＋三特性＋与 Java 对照）

Python 基础补强：四种容器＋三条特性（2026-11-06 补）

容器	写法	可变？	有序？	元素可重复？	要点
list 列表	`[1,2,3]`	可变	有序	可重复	下标访问、切片、`append()`
tuple 元组	`(1,2,3)`	不可变	有序	可重复	建后不能改，可作字典的键
dict 字典	`{"a":1}`	可变	3.7+ 保持插入序	键唯一	键值对，`d["a"]` 按键取值
set 集合	`{1,2,3}`	可变	无序	自动去重	交并差、成员判断快

三条特性：①动态类型（变量不声明类型，a=1 之后 a="x" 合法）；②靠缩进划分代码块（没有 {}）；③一切皆对象，函数也是一等对象。
常考小题：len([1,2,3])＝3；切片 "abcde"[1:4]＝"bcd"（含头不含尾）；range(3) 得 0,1,2；eval("105") 返回整数 105（2026 单58）；Python 3 的 1/2＝0.5（真除法，// 才是整除）。
类与继承一行：class Dog(Animal): —— 括号里是父类；构造方法 __init__(self, ...)，实例方法第一个参数固定是 self。
与 Java 对照：Java 必须先声明类型、Python 不用；Java 类单继承＋接口多实现，Python 支持多继承。

功能性注释（2020 单39）：说明程序段或语句的功能的注释（vs 序言性注释说明整个程序）。

安全编程（衔接 7.1 安全编程原则）："尽可能使用高级语言"不是安全编程原则；应最小化功能、不信任用户输入、考虑异常（详见 7.1 横向）。

四、易错坑汇总（命题人惯用陷阱）

k=n++ = 先赋值后自增；++n 相反（2018 单40）。
sizeof(指针) = 指针大小（4/8），不是字符串长度；strlen 才是长度（2024 单30）。
字符串 == 常量池：同内容字面量 == true；new 后 == false（用 equals）（2023 单32）。
构造方法可重载、无返回值（2023 单31）；抽象方法无方法体（2023 单34）。
integer 不是 Java 关键字（2021 单35）；"过程调用"不属于面向对象范畴（2023 单36）。
继承是 OOP 最主要特点（2021 单33）；对象三成分=标识/属性/方法（2022 单39）。
编译发现全部语法+部分语义错误，不能发现逻辑错误（2020 单43）。
C 从 main 开始到 main 结束（2019 单24、2022 单36）；编译流程=预处理→编译→汇编→链接（2025 单31）。
Java 无指针（引用）、纯面向对象（2021 多87）；嵌入式首选 C 不是 Java（2026 多92）。
eval("105") 返回整数（2026 单58）；'3'-'1'=2（ASCII 差值，2024 单36）。
接口不能实例化，但能声明引用：List l = new ArrayList(); ✓、new List() ✗（2021 单34）。
关键字 ≠ 类库类型名：List／String／Integer 都不是关键字；integer 小写更是啥也不是（2021 单35）。

五、横向扩展（防漏网：本章边界内、真题尚未考但可能补考的点）

说明：横向扩展覆盖"大纲范围内但 9 年真题未考过"的知识，标注【新增概率】供取舍。

C 指针与数组关系【高】：a[i] ≡ *(a+i)；指针运算（++/--）——2024 考了 sizeof，指针运算高概率。
Java 四大特性深挖【高】：多态（重载 vs 重写）、抽象类 vs 接口区别（接口多实现、抽象类单继承）——2027 高概率（2021 接口、2023 抽象方法已埋点）。已在 §3.3 补强块展开：关键字 vs 类库类型名、常见接口清单、普通类/抽象类/接口三表、List l = new ArrayList() 五种写法对错。
字符串比较 equals vs ==【高】：String 常量池、new、intern——2023 单32 已考 ==，equals 与 == 对比可能补考。
异常处理【中】：try-catch-finally、受检/非受检异常——Java 基础，未考过。
Python 基础语法【中】：列表/字典、range、f-string——2026 考了 eval，Python 语法题可能扩展。已在 §3.4 补四容器对照表（list/tuple/dict/set 的可变性·有序性·去重）＋动态类型/缩进/类与继承三条。
JS 与浏览器 DOM【中】：document.getElementById、事件处理——2026 多89 已考 JS 能力，可考 DOM 操作。
数据库连接（JDBC）【低】：DriverManager/Connection/Statement/ResultSet——2023 多83 提过 JDBC 环境。
面向对象设计原则【中】：单一职责、开闭原则、里氏替换——SOLID 原则可能以"良好设计"形式出现。
算法与程序结合【低】：排序/查找的代码实现（衔接 3.3 数据结构）——代码阅读题变体。
大模型时代编程语言趋势【低】：Python 在 AI 领域主导（衔接 8.3 机器学习）——跨篇场景题。

六、真题演练（代表性真题 + 解析）

例 1（2023 单32） String a="abcdefg"; String b="abcdefg"; 则 a==b 的值为（口径已核）。 A. true　B. false　C. 编译错误　D. 运行异常

答案：A。字符串字面量在常量池中，同内容指向同一对象 → == 比较引用地址 → true。若用 new String 则不同对象、== 为 false（须用 equals）。口诀：字面量==看常量池、new 出来==必 false。

例 2（2024 单30） char *ss="0123456789"; sizeof(ss) 的值为（口径已核）。（32 位系统） A. 10　B. 4　C. 11　D. 2

答案：B。ss 是指针变量，sizeof(指针) = 指针大小 = 32 位系统 4（64 位为 8）；10/11 是 strlen/数组长度。口诀：sizeof(指针) 看位数、strlen(字符串) 数内容。

例 3（2023 单31） 关于 Java 构造方法，下列说法错误的是（口径已核）。 A. 构造方法与类同名 B. 构造方法无返回值 C. 构造方法不能重载 D. 创建对象时自动调用构造方法

答案：C。构造方法可重载（同名不同参数表）——"不能重载"是错误说法。口诀：构造同名无返回、可重载自动调。

例 4（2018 单40） 与 k=n++ 完全等价的表达式是（口径已核）。 A. k=n; n=n+1　B. n=n+1; k=n　C. k=++n　D. k+=n+1

答案：A。n++ 先使用后自增 → k=n; n=n+1；B/C 是先自增后赋值（++n）。口诀：++ 在后先使用、++ 在前先自增。

例 5（2021 单34） 下列 Java 语句正确的是（口径已核）。 A. List myList = new List();　B. List myList = new ArrayList(); C. ArrayList myList = new List();　D. List myList = ArrayList();

答案：B。接口引用指向实现类对象（多态）：List 是接口、ArrayList 是实现类；A 接口不能实例化（new List() 错）、C 类型不符（接口不能 new）、D 缺 new。口诀：接口引用接实现类。

例 6（2026 单58） Python 表达式 eval("105") 的返回结果是（口径已核）。 A. 字符串 "105"　B. 整数 105　C. 报错　D. 浮点数 105.0

答案：B。eval() 把字符串当表达式求值 → 返回整数 105（不是字符串）。口诀：eval 求值不引号。

例 7（2021 单33） 面向对象语言区别于其他语言的最主要特点是（口径已核）。 A. 封装性　B. 多态性　C. 继承性　D. 抽象性

答案：C。继承性是面向对象语言最独特的特点（子类复用父类代码与结构）；封装/多态/抽象也是 OOP 特性但继承最具区分度。口诀：OOP 招牌=继承。

例 8（2025 单31） C/C++ 程序从源文件到可执行文件的一般流程是（口径已核）。 A. 编译→汇编→预处理→链接 B. 预处理→编译→汇编→链接 C. 编译→预处理→链接→汇编 D. 汇编→编译→预处理→链接

答案：B。预处理（宏/头文件）→ 编译（生成汇编）→ 汇编（生成目标文件）→ 链接（生成可执行文件）。口诀：预编汇链四步走。

七、本章小结

一条主线：语言基础（编译解释/入口/控制结构）→ C（指针/自增/sizeof）→ Java OOP（四特性/类接口/构造/字符串）→ Python/JS（eval/场景）→ 规范（注释/安全）。
必背口诀：++ 在后先使用；sizeof(指针) 看位数、strlen 数内容；字面量 == 看常量池；接口引用接实现类；eval 求值不引号；C 嵌入式首选。
必背区分：编译 vs 解释；抽象类 vs 接口；重载 vs 重写；== vs equals；Java 无指针。
衔接预告：安全编程（7.1）与编程规范衔接；Python 数据科学（8.3 机器学习）、JS 前端（8.5 应用）与金融科技篇呼应。