学科册 04 · Java · 按考点组织(《Java 2 实用教程》第 7 版)

Java

按考点而不是按理论顺序组织:每个考点给出「考什么题型 → 解题 / 判定步骤 → 示例 → 易错点」。 考点按教材章序排列,章末保留教材小节清单;需要系统讲解时可跳转到配套教学页。

16 个考点 15 章 阅读程序 / 写程序 / 简答 含实验环境配置

考点速查表

按考试出现频率标注:高 = 大题常客,中 = 常规题,了解 = 概念题为主。点击考点名称可直接跳转。

频率考点常见题型所属章节
中1 程序结构与运行方式选择 / 简答第 1 章
中2 基本类型与类型转换选择 / 阅读程序第 2 章
高3 数组程序题第 2 章
高4 运算符与表达式阅读程序写结果第 3 章
高5 分支与循环程序题第 3 章
高6 类与对象、static、参数传值阅读程序 / 简答第 4 章
高7 继承、重写与多态阅读程序写结果第 5 章
中8 接口与面向接口编程简答 / 程序第 6 章
高9 异常与 try-catch-finally阅读程序第 7 章
中10 字符串与常用类程序题第 8 章
了解11 GUI 组件与事件处理简答第 9 章
中12 输入输出流程序 / 简答第 10 章
中13 JDBC 编程简答 / 程序第 11 章
高14 多线程与同步简答 / 程序第 12 章
了解15 网络编程(Socket / UDP)选择第 13 章
高16 泛型与集合框架程序题第 15 章

第 1-2 章 程序结构与数据类型

三个考点,数组是程序题的第一道坎。

考点 1

程序结构与运行方式

选择简答频率 中
判定要点
  1. 一个源文件最多一个 public 类,且文件名必须与 public 类同名(大小写一致)。
  2. main 方法签名固定:public static void main(String[] args)。
  3. 编译 javac 文件名.java → 生成 .class;运行 java 类名,不带 .class。
  4. 平台无关性来源:源程序 → 字节码 → 由各平台的 JVM 解释执行。
易错点
  • 写 java Hello.class → 报"找不到或无法加载主类"。
  • 一个文件里写两个 public 类 → 编译报错。
  • 把 JDK 与 JRE 混为一谈:JDK 含编译器,JRE 只能运行。
考点 2

基本类型与类型转换

选择阅读程序频率 中
判定步骤
  1. 看类型是否合法:float 字面量必须加 F(3.14F),大整数 long 要加 L。
  2. 看范围:byte 1 字节(-128~127)、short 2、int 4、long 8、float 4、double 8、char 2(0~65535)。
  3. 看转换方向:小→大自动转换(byte→short→char→int→long→float→double);大→小必须强制转换,且直接截断小数。
  4. 看除法:两个整数相除结果必为整数(5/2 = 2);要先转浮点再除。
  5. 看默认值:成员变量有默认值(0 / 0.0 / false / null),局部变量没有,未赋值使用编译报错。
示例
  • int n = (int) 3.99; → 结果 3(截断,不是四舍五入;四舍五入用 Math.round)。
  • 1 / 2 * 3.0 → 0.0(先算整数除法 1/2 = 0)。
易错点
  • byte b = 200; 编译失败(超范围)。
  • 以为强制转换会四舍五入。
  • char 用单引号、String 用双引号,混用报错。
考点 3

数组 ★

程序题频率 高
解题步骤
  1. 声明 + 创建:int[] a = new int[5];(元素默认 0)或静态初始化 int[] b = {1,2,3};。
  2. 长度用 a.length(属性,不是方法);二维:m.length 是行数、m[0].length 是第一行列数。
  3. 遍历用 for 或 for-each;for-each 的循环变量是副本,不能用来改元素。
  4. 引用语义:int[] c = b; 只是复制引用,改 c 会影响 b;要副本用 Arrays.copyOf。
  5. 排序用 Arrays.sort,输出用 Arrays.toString。
示例
  • 二维数组求和:for (int[] row : m) for (int v : row) sum += v;
  • 遍历时删除元素必须用 Iterator.remove(),直接 list.remove() 会抛 ConcurrentModificationException。
易错点
  • 下标越界(ArrayIndexOutOfBoundsException),循环条件应是 i < a.length。
  • 把 length 写成 length()。
  • 以为 int[] c = b 复制了数组。
教材小节对照
  • 1.1-1.5 Java 入门与程序开发步骤 2.1 标识符与关键字 2.2 基本数据类型 2.3 类型转换 2.4 输入输出 2.5 数组 2.6 枚举

第 3 章 运算符、分支与循环

两个高频考点,"阅读程序写结果"基本都出自这里。

考点 4

运算符与表达式 ★

阅读程序写结果频率 高
判定步骤(按顺序排查)
  1. 先找自增自减:i++ 先用后加,++i 先加后用;一个表达式里出现多次要逐步更新变量值。
  2. 再看短路:&& 左侧为 false 时右侧不执行;|| 左侧为 true 时右侧不执行;&、| 两侧都执行。
  3. 整数除法:/ 对整数取整,% 取余,注意负数的余数符号规则。
  4. 复合赋值:a += b 隐含强制转换,等价写法要考虑类型宽度。
  5. 比较运算:== 对基本类型比值,对引用类型比地址;字符串比内容用 equals。
示例
  • int i = 5; int j = i++ + ++i; → i++ 取值 5(i 变 6),++i 使 i 变 7 并取值 7,故 j = 12,最终 i = 7。
  • s != null && s.length() > 0 中若 s 为 null,右侧不执行 → 不会抛异常(换成 & 就会抛)。
易错点
  • 自增出现在同一表达式多次时,变量值逐步变化,必须一步一步算。
  • 把 = 当成比较写进 if 条件(基本类型会编译报错,布尔类型则静默出错)。
考点 5

分支与循环 ★

程序题频率 高
解题步骤
  1. 确定循环范围:已知次数用 for,未知次数用 while;至少要执行一次用 do-while(末尾有分号)。
  2. 边界:数组遍历写 i < arr.length;从 1 开始计数写 i <= n。
  3. switch:每个 case 后要写 break,否则穿透执行后续 case;default 放最后。
  4. break / continue:break 结束整个循环,continue 跳过本次;跳出多层循环用带标签的 break。
  5. 常见算法模板:求最值(先设首元素为初始最值)、累加、计数、判素数(循环到 Math.sqrt(n))。
示例
  • 判素数:for (int i = 2; i * i <= n; i++) if (n % i == 0) return false;
  • 带标签跳出:outer: for(...) for(...) if (条件) break outer;
易错点
  • switch 漏 break 造成穿透(阅读程序题常见陷阱)。
  • if / while 后省略花括号,只有第一条语句受控。
  • 循环变量在循环外被复用,导致结果异常。
教材小节对照
  • 3.1 运算符与表达式 3.2 语句概述 3.3 if 分支 3.4 switch 3.5 循环语句 3.6 break 与 continue

第 4-5 章 类与对象、继承与多态

两个核心考点,"阅读程序写结果"的必考区。

考点 6

类与对象、static、参数传值 ★

阅读程序简答频率 高
判定步骤
  1. 对象创建:new 时调用构造方法;自定义了构造方法后系统不再提供无参构造(无参 new 会报错)。
  2. static 变量被所有对象共享:统计对象个数之类的题,static 计数会累加;实例变量各对象独立。
  3. 参数传值:基本类型传值副本(方法内修改不影响实参);引用类型传引用副本(改对象状态会影响实参,但让引用指向新对象不会影响实参)。
  4. 重载只看参数列表(个数、类型、顺序),与返回值无关。
  5. 访问权限:private(本类)< 默认(同包)< protected(子类)< public。
示例
  • void f(int x) { x = 10; } 调用后实参不变;void g(Student s) { s.age = 10; } 调用后对象的 age 变了。
  • static 方法不能直接用 this,也不能直接访问实例成员。
易错点
  • 以为"传引用"就能在方法里让实参指向新对象(不能)。
  • 在 static 方法里访问实例变量 → 编译报错。
  • 局部变量未初始化就使用。
考点 7

继承、重写与多态 ★

阅读程序写结果频率 高必考
判定步骤(三步法)
  1. 看引用声明类型:决定能调用哪些方法(上转型对象只能调用父类声明过的方法)。
  2. 看对象实际类型:决定执行哪个版本——被重写的方法运行期动态绑定,执行子类版本。
  3. 成员变量没有多态:访问哪个变量取决于引用的声明类型(这是最经典的陷阱)。
  4. 静态方法也不具有多态性(调用取决于声明类型)。
  5. 子类构造方法默认先调用父类无参构造;父类无无参构造时必须显式 super(...),且为第一条语句。
示例
  • Animal a = new Dog(); a.sound(); → 执行 Dog 重写后的 sound(汪汪)。
  • 若父类与子类都有 int x,通过 a.x 访问到的是父类的 x。
  • a.fetch()(子类新增方法)编译报错,需向下转型 ((Dog) a).fetch()。
易错点
  • 把"变量隐藏"当成重写——变量没有多态。
  • 重写时缩小访问权限(如父类 public、子类 protected)→ 编译错误。
  • 子类构造方法未调用 super 且父类无无参构造 → 编译错误。
配套练习
  • 给定父子类(含同名变量与重写方法),写出 new Sub() 并上转型后调用的输出结果。
  • 说明重写与重载的三点区别,并各写一个例子。
教材小节对照
  • 4.1-4.7 类与对象(构造、传值、static、重载、this、包与权限)
  • 5.1-5.8 继承(继承性、重写、super、final、上转型、多态、abstract、面向抽象)

第 6-7 章 接口与异常

两个考点,异常的执行顺序是阅读题常客。

考点 8

接口与面向接口编程

简答程序频率 中
要点 / 判定
  1. 接口中的方法默认 public abstract,变量默认 public static final。
  2. 实现类必须重写全部抽象方法,否则该类必须声明为 abstract。
  3. 接口不能被实例化,但可以声明接口类型的引用(接口回调)。
  4. 一个类可实现多个接口,但只能继承一个父类(extends 在前、implements 在后)。
  5. 接口与抽象类:接口强调"能力/规范",抽象类强调"共性/复用"。
易错点
  • new 接口() → 编译错误。
  • 实现类重写时漏写 public(接口方法默认 public,实现时不能降低权限)。
考点 9

异常与 try-catch-finally ★

阅读程序频率 高
判定步骤
  1. 匹配 catch:按从上到下、子类在前的顺序匹配第一个能容纳异常类型的 catch。
  2. finally 总会执行:即使 try 或 catch 中有 return,也会先执行 finally(返回值会先暂存)。
  3. 未捕获的异常:向上抛给调用者,最终由 JVM 处理并打印栈轨迹。
  4. 受检异常必须处理(捕获或 throws 声明),运行时异常可不处理。
  5. catch 顺序写反(父类在前)→ 编译错误(子类 catch 不可达)。
示例
  • try 中 return 1、finally 中修改变量 → 返回值仍是暂存的值,finally 的改变不影响返回值(对基本类型)。
  • catch (Exception e) 写在 catch (IOException e) 之前 → 编译错误。
易错点
  • 以为 return 后 finally 不执行。
  • 把异常吞掉(catch 里什么都不写)。
教材小节对照
  • 6.1-6.4 接口与实现 7.1 内部类 7.2 匿名类 7.3 异常类 7.4 try-catch-finally 7.5 自定义异常与断言

第 8-9 章 常用类与图形界面

字符串是程序题常客,GUI 多为概念题。

考点 10

字符串与常用类

程序题频率 中
解题要点
  1. String 不可变:任何"修改"都产生新对象;循环拼接用 StringBuilder(StringBuffer 线程安全但更慢)。
  2. 比较用 equals,== 比较地址;忽略大小写用 equalsIgnoreCase。
  3. 常用方法:length、charAt、substring(左闭右开)、indexOf、split(参数是正则)、trim、toUpperCase。
  4. 数值转换:Integer.parseInt(s)、String.valueOf(x)。
  5. 格式化输出:System.out.printf("%.2f%n", d)。
易错点
  • split(".") 切不出结果——正则中的点表示任意字符,应写 split("\\.")。
  • substring(1,3) 取的是下标 1、2 两个字符。
  • 循环里用 s += 拼接,效率低。
考点 11

GUI 组件与事件处理

简答频率 了解
答题要点
  1. 三要素:事件源(组件)、事件对象、监听器。
  2. 流程:创建监听器 → 注册到事件源 → 事件发生时回调对应方法。
  3. 布局管理器决定组件位置(BorderLayout / FlowLayout / GridLayout 等)。
  4. 匿名内部类或 Lambda 常用于一次性监听器。
易错点
  • 按钮无反应:监听器未注册、组件未加入容器、窗口未 setVisible(true)。

第 10-11 章 输入输出流与 JDBC

两个考点,一个考流程一个考代码。

考点 12

输入输出流

程序简答频率 中
解题步骤
  1. 先分流派:文本用字符流(Reader/Writer,涉及编码),二进制用字节流(InputStream/OutputStream)。
  2. 加缓冲:BufferedReader / BufferedWriter 套在节点流之上。
  3. 关资源:用 try-with-resources 自动关闭(实现 AutoCloseable 的资源)。
  4. 序列化:类实现 Serializable,transient 成员不参与。
示例
  • 读文本:try (BufferedReader br = new BufferedReader(new FileReader("in.txt"))) { while ((line = br.readLine()) != null) ... }
  • 中文乱码:指定 StandardCharsets.UTF_8 并确保文件编码一致。
易错点
  • 忘记关闭流(数据可能未写出)。
  • 读写两端编码不一致导致乱码。
考点 13

JDBC 编程

简答程序频率 中
答题 / 写代码步骤(六步)
  1. 加载驱动(MySQL 8:com.mysql.cj.jdbc.Driver)。
  2. 建立连接:DriverManager.getConnection(url, user, pwd),URL 形如 jdbc:mysql://localhost:3306/school?useSSL=false&serverTimezone=UTC。
  3. 创建语句:优先 PreparedStatement(? 占位符,防注入)。
  4. 执行:查询 executeQuery 得 ResultSet;增删改 executeUpdate 得影响行数。
  5. 处理结果:while (rs.next()) 逐行取值。
  6. 关闭资源(逆序:ResultSet → Statement → Connection)。
易错点
  • ResultSet 未调用 next() 就取值。
  • 拼接 SQL 字符串(注入风险),应用 PreparedStatement。
  • 事务未关闭自动提交,异常时未 rollback。
教材小节对照
  • 8.1-8.6 常用实用类 9.1-9.5 组件与事件 10.1-10.5 输入输出流 11.1-11.6 JDBC 与 MySQL

第 12-13 章 多线程与网络

多线程是简答与程序题的常见来源。

考点 14

多线程与同步 ★

简答程序频率 高
解题 / 答题步骤
  1. 创建方式:继承 Thread 或实现 Runnable(后者便于共享资源);启动必须调用 start()。
  2. 共享数据保护:用 synchronized(修饰方法或代码块)保证互斥。
  3. 线程协作:wait / notify 必须在同步块中调用;wait 释放锁、sleep 不释放锁。
  4. 状态转换:新建 → 就绪 → 运行 → 阻塞 → 死亡;start 进入就绪态而非立即运行。
  5. join 等待线程结束;守护线程随主线程退出。
示例
  • 计数器并发加一结果偏小:因为 n++ 不是原子操作,需 synchronized 或使用原子类。
  • t.run() 不会启动新线程,只是普通方法调用。
易错点
  • 用 run() 代替 start()。
  • 在同步块外调用 wait/notify → 抛 IllegalMonitorStateException。
  • 依赖线程调度顺序编写逻辑(执行顺序不确定)。
考点 15

网络编程(Socket / UDP)

选择频率 了解
答题要点
  1. TCP:面向连接、可靠;服务端 ServerSocket.accept() 阻塞等待连接,客户端 new Socket(host, port)。
  2. UDP:无连接、可能丢包但开销小;用 DatagramSocket 与 DatagramPacket。
  3. URL 类可直接读取网络资源;InetAddress 解析主机名与 IP。
易错点
  • 端口被占用抛 BindException;双方读写顺序不一致可能互相等待。
教材小节对照
  • 12.1-12.7 多线程机制 13.1-13.5 网络编程

第 14-15 章 泛型与集合框架

一个高频考点,程序题常要求用集合实现统计与排序。

考点 16

泛型与集合框架 ★

程序题频率 高
解题步骤
  1. 先选型:需要按下标访问/频繁追加 → ArrayList;去重 → HashSet;按键值统计 → HashMap;需要排序 → TreeSet / TreeMap。
  2. 遍历:for-each 或 Iterator;遍历中删除必须用 Iterator.remove()。
  3. 自定义对象作键:必须同时重写 equals 与 hashCode 且保持一致。
  4. 排序:Collections.sort(自然顺序)或传入 Comparator(自定义规则)。
  5. 泛型是编译期机制(类型擦除),不支持基本类型(需用包装类)。
示例
  • 词频统计:Map<String,Integer> m = new HashMap<>(); m.put(w, m.getOrDefault(w, 0) + 1);
  • 遍历输出:for (Map.Entry<String,Integer> e : m.entrySet()) ...
易错点
  • foreach 中调用 list.remove() → ConcurrentModificationException。
  • 自定义对象作 HashMap 键只重写 equals 未重写 hashCode → 查不到。
  • 泛型中写基本类型(如 List<int>)→ 编译错误,应用 Integer。
配套练习
  • 用 HashMap 统计一段文本中各单词出现次数并输出。
  • 用 Comparator 对自定义 Student 对象按成绩降序、成绩相同按姓名升序排序。
教材小节对照
  • 14.1-14.3 图形、图像与音频 15.1-15.5 泛型与集合框架

练习题

先自己做,再点开解答对照。代码题可直接粘到 Java 在线运行环境 里编译运行。

练习 1 · 阅读程序写结果(自增运算)

  • 题目:下面程序输出什么? int i = 5; int j = i++ + ++i; System.out.println("i = " + i + ", j = " + j);
查看解答
  • 答案:i = 7, j = 12。
  • 推导:i++ 先用后加 —— 取 5 参与运算,然后 i 变成 6; ++i 先加后用 —— i 先变成 7,再取 7 参与运算。
  • 所以 j = 5 + 7 = 12,最终 i = 7。
  • 要点:前缀与后缀自增的区别是必考点;写表达式时尽量避免同一变量多次自增,可读性差。

练习 2 · 用 HashMap 统计单词出现次数

  • 题目:给定字符串数组 {"java", "sql", "java", "cpp", "sql", "java"}, 统计每个单词出现的次数并输出。
  • 提示:getOrDefault(key, 0) 可以避免第一次取值为 null 的问题。
查看解答
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        String[] words = {"java", "sql", "java", "cpp", "sql", "java"};
        HashMap<String, Integer> m = new HashMap<>();
        for (String w : words) {
            m.put(w, m.getOrDefault(w, 0) + 1);
        }
        System.out.println(m);          // {java=3, cpp=1, sql=2}(顺序不保证)
    }
}
  • 要点:HashMap 不保证遍历顺序;若需要按插入顺序输出用 LinkedHashMap。
  • 键的 equals 与 hashCode 决定"同一个键",自定义类做键时必须同时重写这两个方法。

练习 3 · 上转型对象与动态绑定

  • 题目:定义 Animal 类与它的子类 Dog,用 Animal a = new Dog(); 创建对象后调用 a.sound(),输出是什么?
  • 提示:上转型对象调用子类重写过的方法时,执行的是子类版本(动态绑定)。
查看解答
class Animal {
    void sound() { System.out.println("动物叫"); }
}
class Dog extends Animal {
    @Override
    void sound() { System.out.println("汪汪"); }   // 重写父类方法
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();     // 上转型:父类引用指向子类对象
        a.sound();                // 动态绑定 → 执行 Dog 的版本
    }
}
  • 答案:输出 汪汪。
  • 要点:上转型对象不能调用子类新增的成员(编译期按父类类型检查), 但可以调用被子类重写的方法,运行时绑定到子类实现。
  • 加 @Override 注解能让编译器帮你检查是否真的重写成功。

笔记与作业

待补充:上机作业与练手程序、错题(尤其是"阅读程序写结果"类);建议按考点归档为 Markdown 或仓库链接后在此处挂接。
教材版本:本页按《Java 2 实用教程》第 7 版(耿祥义、张跃平,清华大学出版社)章目排布考点,全书 15 章。系统讲解见 基础语法教学(1-3 章) 与 面向对象与 API 教学(4-15 章);本地运行见 实验环境配置。