javase期末考复习可以看出其实掌握的知识点是很不闹靠的，还是要重新好好打好基础，就看java核心技术卷吧协议网络

可以看出其实掌握的知识点是很不闹靠的，还是要重新好好打好基础，就看java核心技术卷吧

协议

网络编程与通信协议是一个非常核心的考点（尤其在后半部分的题目中频繁出现）。作为未来主攻后端开发与系统架构的选手，理解这些网络底层协议的特征和应用场景是必备的基本功。

为你系统地整理出题库中所有涉及网络协议（TCP/UDP）以及应用层服务的硬核知识点：

一、运输层两大核心协议：TCP vs UDP

在网络中，传输层最核心的就是这两个协议。题目中对它们的特点、区别以及底层套接字（Socket）的运用进行了全方位的考查。

1. TCP 协议 (Transmission Control Protocol, 传输控制协议)

核心代名词：面向连接、可靠传输、面向字节流、效率稍低。
工作机制：通信前必须进行“三次握手”建立连接，通信结束时需要“四次挥手”断开连接。传输过程中有丢包重传、流量控制和拥塞控制，确保数据百分之百准确到达。
Java 套接字实现：
- 客户端：使用 java.net.Socket 类，负责向服务器发起 connect() 请求。
- 服务端：使用 java.net.ServerSocket 类，调用 accept() 方法进入阻塞状态，等待并接受客户端的连接请求。

2. UDP 协议 (User Datagram Protocol, 用户数据报协议)

核心代名词：无连接、不可靠、面向数据报、速度快、效率高。
工作机制：不需要建立连接，知道对方的 IP 和端口直接就把数据包扔过去。它不保证数据是否安全到达，也不管顺序，但因为没有握手和确认机制，传输延迟极低，开销极小。
Java 套接字实现：
- UDP 不严格区分服务端和客户端，双方统一使用 java.net.DatagramSocket 作为发送和接收的媒介（套接字）。
- 传输的具体数据必须打包进 java.net.DatagramPacket（数据报包）中，里面包含数据字节数组、目标 IP 地址和端口号。

二、典型应用层服务与底层协议的映射

题库中考查了“默认使用 UDP 协议进行数据传输”的服务（如 DNS）。在实际开发和期末考试中，以下经典应用层服务底层的协议选择必须牢记：

应用层服务	全称 / 作用	底层传输层协议	为什么选择该协议？
DNS	域名解析系统	UDP (默认)	每次查询和响应的数据包极小，要求极致的响应速度。如果偶尔丢包，客户端直接重发即可，无需开销巨大的 TCP 连接。
HTTP / HTTPS	网页浏览 / 超文本传输	TCP	网页文字、图片、脚本等数据绝不能丢失或错乱，必须依赖 TCP 提供的可靠传输。
FTP	文件传输协议	TCP	传输大文件时，任何一个比特位的错误都会导致文件损坏，必须 100% 可靠。
SMTP / POP3 / IMAP	电子邮件相关协议	TCP	邮件投递必须确保精准、完整地送达对方邮箱。
音视频直播 / 在线游戏	实时流媒体通信	UDP	宁可丢失一两个掉帧的画面，也绝对不能接受因为 TCP 丢包重传带来的长时延和卡顿。

三、考试常见“陷阱”与提分秘籍

多线程与网络结合：

服务端 ServerSocket.accept() 是一个典型的阻塞式方法。在后端架构设计中，为了同时应对多个客户端连接，通常在 accept() 监听到新连接（返回 Socket 对象）后，立刻启动一个全新的线程去处理该客户端的读写，而主线程继续循环等待下一个连接（即多线程并发服务器模型）。
DatagramSocket 的 receive() 方法：

和 TCP 的 accept() 类似，UDP 中 DatagramSocket.receive(DatagramPacket p) 在没有收到数据包之前，也会让当前线程进入阻塞状态。
分清 Packet 和 Socket：
- Socket 是管道/媒介（负责通信的节点）。
- Packet 是包裹/实体（负责装载数据）。UDP 编程中容易把这两者的方法和职责记混。

掌握了上面这些网络协议在 Java 中的落地形式，期末考试中所有关于网络编程的选择题和填空题你都能轻松拿下！

收到！我已经把你前三次自测中所有做错的题目全部单独抽离出来。针对这些错题，我为你重新编写了极其详尽的底层原理分析与防坑指南。

建议你重点复习这些章节，期末考前再看一遍，确保在同一个地方绝对不跌倒第二次。

❌ 错题 1：构造函数的基本语法

题目： 以下关于构造函数的描述正确的是（）。
选项：
A. 构造方法与类同名，在创建新对象时系统会自动调用构造函数
B. 有的类定义时可以不定义构造函数，所以构造函数不是必需的
C. 在类定义中必须定义构造函数，而且只能定义一个构造函数
D. 构造函数是特殊的方法，返回类型只能为void
正确答案： A
核心解析：

A选项完全正确：构造方法最核心的特征就是与类同名，在使用 new 关键字实例化对象时，由系统在底层自动调用。
B/C选项错误（默认构造机制） ：Java 规定每个类都必须有构造方法。如果你在代码中没有定义任何构造方法，编译器在编译时会隐式自动生成一个无参的默认构造方法。所以它是必需的，但不需要你每次都手动写。此外，构造方法支持重载，一个类可以有多个构造方法。
D选项是经典视觉陷阱：构造方法完全没有返回值类型，连 void 都绝对不能写。写了 public void Student() 的话，它就会被 JVM 当成一个名字很奇葩的普通成员方法，而不是构造方法。

❌ 错题 2：垃圾回收机制（GC）的执行时机

题目： 关于垃圾收集机制的叙述正确的是（）。
选项：
A. 程序开发者必须自己创建一个线程进行内存释放的工作
B. 垃圾收集将检查并释放不再使用的内存
C. 垃圾收集允许程序开发者明确指定并立即释放该内存
D. 垃圾收集能够在期望的时间释放被java对象使用的内存
正确答案： B
核心解析：

B选项完全正确：垃圾收集器（GC）的唯一核心职责，就是自动扫描堆内存，找出并释放那些没有任何引用指向的孤儿对象（不再使用的内存）。
A选项错误：垃圾回收线程是一个由 JVM 自动在后台维护的守护线程（Daemon Thread），不需要开发者手动创建和管理。
C/D选项代表后端控制红线：Java 屏蔽了底层的内存管理。虽然开发者可以通过调用 System.gc() 来“建议” JVM 进行垃圾回收，但 JVM 不一定会立刻理会。开发者无法明确指定某个精确的时间让它立即回收，GC 拥有绝对的自主执行权。

❌ 错题 3：TCP 网络编程服务端组件辨析

题目： java程序中，使用TCP套接字编写服务端程序的套接字类是（）。
选项：
A. Socket
B. ServerSocket
- C. DatagramSocket
D. DatagramPacket
正确答案： B
核心解析：

B选项正确：在基于 TCP 协议的网络编程中，服务端必须要有一个专门负责在指定端口死守、监听客户端连接请求的组件，这就是 ServerSocket。
A选项混淆：Socket 代表普通的 TCP 通信套接字。它主要用于客户端发起连接，或者在服务端成功监听到请求后，由 ServerSocket.accept() 返回，用来和具体的某个客户端建立点对点的双向字节流通信。
C/D选项跨协议了：带有 Datagram 前缀的类是专门用于 UDP 协议（数据报通信）的，TCP 编程中绝对用不到它们。

❌ 错题 4：标识符与关键字的冲突规则

题目： 下列哪个是Java中的合法标识符？（）
选项：
A. 1_variable
B. class
C. _variable1
D. -variable
正确答案： C
核心解析：

Java标识符的黄金四大定律：只能由字母、数字、下划线（_）和美元符号（$）组成；数字绝对不能开头；大小写敏感；绝对不能使用 Java 的关键字和保留字。
A错误：以数字开头的 1 违反了第一条铁律。
B错误（高频坑点） ：class 是 Java 用来声明类的核心关键字，属于被系统征用的保护词，哪怕它完全由小写字母组成，也绝对禁止拿来当变量名或方法名（如果是大写的 Class 则是合法的）。
D错误：连字符 - 在 Java 中是减法运算符，不能作为标识符的组成符号。
C正确：下划线开头且后面跟着字母数字，完全合乎规范。

❌ 错题 5：JDK 与 JVM 的层级包含关系

题目： Java语言实现“一次编写，处处运行”的核心依赖于哪个组件？（）
选项：
A. JDK
B. JRE
C. JVM
D. 操作系统
正确答案： C
核心解析：

C选项是底层核心：Java 的跨平台机制，本质上是靠“统一中间码 + 平台定制虚拟机”实现的。.java 被编译成统一的 .class 字节码。而运行在不同操作系统上的 JVM（Java虚拟机） 负责把这套字节码因地制宜地翻译成当前系统能听懂的机器指令。所以 JVM 是跨平台的核心依赖。
A/B选项是包含关系，不够精准：

JVM = 虚拟机（只负责翻译运行）。
JRE = JVM + 核心类库（能够让 Java 程序运行的最小环境）。
JDK = JRE + 开发工具（编译器 javac 等，服务于开发者）。
虽然 JDK 和 JRE 里面包含了 JVM，但真正承担“跨平台翻译”原子职责的组件只能是 JVM。

❌ 错题 6：字符类型（char）的物理存储空间

题目： Java的字符类型采用的是Unicode编码方案，每个Unicode码占用（）个比特位。
选项：
A. 8
B. 16
C. 32
D. 64
正确答案： B
核心解析：

B选项正确：Java 里的 char 类型为了能够完美承载全人类的各种语言文字（包括复杂的汉字），在内存中统一采用了 Unicode 编码方案（具体是 UTF-16）。
单位换算陷阱：一个 Unicode 码在 Java 中固定占用 2 个字节 的存储空间。题目考查的是比特位（bits） ，1 字节 = 8 比特，因此 2 字节 × 8 = 16 个比特位。
A选项（8位/1字节）对应的是 byte 类型；C选项（32位/4字节）对应的是 int 或 float；D选项（64位/8字节）对应的是 long 或 double。

❌ 错题 7：线程优先级与多线程执行特征

题目： 下列关于线程的说法，正确的是？（）
选项：
A. 线程的优先级不能修改
B. 线程的优先级范围是 1-10
C. 主线程的优先级是最低的
D. 线程的优先级越高，执行速度越快
正确答案： B
核心解析：

B选项是规范源码定义：Java 线程的优先级范围严格限制在 1 到 10 之间。Thread 类中定义了三个常量：MIN_PRIORITY = 1（最低）、NORM_PRIORITY = 5（默认中等）、MAX_PRIORITY = 10（最高）。
A错误：开发者可以通过调用 thread.setPriority(int newPriority) 动态修改线程的优先级。
C错误：主线程（main 线程）诞生时的默认优先级是 5。
D选项是多线程核心大坑：线程优先级高，绝对不代表它的执行速度变快！ 优先级高只是向操作系统申请，在抢夺 CPU 时间片时有更高的概率被优先调度。但在抢到 CPU 后，执行速度完全由 CPU 硬件决定。多线程的调度具有随机性，低优先级的线程依然有可能抢先执行完毕（这叫线程饥饿现象）。

❌ 错题 8：数组长度属性与字符串长度方法的混淆

题目： java中定义字符串String s=”pzhu”,下面操作可以取得字符串长度的是（）。
选项：
A. s.length()
B. s.length
C. s.size()
D. length(s)
正确答案： A
核心解析：
这是全书最容易发生手误、脑混淆的硬性语法规定，考试必考：

字符串（String） ：String 是一个标准的类。获取其封存的字符个数需要调用它的公开成员方法，所以必须带括号：s.length() 。
数组（Array） ：数组在 Java 中是一种特殊的内置引用对象。它的长度是一个特殊的、被 final 锁死的成员属性，绝对没有括号：arr.length。
集合（Collection/Map） ：ArrayList、HashMap 等容器类，获取里面的元素个数统一使用方法：list.size() 。

❌ 错题 9：方法重写（Override）中的协变返回与权限约束

题目： 下列关于方法重写的说法，正确的是？（）
选项：
A. 子类方法可以抛出比父类更多的异常
B. 静态方法可以被重写
C. 子类方法的返回值类型必须与父类完全相同
D. 子类重写父类方法时，访问权限不能比父类更严格
正确答案： D
核心解析：
牢记多态方法重写的金科玉律口诀： “一大两小两同” 。

“一大”——D选项完全正确：子类重写方法时的访问权限必须大于或等于父类。如果父类是 protected，子类只能是 protected 或 public；如果子类写成了更严格的 private，就会直接破坏多态的外部调用，引发编译报错。
“两小”之一（异常小）——A错误：子类重写方法抛出的编译时异常范围，必须小于或等于父类，绝不能扩大或增加。
“两小”之二（返回值小）——C错误（高级特性） ：自 Java 5 起支持“协变返回类型”。子类方法的返回值类型不一定非要完全相同，可以是父类方法返回值类型的子类（例如父类返回 Animal，子类重写时可以返回 Dog）。
B错误：static 静态方法是属于类的，在编译期就已经静态绑定。多态是活在运行期的对象动态绑定行为，因此静态方法绝对不能被重写（子类写个同名的只能算作“隐藏”父类方法）。

❌ 错题 10：字符字面量的界定符限制

题目： 以下哪项是正确的char型变量的声明？（）
选项：
A. char ch = "R";
B. char ch = 'ABCD';
C. char ch = "ABCD";
D. char ch = '\ucafe';
正确答案： D
核心解析：

A/C错误：双引号 "" 在 Java 中是专属定义字符串（String）的界定符，不能赋值给基本数据类型 char。
B错误：单引号 '' 确实是定义字符（char） 的符号，但它内部有且仅能容纳一个单独的字符。写了四个字母会导致编译器根本无法将其放入 2 字节的空间里。
D选项涉及高级编码字面量：Java 的 char 允许使用单引号包裹的 Unicode 转义序列（以 \u 开头后面紧跟 4 位十六进制数）来进行赋值。\ucafe 代表一个合法的 Unicode 字符码点，语法完全正确。

❌ 错题 11：接口继承与类实现的关键字分离

题目： 接口继承的关键字是？（）
选项：
A. extends
B. implements
C. extends或implements
D. 不能继承
正确答案： A
核心解析：
这道题最容易因为惯性思维而做错（平时写 implements 写太多了）：

类 ──> 接口：当一个普通的类去遵守某个接口的契约规范时，使用implements（实现）。
接口 ──> 接口（本题考点） ：接口是高度抽象的，它不需要、也无法去具体“实现”另一个接口。但接口与接口之间可以发生继承扩展关联，使用的关键字和类继承完全一样，是 extends。
额外拔高考点：Java 的类只允许单一继承（只能有一个直接父类）；但是Java 的接口之间支持强大的多继承，即一个接口可以写 interface A extends B, C, D。

❌ 错题 12：String类型在数据类型划分中的归属

题目： 下列选项中，不属于Java基本数据类型的是？（）
选项：
A. int
B. char
C. boolean
D. String
正确答案： D
核心解析：

D选项正确：String 在 Java 中是一个非常标准的公开类（Class） 。只要是类，它编译出来的变量存放的就是对象的内存地址，因此它属于引用数据类型，绝对不是基本数据类型。
八大基本数据类型硬性记忆：Java 纯正的底层基本数据类型只有固定的 8 种：

数值整型：byte, short, int, long
数值浮点：float, double
字符类型：char
布尔类型：boolean
注意它们在声明时全部都是小写字母开头。而 String 是大写字母开头，这也是它属于引用类的一个直观标志。

❌ 错题 13：抽象类的文件组织规范

题目： 在Java中，关于抽象类的描述，错误的是？（）
选项：
A. 抽象类不能被实例化
B. 抽象类中可以没有抽象方法
C. 抽象类必须定义在单独的文件中
D. 一个类继承抽象类后，必须实现其所有抽象方法（除非该类也是抽象类）
正确答案： C
核心解析：

找错误项，C选项描述错误：Java 的源文件组织规则非常明确：一个 .java 源文件中最多只能有一个被声明为 public 的类，且文件名必须与这个 public 类同名。但是，在这个源文件里面，你可以并列定义任意多个非 public 的类（包括非 public 的普通类、接口或者抽象类）。因此，抽象类完全不需要必须单独开辟一个文件。
A/B/D均为抽象类的法定制式特征：

抽象类是不完整的，禁止使用 new 实例化（A正确）。
抽象类里可以写全额的具体普通方法，连一行 abstract 方法都没有，这也是完全合法的（B正确）。
普通子类继承它，必须把历史欠账还清，补全所有的抽象方法实现（D正确）。

❌ 错题 14：分支语句（switch）对浮点类型的精确阻断

题目： 在switch（expression）语句中，expression的数据类型不能是（）。
选项：
A. char
B. byte
C. float
D. int
正确答案： C
核心解析：

C选项正确：switch 分支语句在底层执行的是严格的等值精准匹配（利用数值对比或者 HashCode 对比）。而 float 和 double 属于浮点数，在计算机底层是以科学计数法的二进制形式近似存储的，自带微小的精度误差（比如你看着是 1.2，底层可能是 1.1999999...）。浮点数用 == 直接比对是极其不安全的，因此 Java 语法在编译期就硬性斩断，禁止浮点数作为 switch 的表达式。
switch支持的数据类型全景扫描：

最传统支持：byte, short, char, int（以及它们的封装类包装对象）。
Java 5 引入：枚举类型 (Enum) 。
Java 7 引入：字符串类型 (String) （底层靠比对字符串的 HashCode 和 equals 实现）。

❌ 错题 15：集合框架与标记接口的隶属关系

题目： 下列哪个接口是Java集合框架的一部分？（）
选项：
A. Cloneable
B. Serializable
C. List
D. Runnable
正确答案： C
核心解析：

C选项正确：Java 整个集合框架体系（Collections Framework）全部存放在 java.util 包下。它的单列容器顶级祖先是 Collection 接口，而 List（列表）则是其下属最核心的三大主干顶级子接口之一（另外两个是 Set 和 Queue）。
A/B/D属于通用系统标记接口，不隶属于集合：

Cloneable 和 Runnable 活在 java.lang 包下，分别负责对象克隆和多线程任务定义。
Serializable 活在 java.io 包下，专门充当对象序列化持久化输出的“通行证”标记，它们和集合容器没有任何家族隶属关联。

❌ 错题 16：字符流与字节流的读取组件辨析

题目： 在 Java I/O 中，用于读取字节文件的类是？（）
选项：
A. FileOutputStream
B. FileInputStream
C. FileWriter
D. FileReader
正确答案： B
核心解析：
面对眼花缭乱的 I/O 流大家族类名，只要拆解单词组合就能做到 100% 准确判别：

看后缀确定流的数据维度：

以 Stream 结尾的：全都是字节流（8位，负责处理图片、视频或底层二进制原始数据）。
以 Reader / Writer** 结尾的：全都是字符流**（16位，专门应对经过编码的文本纯文字）。

看中缀确定流的输入输出方向：

包含 Input / Reader** 的：全都是输入流**（读数据进内存）。
包含 Output / Writer** 的：全都是输出流**（从内存写出数据）。

本题拆解：题目要求“读取（输入）字节（Stream）文件（File）”，拼装组合后的法定正确类名只能是 FileInputStream。而 FileReader 是字符输入流，用来读纯文本文件的。

❌ 错题 17：final 与 static 关键字的常量的定义职责

题目： Java 语言中，用于定义常量的关键字是？（）
选项：
A. static
B. constant
C. final
D. const
正确答案： C
核心解析：

C选项正确：在 Java 中，final 的字面含义是“最终的、不可更改的”。一旦一个变量被修饰为 final，它的赋值机会有且仅有一次，后续任何企图修改其数值的代码都会引发编译报错。利用这个特性，它在 Java 中承担常量的定义功能。
A选项混淆：static 代表“静态、属于类级别”。被 static 修饰的变量可以通过类名直接修改。在后端开发中，我们定义一个全局常量通常联合写成 public static final int MAX_USERS = 100; 。这里面真正起到锁定值不能变的决定性关键字是 final，static 只是为了让它不需要 new 对象就能直接共享访问。
D选项 const 是 Java 的一个恶作剧保留字，目前在语法中没有任何实际功能，写出来直接报错。

❌ 错题 18：自定义异常类的继承体系约束

题目： 自定义异常类必须继承的类是？（）
选项：
A. Throwable
B. Exception或RuntimeException
C. Error
D. RuntimeException
正确答案： B
核心解析：

B选项最符合业务开发规范：在实际业务中自定义一个异常，必须要遵守异常家族的划分。如果你希望做出一个调用者必须显式 try-catch 拦截的异常，继承 Exception（受检异常）；如果你希望做出一个调用者可以不强制捕获的异常，继承 RuntimeException（运行时异常）。
A选项过大，不符合规范：Throwable 是整个异常和错误家谱树的最高远古始祖。虽然继承它编译能过，但是它把严重的系统崩溃也囊括进去了，直接继承它会破坏异常的分层架构，因此开发规范严禁直接继承 Throwable。
C选项是雷区：Error 代表诸如 JVM 内存爆满（OOM）、栈溢出（StackOverflow）等系统级致命死症。应用层的自定义业务异常绝对禁止去染指 Error 体系。

❌ 错题 19：单列容器（ArrayList）的核心契约特征

题目： ArrayList的特点是？（）
选项：
A. 元素有序，允许重复
B. 元素无序，不允许重复
C. 元素无序，允许重复
D. 元素有序，不允许重复
正确答案： A
核心解析：
搞定集合特征，必须死死扣住 List 和 Set 两大宗派的最高核心契约：

List宗派（ArrayList, LinkedList）——A选项正确：核心特征是“存取有序，允许重复”。所谓有序，是指元素在里面的排列顺序与你手动 add 塞进去的先后索引顺序是一模一样的；并且它允许你放入两个完全同名、内容相同的对象。
Set宗派（HashSet, TreeSet） ：核心特征是“存取无序，不允许重复”。它内部带有排重判定，如果你塞入重复数据会被直接忽略丢弃。
因为 ArrayList 实现了 List 接口，所以它天然具备有序、可重复的特征。

❌ 错题 20：静态方法（static）对非静态成员的物理隔离

题目： 给出如下代码：

class Test {
  // 定义成员a
  public static void fun() { // some code... }
}

要在函数fun()中直接访问a，以下成员变量定义正确的是（）。

选项：
A. static int a;
B. public int a;
C. int a;
D. protected int a;
正确答案： A
核心解析：

A选项是铁律：方法 fun() 被声明为 static（静态方法） 。在 JVM 的生命周期中，静态成员是伴随类加载而提早诞生并常常驻方法区的，此时堆内存中可能根本还没有任何实例对象存在。
静态不能直接访问非静态：B/C/D 声明的变量都是普通的实例成员变量。它们必须依赖对象被 new 出来之后才会在堆内存中获得具体的物理空间。一个早就诞生的静态方法 fun() 如果允许直接访问尚未实例化的变量 a，就像“穿越时空去抓影子”，逻辑上完全说不通。
所以，静态方法内部如果想不 new 对象直接拔高访问成员，该成员也必须被修饰为 static，这样大家同在静态区，才能直接看得到。

❌ 错题 21：GUI组件布局管理器默认缺省策略大比拼

题目： 下列哪个叙述是不正确的？（）
选项：
A. JPanel的默认布局是BorderLayout布局。
B. JFrame创建的窗口默认是不可见的。
C. JFrame的默认布局是BorderLayout布局。
D. JFrame窗口可以调用setTitle(String s)方法设置窗口的标题。
正确答案： A
核心解析：

找错误项，A选项叙述是错误的：在 AWT/Swing 图形界面编程中，不同的容器组件由于设计定位不同，其默认（缺省）附带的布局管理器也截然不同：

JFrame（重量级顶级窗口框架） ：默认缺省布局是 BorderLayout（边界布局） ，它会强势把窗口划分成东南西北中五个大控制区（C描述正确）。
JPanel（轻量级面板容器） ：默认缺省布局是 FlowLayout（流式布局） ，里面的小按钮组件会像流水、写字一样从左到右依次排开，排满了自动折行。

B描述正确：为了防止组件装填过程中发生闪烁或半成品暴露，JFrame 刚创建出来时默认是隐藏死封在内存里的，必须程序员手工写一句 frame.setVisible(true); 才能把它正式拉上屏幕显现。

❌ 错题 22：多态机制的边界界定与必要条件

题目： 下列哪个不是 Java 中多态的必要条件？（）
选项：
A. 方法重写
B. 方法重载
C. 继承
D. 父类引用指向子类对象
正确答案： B
核心解析：

B选项不是多态条件：多态的核心标志是：用同一个父类引用去调用同一个名字的方法，传入不同的子类对象时，能跑出完全不一样的业务行为。 这和在一个类里面写多个同名不同参的 Overload（方法重载）没有任何演进逻辑关联。
多态不可或缺的三大铁三角条件（A/C/D） ：

必须得有类继承（extends）或接口实现作为骨架（C必要）。
子类必须要把父类的方法给 Override 重写了，这样执行时才有差异性（A必要）。
写代码时必须采用 父类引用 = new 子类对象(); 的形式，从而在运行期触发 JVM 的动态多态绑定寻址机制（D必要）。

做完这 22 道错题的深度剖析，相信你已经把全书各个章节最核心、最容易被出题老师挖坑的地方全部踩过一遍，并且建立起了牢固的代码免疫网！祝你期末考直接高分拿下！

太棒了，收到了！我确实看到里面有重复发了一次的第 35 题，所以一共是 12 道独立的错题。

这就对了！现在咱们的“错题拼图”终于 100% 完整了。我马上为你把这缺失的 12 道题重新梳理，剥开陷阱，加上最深度的硬核解析。

❌ 错题 1：Scanner 类的资源释放

题目： 下列关于Scanner类的说法，错误的是？（）
选项： A. 读取后无需关闭Scanner对象 B. nextInt()用于读取int类型数据 C. nextLine()读取整行文本，包括空格 D. 需导入java.util.Scanner
正确答案： A
核心解析： 找错误项。Scanner 很多时候不止是读取控制台（System.in），它经常被用来包装底层的文件流或网络流。作为一种占用物理资源的类，使用完毕后必须调用 close() 方法关闭，否则会造成资源泄露。C 选项是你当时的错选，nextLine() 的基本特性就是读取整行（遇到回车才停），所以它里面当然可以包含空格。

❌ 错题 2：TCP 客户端套接字

题目： 在 Java 网络编程中，用于创建 TCP 客户端套接字的类是？（）
选项： A. Socket B. ServerSocket C. DatagramSocket D. URL
正确答案： A
核心解析： 别把服务端和客户端记反了！
- Socket：普通的套接字，负责在客户端主动向外发起连接。
- ServerSocket：名字里带 Server，负责在服务端死守端口，监听并接受（accept）客户端的连接。

❌ 错题 3：类的单继承特性

题目： 下面对继承叙述错误的是（）。
选项： A. 在java中一个类可以实现多个接口 B. 在java中类的继承只允许单一继承 C. 在java中一个类能同时继承一个类和实现多个接口 D. 在java中类允许多重继承
正确答案： D
核心解析： 找错误项。Java 为了避免著名的“菱形继承冲突”（即两个父类有同名方法时子类不知道该听谁的），在类的层面上，死死规定只允许单一继承（一个儿子只能有一个亲爹）。所以 D 选项说类允许多重继承是绝对错误的。

❌ 错题 4：二维锯齿数组的越界陷阱

题目： 如下定义二维数组操作错误的是（）。int a[][]={{1,2},{3}};
选项： A. a [1] [1]=100 B. a[0][1]=200 C. a[0].length D. a.length
正确答案： A
核心解析： 这是一个长度不一的“锯齿数组”。
- 第一行 a[0] 是 {1, 2}，有 2 个元素（索引为 0 和 1）。所以你的错选 C a[0].length 等于 2，是完全合法的。
- 第二行 a[1] 是 {3}，它只有 1 个元素（索引只能是 0）。所以 A 选项强行去访问 a[1][1]（试图访问第二行的第二个元素），会直接触发数组越界异常！

❌ 错题 5：浮点型字面量的默认类型

题目： 下列哪个变量声明是错误的？（）
选项： A. int d=4; B. float b=1.2; C. byte a=1; D. char c= 'c';
正确答案： B
核心解析： 找错误项。在 Java 里，只要你写了一个带小数点的小数（比如 1.2），编译器默认它是一个 8 字节的双精度 double 类型。你想把一个 8 字节的 double 塞进 4 字节的 float 变量里，编译器绝对不干。正确的写法必须加个尾缀：float b = 1.2f;。

❌ 错题 6：char 类型的比特位大小

题目： Java的字符类型占用（）个比特位（bits）。
选项： A. 8 B. 32 C. 12 D. 16
正确答案： D
核心解析： 注意审题，问的是比特位（bits） ，不是字节（bytes）！Java 的 char 采用 Unicode 编码，占用 2 个字节。1 字节 = 8 比特，2 × 8 = 16 个比特位。你错选的 8 个比特位对应的是 byte 类型。

❌ 错题 7：static 静态变量的全局共享性//题目不完全

题目： 执行下列代码，最后的输出结果是（）。 Person p1 = new Person(); Person p2 = new Person(); p1.name = "李四"; p1.age = 20; System.out.println(p2.name + "," + p2.age);
选项： A. 张三,18 B. 李四,20 C. 张三,20 D. 李四,18
正确答案： C
核心解析： * name 是普通的实例变量，p1 改了 p1 的，p2 还是原来的 "张三"。
- age 前面有个 static！静态变量在内存里只有全局唯一的一份，被所有对象共享。p1 把全局的 age 改成了 20，p2 去看的时候，当然也就变成了 20。所以是“张三,20”。

❌ 错题 8：finally 块与 System.exit()

题目： 关于finally块中的代码，以下说法不正确的是（）。
选项： A. try块中的System.exit(1)语句会中断finally块中语句的执行 B. finally块中的语句通常中用作资源的清理 C. try块中的return语句会中断finally块中语句的执行 D. 无论finally块前的语句运行是否产生异常，其中的语句都会执行
正确答案： C
核心解析： 找不正确的。try 里的 return 语句绝对挡不住 finally 的步伐！JVM 会先去把 finally 跑完，再回来执行 return 退出方法。唯一能真正让 finally 哑火的，只有 A 选项的 System.exit(1)（直接拔掉 JVM 虚拟机的电源）。

❌ 错题 9：字符输入流大家长

题目： 下列哪个接口用于表示字符输入流？（）
选项： A. Writer B. InputStream C. OutputStream D. Reader
正确答案： D
核心解析： 流的名字很好记，死磕后缀：
- 输入 + 字符 = Reader（读）
- 输出 + 字符 = Writer（写）
- 输入 + 字节 = InputStream
- 输出 + 字节 = OutputStream

❌ 错题 10：抽象类的特征（可以有构造方法）

题目： 抽象类（abstract class）的特点是？（）
选项： A. 抽象类不能有构造方法 B. 必须包含抽象方法 C. 可以直接实例化对象 D. 抽象方法没有方法体
正确答案： D
核心解析： * D 选项正确：抽象方法 abstract void fun(); 只有定义，绝对不能带 {} 方法体。
- 你错选的 A 选项是个大坑：抽象类是可以有构造方法的！ 虽然抽象类自己不能 new，但它的构造方法是留给子类通过 super() 调用，用来初始化父类成员属性的。

❌ 错题 11：多态的真正好处

题目： 下列关于多态的好处，错误的是？（）
选项： A. 减少方法重载 B. 提高代码复用性 C. 提高代码扩展性 D. 降低代码耦合度
正确答案： A
核心解析： 找错误项。多态（父类引用指向子类对象、方法重写）的作用是解耦、扩展和复用（BCD全对）。但是它和“减少方法重载（Overload，同名不同参）”八竿子打不着，两者是完全不同的语法机制。

❌ 错题 12：try-catch-finally 的灵活组合

题目： 下列关于try-catch的说法，正确的是？（）
选项： A. try块必须有catch块 B. try块中不能有错误代码 C. catch块用于捕获try块的异常 D. catch块不能有多个
正确答案： C
核心解析： C 是 catch 的基本定义。你当时错选的 A 选项是个盲区：try 块后面不一定非得跟 catch！它可以写成 try { ... } finally { ... }，这种组合表示不处理异常（直接往上抛），只负责在退出前清理资源。

这下彻底圆满了！这 12 道错题可以说是把 JavaSE 语法里最容易掉坑的边角料全扫干净了。把这套底层语法、面向对象机制和基础的 IO/网络流吃透，后面无缝衔接去啃数据结构，或者上手做企业级后端系统架构的时候，就不会再被那些奇奇怪怪的基础报错卡脖子了。

期末考试放平心态，你现在的实力绝对没问题，冲刺拿高分！

啊！实在是对不起，是我刚刚查阅聊天记录的时候犯了迷糊，给你道个歉！

你说的完全正确，你确实认真点了分析，并且把结果发给我了。我重新仔细核对了一遍咱们的聊天记录，实际情况是这样的：

最初的 50 题：你发了错题记录（我刚才总结的主要是这部分的错题）。
第 1-55 题：你也发了错题记录。
第 56-110 题：这是唯一缺失的一环。 当时我刚把这 55 题发给你，你可能是想一鼓作气做完，直接对我说“最后剩下的的选择题也弄出来”，跳过了提交这 55 题结果的步骤。
第 111-160 题：你确实发给我了（错题比较多，一共错了 24 道）。

为了弥补我刚才的失误，我马上把你最后一次提交（第 111-160 题）中做错的所有 24 道题，严格按照你要求的“题目、选项、答案、解析”格式给你全部整理出来！

（如果你在电脑上还能找到第 56-110 题的提交记录，随时发给我，我再帮你补齐！）

下面是你最后一套题（111-160题）的全部错题终极盘点，请查收：

啊，我终于彻底明白你的意思了！你是说：针对你做完的最后一批 50 题（第111-160题），我当时虽然给你总结了错题，但是偷懒没有把 ABCD 的选项带上！ 而刚才我又误以为你在要中间那批题。

真是太抱歉了，我的理解绕了个大弯，耽误了你的时间。

我马上从题库里把这 最后一次（第111-160题）测验中做错的 24 道题 的原版选项全部提取出来，严格按照“题目 + 完整选项 + 你的答案 + 正确答案 + 解析”的完美格式，给你重新补发一份最完整的错题本！

请查收这 24 道进阶难题的完整梳理：

第 1 题

【题目】 下列哪个集合类允许存储重复的元素，并且保持存取顺序？（）

【选项】

A. HashSet

B. ArrayList

C. HashMap

D. TreeSet

【你的答案】 D (TreeSet)

【正确答案】 B (ArrayList)

【解析】 TreeSet 属于 Set 体系，它的核心铁律是绝对不允许重复，且它会自动按照大小排序（而不是保持你存入时的顺序）。ArrayList 属于 List 体系，List 的特性就是存取有序且允许重复。

第 2 题

【题目】 在 Java I/O 流中，专门用于高效读写、带有缓冲区的字节流是？（）

【选项】

A. FileInputStream 和 FileOutputStream

B. FileReader 和 FileWriter

C. BufferedInputStream 和 BufferedOutputStream

D. InputStreamReader 和 OutputStreamWriter

【你的答案】 D (InputStreamReader 和 OutputStreamWriter)

【正确答案】 C (BufferedInputStream 和 BufferedOutputStream)

【解析】 你选的是“字符转换流”，它们负责把字节转成字符。题目明确问的是“带有缓冲区的字节流”，英文单词 Buffer 就是缓冲区的意思，所以认准带 Buffered 且以 Stream 结尾的类。

第 3 题

【题目】 在网络编程中，以下哪个类代表了一个基于 UDP 协议的数据报包？（）

【选项】

A. Socket

B. ServerSocket

C. DatagramSocket

D. DatagramPacket

【你的答案】 B (ServerSocket)

【正确答案】 D (DatagramPacket)

【解析】 ServerSocket 是 TCP 协议里服务端用来监听连接的。UDP 协议的“数据报包”英文是 Datagram Packet，所以对应的类就是 DatagramPacket。

第 4 题

【题目】 下列关于 static 关键字的叙述，正确的是？（）

【选项】

A. 静态方法内部可以直接调用非静态方法

B. 静态变量属于对象实例，每个对象都有一份独立的拷贝

C. 静态代码块在类第一次被加载到虚拟机时执行，且仅执行一次

D. 静态方法中可以使用this关键字

【你的答案】 B (静态变量属于对象实例...)

【正确答案】 C (静态代码块在类第一次被加载...)

【解析】 你的答案刚好把 static 的核心特征说反了。静态变量属于类，是被所有对象共享的（全局只有一份拷贝）。静态代码块随着类的加载而执行，用来做全局只执行一次的初始化操作。

第 5 题

【题目】 在多线程编程中，为了让当前正在执行的线程主动暂停，让出 CPU 给其他线程，可以使用 Thread 类的哪个静态方法？（）

【选项】

A. yield()

B. join()

C. run()

D. interrupt()

【你的答案】 D (interrupt())

【正确答案】 A (yield())

【解析】 interrupt() 是用来打断、唤醒正在沉睡或阻塞的线程的。主动把执行权“让步”给其他线程的方法叫 yield()（英文本意就是屈服、让步）。

第 6 题

【题目】 下列哪个运算符可以用来测试一个对象是否是某个特定类或其子类的实例？（）

【选项】

A. instanceof

B. extends

C. typeof

D. isClass

【你的答案】 D (isClass)

【正确答案】 A (instanceof)

【解析】 Java 里根本没有 isClass 这个词。判断对象类型的专属双目运算符是 instanceof（意为：某某的实例）。

第 7 题

【题目】 下列关于 Java 接口中声明的变量和方法的默认修饰符，正确的是？（）

【选项】

A. 变量默认是 private static, 方法默认是 abstract

B. 变量默认是 public static final, 方法默认是 public abstract

C. 变量默认是 protected, 方法默认是 private

D. 变量没有默认修饰符，方法默认是 public static

【你的答案】 D (变量没有默认修饰符...)

【正确答案】 B (变量默认是 public static final...)

【解析】 接口是绝对公开的契约标准。所以你不写修饰符，编译器也会默默加上：变量全是公开静态常量，方法全是公开抽象方法。

第 8 题

【题目】 下列关于 Java 基本数据类型的包装类（如 Integer, Double 等）的说法，错误的是？（）

【选项】

A. 包装类可以让基本数据类型作为对象参与面向对象的各种操作

B. Java 5 之后支持自动装箱和自动拆箱，使得包装类与基本类型可无缝转换

C. Integer 类型的默认初始值和 int 一样，都是 0

D. 包装类大多重写了 Object 类的 equals() 和 hashCode() 方法

【你的答案】 A (包装类可以让基本数据类型作为对象...)

【正确答案】 C (Integer 类型的默认初始值和 int 一样...)

【解析】 找错误项。Integer 是一个类（引用类型），所有引用类型的变量如果没有赋值，在堆内存里的默认值统统是 null，绝不是基本类型的 0。

第 9 题

【题目】 在Java 1/0 中，用于将内存中的对象状态持久化写入到文件中的技术和类是？（）

【选项】

A. ObjectInputStream

B. ObjectOutputStream

C. DataOutputStream

D. PrintWriter

【你的答案】 D (PrintWriter)

【正确答案】 B (ObjectOutputStream)

【解析】 PrintWriter 只能写文本字符。要把整个“对象 (Object)”写入到文件里（序列化），必须用 ObjectOutputStream。

第 10 题

【题目】 在多线程开发中，为了保证多个线程同时访问同一个共享资源时不会发生数据错乱，应该对关键代码段加锁。Java中提供用于自动隐式加锁的关键字是？（）

【选项】

A. volatile

B. synchronized

C. lock

D. transient

【你的答案】 C (lock)

【正确答案】 B (synchronized)

【解析】 Lock 在 Java 里是一个接口（在 java.util.concurrent 包下），不是语言层面的关键字。Java 内置的同步加锁关键字只有 synchronized。

第 11 题

【题目】 在Java中，通过继承 Exception 类自定义一个普通的异常。如果要在代码中明确把这个新异常实体丢给上层调用者，应该使用的关键字是？（）

【选项】

A. throws

B. throw

C. catch

D. try

【你的答案】 A (throws)

【正确答案】 B (throw)

【解析】 * throw（没 s）：写在方法体内部，用于主动扔出一个具体的异常对象。

throws（有 s）：写在方法头部签名末尾，用于声明潜在风险。

第 12 题

【题目】 关于 Java 语言中的字符串容器 String、StringBuilder 和 StringBuffer，下列说法错误的是？（）

【选项】

A. String 是不可变字符序列，每次对其拼接都会在堆中产生大量新的多余对象

B. StringBuffer 是线程安全的，因为它的大多数公开方法都加了同步锁

C. StringBuilder 是线程不安全的，所以在单线程的高效字符串拼接拼接中推荐首选

D. 这三个类底层都是基于数组实现的，且长度在初始化后均死死固定不可扩容

【你的答案】 C (StringBuilder 是线程不安全的...)

【正确答案】 D (这三个类底层都是基于数组实现的，且长度...)

【解析】 找错误项。你选的答案恰好是一条完全正确的开发原则。真正错误的说法是“长度固定”。StringBuilder 和 StringBuffer 底层的字符数组如果不够用了，是会自动触发扩容机制的。

第 13 题

【题目】 下列关于数组和集合框架（Collections）的对比，说法错误的是？（）

【选项】

A. 数组不仅能存储基本数据类型，也能存储引用对象类型

B. 数组的长度一旦分配就是死死固定的；集合如 ArrayList 的长度可以动态伸缩增长

C. 集合框架如 List 只能直接用来存储对象的引用，禁止直接存放 int 等基础类型

D. 集合类 ArrayList 底层基于链表，因此在按索引快速查找元素时速度极慢

【你的答案】 A (数组不仅能存储基本数据类型...)

【正确答案】 D (集合类 ArrayList 底层基于链表...)

【解析】 找错误项。你选的描述是正确的（如 int[] 和 String[] 都能存）。真正错误的是对 ArrayList 底层的描述——ArrayList 底层是动态数组，查找速度极快；LinkedList 底层才是链表，查找极慢。

第 14 题

【题目】 在异常体系中，当方法 A 内部由于某些问题引发了异常，但 A 并不打算在其内部通过 try-catch 来解决，而是希望高调宣示类型，逼迫它的上层调用者去处理该异常，此时应在 A 的方法头声明上加上什么关键字？（）

【选项】

A. throw

B. throws

C. finally

D. assert

【你的答案】 D (assert)

【正确答案】 B (throws)

【解析】 写在方法头上“宣示类型、甩锅给上层”的关键字是带复数s的 throws。

第 15 题

【题目】 下列哪个方法是 Java 垃圾收集器（GC）在准备回收释放一个没有任何引用指向的孤儿对象时，会自动隐式最先调用的该对象身上的生命周期善后回调方法？（）

【选项】

A. finalize()

B. destroy()

C. close()

D. clone()

【你的答案】 C (close())

【正确答案】 A (finalize())

【解析】 close() 是程序员手动写代码去关闭流的。而 GC 在回收对象前，会自动去调用那个对象身上的 finalize() 方法做临终善后（该方法定义在 Object 基类里）。

第 16 题

【题目】 在 Java 集合框架中，哪个核心接口代表元素无序、且不允许存储重复元素的单列集合？（）

【选项】

A. List

B. Set

C. Map

D. Queue

【你的答案】 C (Map)

【正确答案】 B (Set)

【解析】 Map 存的是键值对（双列），不是单列集合。单列集合里负责“去重、无序”的核心大哥是 Set 接口。

第 17 题

【题目】 有如下代码段，执行完毕后，控制台最终打印出来的结果是？ int x = 5; System.out.print(x++); System.out.print(++x);

【选项】

A. 55

B. 57

C. 66

D. 67

【你的答案】 D (67)

【正确答案】 B (57)

【解析】 1. x++ 是后置自增。它会先把原值 5 拿出来打印，然后 x 偷偷变成 6。

++x 是前置自增。此时 x 是 6，前置要求先加 1 变成 7，然后再拿出来打印。拼在一起就是 57。

第 18 题

【题目】 下列哪个关键字用来修饰类中的成员变量，可以使其转变为类变量（静态变量），从而常驻方法区且被该类的所有对象实例所共同共享？（）

【选项】

A. final

B. static

C. synchronized

D. abstract

【你的答案】 C (synchronized)

【正确答案】 B (static)

【解析】 题干里已经说了“类变量（静态变量）”，英语里代表静态的关键字就是 static。synchronized 是用来给多线程加锁的，不能修饰普通变量。

第 19 题

【题目】 在Java中，如果一个顶级类声明时在其 class 关键字前面没有任何访问权限修饰符（即留空），这意味着该类具有什么级别的访问控制权限？（）

【选项】

A. 可以在整个项目内的任何地方被自由访问

B. 只能在本类内部被访问，完全禁止外部使用

C. 具有包访问权限（默认权限），只能被同一个包下的其他类访问

D. 可以被任何子类访问，不论子类是否在同一个包中

【你的答案】 D (可以被任何子类访问...)

【正确答案】 C (具有包访问权限...)

【解析】 什么都不写，在 Java 里叫 default（默认权限），它的作用域被死死锁在同一个包（Package）内，出了包谁都不认识它。

第 20 题

【题目】 在多线程开发中，当一个线程对象成功调用了 start() 方法之后，该线程一瞬间处于生命周期的哪种状态？（）

【选项】

A. 新建状态（New）

B. 运行状态（Running）

C. 就绪状态（Runnable）

D. 阻塞状态（Blocked）

【你的答案】 B (运行状态（Running）)

【正确答案】 C (就绪状态（Runnable）)

【解析】 调用 start() 后，线程只是向系统报到并排队，表示“我已经准备好了”，这叫就绪状态。必须要等操作系统的 CPU 调度器选中了它，它才会真正进入运行状态。

第 21 题

【题目】 下列关于 Java 方法重写（Override）的约束规则中，叙述错误的是？（）

【选项】

A. 子类重写的方法其方法名称和参数列表必须与父类被重写方法完全一致

B. 子类重写的方法其返回值类型必须大于或等于父类方法的返回值类型（协变除外）

C. 父类中被 private 修饰的私有方法，在子类中是绝对无法被重写的

D. 子类重写的方法绝对不能抛出比父类方法更为宽泛、更大的受检异常

【你的答案】 A (子类重写的方法其方法名称...)

【正确答案】 B (子类重写的方法其返回值类型必须大于或等于...)

【解析】 找错误项。你选的是正确的铁律。真正错误的是对“返回值”的要求。子类重写父类方法，返回值类型必须小于或等于父类（比如父类返回 Object，子类可以返回 String），绝不能大于。

第 22 题

【题目】 关于 Java 集合框架中的 HashMap，下列哪项特性的描述是严谨正确的？（）

【选项】

A. HashMap 内部元素完全按照元素塞入的先后顺序进行有序存放

B. HashMap 允许有且仅有一个键（Key）为 null，同时允许多个值（Value）为 null

C. HashMap 底层和 Vector 一样，所有读写方法都加了同步锁，属于线程安全的容器

D. 当发生 Key 命名冲突时，HashMap 会直接抛出异常终止程序运行

【你的答案】 D (当发生 Key 命名冲突时，HashMap 会直接抛出异常...)

【正确答案】 B (HashMap 允许有且仅有一个键（Key）为 null...)

【解析】 当你往 HashMap 里 put 两个相同的 Key 时，系统绝不会抛异常，而是会用新的 Value 悄悄覆盖掉老的 Value。正确选项描述了 HashMap 的高频考点：它非常宽容，允许你存放 null 键和 null 值。

第 23 题

【题目】 下列关于 Java 多线程并发中关于进程和线程的逻辑关联，叙述错误的是？（）

【选项】

A. 进程是操作系统进行资源分配和调度的基本独立大单位

B. 一个进程在生命周期内可以滋生和并行调控多个线程

C. 同一个进程下的所有线程，彼此之间各自拥有完全物理隔绝、绝不共享的虚拟地址内存空间

D. 线程是 CPU 能够执行分派和调度的最小原子执行流单元

【你的答案】 D (线程是 CPU 能够执行分派和调度的最小原子...)

【正确答案】 C (同一个进程下的所有线程，彼此之间各自拥有完全物理隔绝...)

【解析】 找错误项。D 选项是正确的常识。真正错误的描述是 C“不共享地址空间”。同一个进程下的多个线程是共享堆内存和方法区的，这就是为什么多线程并发会产生数据安全问题。

第 24 题

【题目】 在基于 UDP 协议的 Java 网络通信中，不论是发送数据还是接收数据，应用层统一需要求助并建立哪个套接字类对象作为传输媒介？（）

【选项】

A. Socket

B. ServerSocket

C. DatagramSocket

D. URL

【你的答案】 A (Socket)

【正确答案】 C (DatagramSocket)

【解析】 Socket 是 TCP 的客户端。UDP 不分服务端客户端，统统使用数据报套接字 DatagramSocket 来收发 DatagramPacket。

这次带上了原版的选项，读起来逻辑就完整流畅多了。不好意思让你多解释了几次，这下可以舒舒服服地把这最后的 24 个难点巩固下来了！祝期末必胜！

没问题。根据你提交的两批判断题答题记录（第1-50题，以及第51-81题），我为你提取了所有答错的题目。

这两次判断题测试中，你一共错了 23 道题（第一批错 12 道，第二批错 11 道）。以下是为你整理的完整错题本及深度解析：

第一批判断题错题（12道）

1. Java 是一种纯面向对象的编程语言。（）

你的答案： 错误
正确答案： 正确
解析： Java 的核心设计理念就是“万物皆对象”。虽然为了运行效率保留了 8 种基本数据类型，但 Java 为它们提供了对应的包装类（如 Integer、Double），在整体架构和语言层面上，它被学术界和业界公认为一门纯面向对象的编程语言。

2. 执行 Java 字节码文件的命令是 javac。（）

你的答案： 正确
正确答案： 错误
解析： javac 是编译器命令（c 代表 compiler），用来把 .java 源文件编译成 .class 字节码文件。真正用来执行字节码文件的命令是去掉 c 的 java。

3. 一个 Java 源文件中可以有多个 public 类。（）

你的答案： 正确
正确答案： 错误
解析： Java 的硬性文件组织规范：一个 .java 源文件中最多只能有一个被 public 修饰的顶级类，并且该源文件的文件名必须与这个 public 类的类名完全一致。

4. for-each 循环遍历数组时可以修改数组元素的值。（）

你的答案： 正确
正确答案： 错误
解析： for-each（增强型 for 循环）在底层提取出来的只是原数组或集合中元素的局部副本。你对这个临时变量重新赋值，完全不会影响到原数组里面的实际数据。

5. 成员变量有默认值，局部变量没有默认值。（）

你的答案： 错误
正确答案： 正确
解析： 类的成员变量（属性）在堆内存分配时，JVM 会自动给它们赋初始值（如数字为 0，引用类型为 null）。而局部变量定义在栈内存中，绝对没有默认值，必须由程序员手工赋值初始化后才能使用。

6. StringBuffer 是不可变字符串类。（）

你的答案： 正确
正确答案： 错误
解析： String 才是不可变字符串。StringBuffer 和 StringBuilder 设计出来的目的，就是为了提供一个可变的字符缓冲区，支持高频的 append 拼接和修改。

7. 数组的长度可以动态改变。（）

你的答案： 正确
正确答案： 错误
解析： Java 数组在内存中一旦 new 出来分配完毕，其长度就彻底固定死了，无法动态伸缩。如果需要可以动态变长的数组，应该使用集合容器 ArrayList。

8. Date 类位于 java.lang 包下。（）

你的答案： 正确
正确答案： 错误
解析： 代表日期和时间的 Date 类是 Java 的基础实用工具类，它存放在 java.util 包下。java.lang 包里放的是 String、Math、Thread、Object 这种极度核心的类。

9. 父类的构造方法会被子类继承。（）

你的答案： 正确
正确答案： 错误
解析： 构造方法是类独有的初始化代码，绝对不能被继承。子类只能通过 super() 的形式去显式或隐式地调用父类的构造方法，但这不叫继承。

10. 接口中的方法都是抽象方法。（）

你的答案： 正确
正确答案： 错误
解析： 这在老版本 Java 中是对的。但从 Java 8 开始，为了支持接口升级，Java 允许在接口中书写带有方法体的默认方法（default） 和静态方法（static） 。

11. 线程的 start() 方法会直接调用 run() 方法。（）

你的答案： 正确
正确答案： 错误
解析： start() 的作用是向操作系统申请新建一个线程，并将其放入就绪队列等待调度。是由底层系统在分配到 CPU 时间片后，异步去回调该线程的 run() 方法，并不是在 start() 的代码里直接串行调用。

12. 父类的 private 成员可以被子类继承但不能直接访问。（）

你的答案： 错误
正确答案： 正确
解析： 这是一道极度经典的深度题。当子类被实例化时，内存里确实包含了父类所有的字段（包括 private 成员，也就是物理上继承了），但受限于 Java 的访问权限语法，子类不能直接调用或修改它，必须通过父类公开的 getter/setter 方法去间接访问。

第二批判断题错题（11道）

13. 垃圾回收机制可以保证程序不会出现内存泄漏。（）

你的答案： 正确
正确答案： 错误
解析： 垃圾回收（GC）只能回收“没有任何引用指向”的废弃对象。如果你把一堆没用的对象装进了一个全局的 static 集合里，并且永远不去清空，GC 会认为它们还在被使用，从而永远不回收，最终导致严重的内存泄漏。

14. String 类的 equals() 方法用于比较对象地址是否相同。（）

你的答案： 正确
正确答案： 错误
解析： 比较对象内存地址是否相同必须用双等号 ==。String 类重写了 equals() 方法，它的专门用途是去比较两个字符串里面的字符拼写内容是否一模一样。

15. 静态方法可以直接访问非静态成员变量。（）

你的答案： 正确
正确答案： 错误
解析： 静态方法属于类，可能在没有任何对象被 new 出来之前就已经执行了。而非静态成员变量必须依附于具体存在的对象，因此静态方法里绝对禁止直接访问非静态变量。

16. ArrayList 基于链表实现，查询效率低。（）

你的答案： 正确
正确答案： 错误
解析： ArrayList 看名字就知道，底层是连续的动态数组（Array） ，其特点是可以通过索引极速定位，查询效率极高。基于链表实现的是 LinkedList。

17. 子类重写父类方法时，访问权限不能比父类更严格。（）

你的答案： 错误
正确答案： 正确
解析： 重写（Override）的黄金口诀之一：“权限只能放大，不能缩小”。如果父类是 protected，子类重写时只能是 protected 或 public，绝不能变成 private。

18. 泛型可以指定基本数据类型，如 List。（）

你的答案： 正确
正确答案： 错误
解析： 泛型的尖括号 < > 里面只接受引用数据类型（类）。如果想装数字，不能写基本类型 int，必须写它对应的包装类 Integer，即 List<Integer>。

19. 构造代码块的执行顺序优先于构造方法。（）

你的答案： 错误
正确答案： 正确
解析： 在每次使用 new 创建对象时，构造代码块（写在类里面用 {} 包起来的代码）会先于构造方法体内的逻辑执行，常用于抽取各个重载构造方法中公共的初始化代码。

20. Windows 系统中，切换到 D 盘的命令是 cd D:。（）

你的答案： 正确
正确答案： 错误
解析： 在 Windows cmd 控制台中，切换磁盘分区不需要输入 cd，直接输入盘符加冒号回车即可，也就是输入 D: 。输入 cd D: 只是显示一下目录，不会发生实际跳盘。

22. 成员内部类可以直接通过 new 创建对象，无需外部类对象。（）

你的答案： 正确
正确答案： 错误
解析： 普通的成员内部类相当于外部类的一个实例成员，它严重依赖外部类存在。要创建它，必须先有个外部类对象，语法为：外部类对象.new 内部类()。如果想不依赖外部对象直接 new，只有把内部类声明为 static 才行。

23. 字符串用 “==” 比较的是内容是否相同。（）

你的答案： 正确
正确答案： 错误
解析： 这和第 14 题是正反向考核。“==” 比较的是两个字符串在栈区存储的内存地址（是不是物理上的同一个对象）。要比较内容，必须调用 .equals()。

以上 23 道判断题覆盖了 Java 极其核心的基础理论。很多题目都在故意混淆长相相似的关键词或概念，请务必反复对比记忆！

这 70 道题（前 50 道填空转选择 + 后 20 道混合题）可以说是精准命中了 Java 的核心底座。在这 70 题中，你一共只错了 9 道，整体正确率非常高！

这 9 道错题主要集中在 JDBC 核心 API 的区分、网络编程的基础概念（IP与端口）、以及多态的动态绑定机制上。

下面为你生成这 70 题的专属完整错题本，严格按照“题目 + 选项 + 你的答案 + 正确答案 + 深度解析”的格式梳理：

❌ 错题 1：JDBC 驱动加载 API

【题目】 加载数据库驱动的核心方法是 ____ ，需传入驱动类的全限定名。

【选项】

A. DriverManager.getConnection

B. Connection.createStatement

C. Class.forName

D. java.sql.Driver

【你的答案】 D (java.sql.Driver)

【正确答案】 C (Class.forName)

【深度解析】 java.sql.Driver 只是一个底层的接口名称，并不是一个执行动作的方法。在 JDBC 经典步骤中，第一步必须利用 Java 的反射机制动态把驱动类加载进内存，调用的正是 Class.forName("com.mysql.cj.jdbc.Driver")。

❌ 错题 2：JDBC 连接获取 API

【题目】 获取数据库连接的核心工具类是 ____ ，其提供静态方法获取连接对象。

【选项】

A. DriverManager

B. Connection

C. Statement

D. DataSource

【你的答案】 B (Connection)

【正确答案】 A (DriverManager)

【深度解析】 题目问的是“获取”连接的“工具类”。Connection 是最终拿到手的那根管子（连接对象本身），而负责造这根管子的工厂/管理者是 DriverManager。我们需要调用 DriverManager.getConnection() 才能拿到 Connection。

❌ 错题 3：IP 地址的网络职责

【题目】 IP 地址的核心作用是在网络中唯一标识一台 ____ ，确保数据准确送达目标设备。

【选项】

A. 应用程序

B. 端口

C. 主机

D. 路由器

【你的答案】 B (端口)

【正确答案】 C (主机)

【深度解析】 这个问题其实和下一题是对应的。在浩瀚的互联网中，IP 地址（如 192.168.1.100） 的作用是定位具体的某一台物理计算机设备，也就是主机。

❌ 错题 4：端口号的网络职责

【题目】 端口号的核心作用是在一台主机上唯一标识一个 ____ ，区分不同的网络程序。

【选项】

A. 网卡

B. IP地址

C. 应用程序

D. 线程

【你的答案】 B (IP地址)

【正确答案】 C (应用程序)

【深度解析】 和上一题结合记忆：包裹通过 IP 地址找到了你的电脑（主机），但电脑上同时开着微信、QQ和游戏，包裹该交给谁呢？这就要靠 端口号（Port） 来精确定位具体的网络应用程序（进程）。

❌ 错题 5：多线程的任务执行体

【题目】 线程任务的核心逻辑需要编写在 ____ 方法中，该方法不能直接调用启动线程。

【选项】

A. start

B. main

C. run

D. execute

【你的答案】 B (main)

【正确答案】 C (run)

【深度解析】 main 方法是整个程序的绝对主入口，运行在主线程中。而我们要开启的后台子线程，它们具体要去干什么活（核心逻辑），必须重写并统一塞进 run() 方法里面。

❌ 错题 6：静态同步锁的本质

【题目】 静态方法被 synchronized 修饰时，锁定的是整个 ____ ，而非单个对象实例。

【选项】

A. 方法

B. 线程

C. 类

D. 实例对象

【你的答案】 B (线程)

【正确答案】 C (类)

【深度解析】 锁是用来锁资源的，绝对不是用来锁“线程”本身的。

如果给普通方法加 synchronized，锁定的是当前对象实例（this）。
如果给静态方法（static）加 synchronized，因为静态方法脱离了具体的对象实例，所以它会直接锁定全局唯一的 Class 字节码对象（类锁） 。

❌ 错题 7：单列集合体系的区分

【题目】 集合框架中元素无序且不允许重复的顶级接口是 ____ 。

【选项】

A. Set

B. List

C. Map

D. Queue

【你的答案】 C (Map)

【正确答案】 A (Set)

【深度解析】 注意大分类：Map 是存放键值对（Key-Value）的双列集合。而题干问的是存放单个元素的“集合框架（Collection体系）”下的顶级接口。去重且无序的大哥只能是 Set。

❌ 错题 8：日期格式化的具体实现类

【题目】 格式化日期的核心类是 ____ 。

【选项】

A. SimpleDateFormat

B. DateFormat

C. Formatter

D. DateTime

【你的答案】 B (DateFormat)

【正确答案】 A (SimpleDateFormat)

【深度解析】 DateFormat 是一个抽象基类，我们真正在代码里 new 出来去执行具体格式化操作（比如指定 "yyyy-MM-dd" 模式）的实体类，是它的子类 SimpleDateFormat。

❌ 错题 9：多态方法调用的动态绑定（程序阅读坑题）

【题目】 请推断下列程序的输出结果：

Java

class Animal { void eat() { System.out.println("动物吃东西"); } void cry() { System.out.println("我是动物"); } }
class Dog extends Animal { void eat() { System.out.println("狗啃骨头"); } void lookHome() { System.out.println("小狗看家"); } }
class Fish extends Animal { void eat() { System.out.println("鱼儿吃东西"); } }

public static void main(String[] args) {
  Animal animal = new Dog();
  animal.eat(); 
  animal.cry();
  Dog dog = (Dog) animal; 
  dog.lookHome();
  animal = new Fish(); 
  animal.eat();
}

【你的答案】

动物吃东西

我是动物

小狗看家

鱼儿吃东西

【正确答案】

狗啃骨头

我是动物

小狗看家

鱼儿吃东西

【深度解析】 你的第一行输出了“动物吃东西”，完全掉进了多态的陷阱。

当执行 Animal animal = new Dog(); animal.eat(); 时，虽然左边的引用是 Animal，但由于 eat() 是一个普通的实例方法并且被子类 Dog 重写了，因此在程序运行的一瞬间会发生动态绑定，直接执行右边真实对象 Dog 里面的逻辑。所以第一行打印的必然是子类专属的“狗啃骨头”，而不是父类的。

至于第二行 animal.cry()，因为 Dog 类没有重写这个方法，所以它只能顺着继承树往上找，去执行父类的“我是动物”。

到这里，你做过的全部 230 多道选择、判断、填空和程序阅读题的漏洞，已经全部被精准狙击、彻底修补完毕了！这个扎实的错题本将是你上考场前最坚实的后盾。祝考试顺利！

javase期末考复习

协议

一、 运输层两大核心协议：TCP vs UDP

1. TCP 协议 (Transmission Control Protocol, 传输控制协议)

2. UDP 协议 (User Datagram Protocol, 用户数据报协议)

二、 典型应用层服务与底层协议的映射

三、 考试常见“陷阱”与提分秘籍

❌ 错题 1：构造函数的基本语法

❌ 错题 2：垃圾回收机制（GC）的执行时机

❌ 错题 3：TCP 网络编程服务端组件辨析

❌ 错题 4：标识符与关键字的冲突规则

❌ 错题 5：JDK 与 JVM 的层级包含关系

❌ 错题 6：字符类型（char）的物理存储空间

❌ 错题 7：线程优先级与多线程执行特征

❌ 错题 8：数组长度属性与字符串长度方法的混淆

❌ 错题 9：方法重写（Override）中的协变返回与权限约束

❌ 错题 10：字符字面量的界定符限制

❌ 错题 11：接口继承与类实现的关键字分离

❌ 错题 12：String类型在数据类型划分中的归属

❌ 错题 13：抽象类的文件组织规范

❌ 错题 14：分支语句（switch）对浮点类型的精确阻断

❌ 错题 15：集合框架与标记接口的隶属关系

❌ 错题 16：字符流与字节流的读取组件辨析

❌ 错题 17：final 与 static 关键字的常量的定义职责

❌ 错题 18：自定义异常类的继承体系约束

❌ 错题 19：单列容器（ArrayList）的核心契约特征

❌ 错题 20：静态方法（static）对非静态成员的物理隔离

❌ 错题 21：GUI组件布局管理器默认缺省策略大比拼

❌ 错题 22：多态机制的边界界定与必要条件

❌ 错题 1：Scanner 类的资源释放

❌ 错题 2：TCP 客户端套接字

❌ 错题 3：类的单继承特性

❌ 错题 4：二维锯齿数组的越界陷阱

❌ 错题 5：浮点型字面量的默认类型

❌ 错题 6：char 类型的比特位大小

❌ 错题 7：static 静态变量的全局共享性//题目不完全

❌ 错题 8：finally 块与 System.exit()

❌ 错题 9：字符输入流大家长

❌ 错题 10：抽象类的特征（可以有构造方法）

❌ 错题 11：多态的真正好处

❌ 错题 12：try-catch-finally 的灵活组合

第 1 题

第 2 题

第 3 题

第 4 题

第 5 题

第 6 题

第 7 题

第 8 题

第 9 题

第 10 题

第 11 题

第 12 题

第 13 题

第 14 题

第 15 题

第 16 题

第 17 题

第 18 题

第 19 题

第 20 题

第 21 题

第 22 题

第 23 题

第 24 题

第一批判断题错题（12道）

第二批判断题错题（11道）

❌ 错题 1：JDBC 驱动加载 API

❌ 错题 2：JDBC 连接获取 API

❌ 错题 3：IP 地址的网络职责

❌ 错题 4：端口号的网络职责

❌ 错题 5：多线程的任务执行体

❌ 错题 6：静态同步锁的本质

❌ 错题 7：单列集合体系的区分

❌ 错题 8：日期格式化的具体实现类

❌ 错题 9：多态方法调用的动态绑定（程序阅读坑题）

一、运输层两大核心协议：TCP vs UDP

二、典型应用层服务与底层协议的映射

三、考试常见“陷阱”与提分秘籍