大纲要求掌握 Java 语言的特点、实现机制和体系结构：为什么 Java 能"一次编写、到处运行"？源文件如何变成可执行程序？JDK / JRE / JVM 之间是什么关系？

Java 语言的主要特点

• 面向对象——封装、继承、多态，一切皆对象
• 平台无关（可移植性）——编译生成字节码，由 JVM 解释执行，与操作系统/硬件"分开"
• 安全性——无指针操作、自动内存管理（垃圾回收），Applet 沙箱机制
• 健壮性——强类型、异常处理机制
• 多线程——内置线程支持
• 自动垃圾回收——程序员无需手工释放内存（Java 要求编程者管理内存 是错误说法）

实现机制：从源码到运行

体系结构：JDK / JRE / JVM

Java 程序结构（必背）

JAVA// 源文件名必须与 public 类名一致：Test.java
public class Test {
    public static void main(String[] args) {
        System.out.println("Hello Java");
    }
}
// 运行：javac Test.java  →  java Test（不带 .class 后缀）

大纲要求：变量和常量、基本数据类型及转换、包装类、运算符和表达式运算、字符串和数组、注释。这一章是全部选择题的基础，务必滚瓜烂熟。

标识符与关键字

• 组成：字母 / 下划线 _ / 美元符 $ 开头，后续可含数字；不能以数字开头
• 不能与关键字重名（如 class、super、do）；区分大小写
• 命名约定：类名首字母大写（PascalCase）；变量、方法名首字母小写（camelCase）；常量名全大写（官方样题）
• 合法：_object、$123、fieldname；不合法：3number、#number、do、super

8 种基本数据类型

类型转换

JAVA// 自动转换：小范围 → 大范围（byte→short→int→long→float→double）
int a = 10;
double d = a;            // 自动，int 可赋给 double

// 强制转换：大范围 → 小范围，可能丢失精度
double x = 3.14;
int y = (int) x;       // y = 3（截断小数部分）

// char 可转为 int（取其 Unicode 码值）
int data = 'f' - 'a';  // data = 5

包装类（Wrapper Class）

Java 为 8 种基本类型提供包装类：Integer / Double / Boolean / Character / Byte / Short / Long / Float，用于把基本类型包装成对象；自动装箱/拆箱（JDK 5+）。

运算符与表达式（易错点集中地）

JAVA// 算术：+ - * / %（取余）；整数除法结果仍为整数
System.out.println(100 % 3);    // 1
System.out.println(100 % 3.0);  // 1.0（float/double 参与 → 结果浮点）

// 关系：==  !=  >  <  >=  <=（= 是赋值，不是关系运算符）
// 逻辑：&&  ||  !   短路求值
// 位运算：&  |  ^  ~  <<  >>  >>>
System.out.println(8 >> 1);      // 4（右移一位，相当于整除 2）

// 三元：条件 ? 表达式1 : 表达式2
System.out.println(3 > 2 ? 4 : 5);  // 4

// 扩展赋值：+=  -=  *=  /=  %=（是表达式语句）
int b = 5;  b *= 2;     // b = 10

进制字面量

• 八进制：以 0 开头，如 0144（十进制 100）
• 十六进制：以 0X / 0x 开头，如 0XA6；科学计数法：-1E3 = −1000.0

大纲要求：选择语句、循环语句、跳转语句、表达式语句。操作题的程序填空大量考查循环与分支的正确写法。

分支语句

JAVAif (score >= 60) {
    System.out.println("及格");
} else if (score >= 90) {
    System.out.println("优秀");
} else {
    System.out.println("不及格");
}

switch (grade) {
    case 'A': System.out.println("优秀"); break;
    case 'B': System.out.println("良好"); break;
    default:  System.out.println("其他");
}

循环语句（while / do-while / for）

JAVAwhile (condition) { ... }        // 先判断后执行，可能一次都不执行
do { ... } while (condition);     // 先执行后判断，至少执行一次
for (int i = 0; i < 10; i++) { ... }   // 初始化; 条件; 步进
for (;;) { ... }                    // 无限循环（合法！）

跳转语句

嵌套循环计算（考试最爱）

JAVAint s = 0;
for (int i = 1; i < 5; i++)          // i = 1,2,3,4
    for (int j = 1; j <= i; j++)
        s = s + j;
System.out.println(s);   // 1 + (1+2) + (1+2+3) + (1+2+3+4) = 20

面向对象是 Java 的灵魂。大纲要求：OOP 基本概念和特征、类的基本组成、对象的生成/使用/删除、包与接口、常用类。

类与对象

JAVAclass Student {
    // 属性（成员变量 / 字段）
    private String name;
    private int age;

    // 构造方法：与类同名、无返回值（也不写 void）
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 方法（行为）
    void show() { System.out.println(name + "," + age); }
}

// 创建对象：new 调用构造方法，返回对象引用
Student s = new Student("张三", 20);
s.show();

构造方法四大规定（官方样题）

• 构造方法名与类名必须相同
• 没有返回值，且不用 void 声明
• 可以重载（多个不同参数的构造方法）
• 只能通过 new 自动调用（不能手动调用）

this 与 super

JAVAclass Animal {
    public Animal() { System.out.print("animal"); }
    public Animal(int n) {
        this();                    // this() 调用本类无参构造
        System.out.print("=" + n);
    }
}
class Dog extends Animal {
    public Dog() {
        super(12);                 // super() 调用父类构造
        System.out.println(" dog");
    }
}
// new Dog() 输出：animal=12 dog（先父类后子类）

封装与访问控制

static 与 final 关键字

JAVAclass Util {
    static int count = 0;          // 静态变量：属于类，所有对象共享
    static void run() { ... }     // 静态方法：属于类，不能直接使用 this
}
// final 类不能被继承；final 方法不能覆盖；final 变量是常量
final class String { }          // String、System 都是 final 类
final double PI = 3.14159;     // 常量：全大写命名（官方样题）

大纲要求：继承、多态和高级类特性、覆盖与重载、抽象类、接口、内部类、枚举。操作题的类设计填空集中在这块。

继承（extends）

JAVAclass Animal {
    void sound() { System.out.println("..."); }
}
class Dog extends Animal {
    @Override
    void sound() { System.out.println("汪"); }   // 覆盖（重写）
    void bark() { System.out.println("汪汪"); }  // 子类新增方法
}

• 覆盖（Override）：子类重新实现父类方法，方法签名一致、访问权限不能缩小、可用 @Override 检查
• 重载（Overload）：同一个类中方法名相同，参数个数/类型/顺序不同；不能只靠返回类型区分
• 子类可覆盖父类方法、增加方法、增加属性；不能访问父类 private 成员
• Java 单继承：一个类只能直接继承一个父类

多态：父类引用指向子类对象

JAVAAnimal a = new Dog();    // 向上转型：父类引用指向子类对象
a.sound();                     // 运行期动态绑定，调用 Dog 的 sound()
// 子类对象可以作为父类对象使用（真题原句）

抽象类与接口（高频对比考点）

JAVA// 抽象类：不能实例化，抽象方法子类必须实现
abstract class Shape {
    abstract double area();          // 抽象方法，无方法体
    void info() { }                   // 普通方法可以有方法体
}
class Circle extends Shape {
    double area() { return 0; }   // 必须实现抽象方法
}

// 接口：implements 实现，一个类可实现多个接口
interface Flyable {
    void fly();
}
class Bird implements Flyable {
    public void fly() { }          // 实现方法必须 public
}

大纲要求：字符串和数组的创建、初始化与引用。String 的常用方法与"不可变"特性、数组下标与越界是必考点。

String 字符串

JAVAString s1 = "123";                 // 字面量，常量池
String s3 = new String("123");    // new 出来的新对象
s1 == s3          // false（引用不同）  s1 == s2（同字面量）→ true
s1.equals(s3)     // true（内容相同）

// String 是不可变对象；StringBuffer / StringBuilder 可变
String s = "Hello";
s.charAt(1)                 // 'e'
s.substring(1, 3)           // "el"（含头不含尾）
s.indexOf("l")               // 2
s.toUpperCase()             // "HELLO"
String.valueOf(123)          // "123" 转字符串
// append() 是 StringBuffer/StringBuilder 的方法，不是 String 的！（官方样题）

数组（一维 / 多维）

JAVAint[] x = {0, 1, 2, 3};        // 声明+初始化
int[] y = new int[5];            // 创建指定长度数组，默认值 0
x.length                      // 4（length 是属性不是方法）
x[0]                          // 访问下标 0 的元素
int[][] m = new int[3][4];     // 二维数组 3 行 4 列
// 下标越界：ArrayIndexOutOfBoundsException（运行时异常）
// 数组大小固定，不能动态扩展（真题判断题：×错）

大纲要求：异常处理（捕获、声明抛出、自定义异常）和断言概念。综合应用题通常就是"输入两个整数做除法 + 异常处理 + GUI 显示结果"。

异常体系

• 常见运行时异常：ArithmeticException（除零）、NullPointerException（空指针）、ArrayIndexOutOfBoundsException（下标越界）、NumberFormatException（数字格式）
• 受检异常：IOException 等，必须捕获或在方法签名 throws 声明
• 自定义异常：继承 Exception（官方样题：父类可以是 Exception）

try-catch-finally 与抛出

JAVAtry {
    int r = 10 / 0;                // 抛出 ArithmeticException
} catch (ArithmeticException e) {      // 子类异常在前
    System.out.println("除零错误");
} catch (Exception e) {               // 父类异常在后
    System.out.println("其他错误");
} finally {                            // 无论是否异常都执行
    System.out.println("收尾");
}

// 声明抛出：方法可能抛出异常但不处理，用 throws 交给调用者
public double quotient(int a, int b) throws Exception {
    if (b == 0) throw new Exception();   // throw 手动抛出异常对象
    return a / b;
}

断言 assert

JAVAassert a > 0 : "a 必须为正数";   // 条件为 false 时抛出 AssertionError
// 运行需加参数启用：java -ea Test（默认不启用）

大纲要求：输入输出流类（FileInputStream / FileOutputStream / BufferedReader / BufferedWriter / File 类）、标准输入输出和基本用户界面 I/O。

流的体系

File 类与随机访问

JAVAFile dir = new File("d:/test");
dir.isDirectory()            // true
String[] names = dir.list();   // 返回目录下的文件名数组（官方样题：得到文件名用 File）

// RandomAccessFile：支持在文件中随机位置读写
RandomAccessFile raf = new RandomAccessFile("d:/a.dat", "rw");
raf.seek(1024);               // 定位到任意字节位置再读写

大纲要求：线程的概念、线程的基本控制（Thread / Runnable）、同步机制（synchronized / wait / notify）。

创建线程的两种方式

JAVA// 方式一：继承 Thread 类，重写 run()
class T1 extends Thread {
    public void run() { System.out.println("T1"); }
}

// 方式二：实现 Runnable 接口（推荐，避免单继承限制）
class T2 implements Runnable {
    public void run() { System.out.println("T2"); }
}

// 启动线程必须调用 start()，而不是直接调 run()
new T1().start();
new Thread(new T2()).start();

线程生命周期与常用方法

同步 synchronized

JAVAclass Stack {
    synchronized void push(int v) { ... }   // 加锁：同一时刻只有一个线程进入
}
// 多线程访问共享数据时，顺序不确定可能导致结果不确定（官方样题）
// 线程优先级范围：1 ~ 10（Thread.MIN_PRIORITY=1, MAX_PRIORITY=10）

大纲（近年）要求了解集合框架的基本使用：List / Set / Map 的特点与常用操作、泛型的作用。

三大接口与实现类

JAVAArrayList<String> list = new ArrayList<>();  // 泛型：编译期类型安全
list.add("A");  list.add("B");
Collections.min(list);   Collections.max(list);   // 集合最值（真题）
Collections.sort(list);                          // 排序

HashMap<String, Integer> m = new HashMap<>();
m.put("张三", 90);   m.get("张三");          // 90

大纲要求：Applet 的概念与生命周期、常用组件与布局管理器、事件处理、paint 绘图。综合应用题通常就是"GUI + 事件 + 业务逻辑"。

AWT 与 Swing

判断题考点：Panel 属于 AWT 组件，不是 Swing 组件（官方样题）。

布局管理器

事件处理三要素 + 一个回调

JAVA// 三要素：事件源（按钮）、事件对象（ActionEvent）、监听器（ActionListener）
JButton btn = new JButton("确定");
btn.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("点击");
    }
});   // 匿名内部类常用于事件处理（真题考点）

// 窗口事件：用适配器 WindowAdapter（只需覆盖需要的回调）
f.addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent e) { System.exit(0); }
});

Applet 生命周期（4 个方法）

• Applet 生命周期方法共 4 个：init / start / stop / destroy（官方样题）
• 浏览器可用 <param name="..." value="..."> 向 Applet 传参，Applet 用 getParameter("...") 接收

选择题前 10 道是公共基础知识（数据结构、程序设计基础、软件工程、数据库），题目相对固定，背熟考点就能拿分，是过关的"保底分"。

数据结构

• 二叉树性质：叶子结点数 N0 = N2 + 1（度为 2 的结点数 + 1）；第 k 层最多 2^k−1 个结点；深度为 h 的二叉树最多 2^h−1 个结点
• 满二叉树 / 完全二叉树：可用数组顺序存储

算法与程序设计

• 算法复杂度：时间复杂度（执行时间随规模增长）与空间复杂度（存储空间）
• 结构化程序设计三原则：自顶向下、逐步求精、模块化
• 面向对象方法：对象、类、实例、消息、继承、多态

软件工程

• 软件生命周期：计划 → 需求分析 → 设计 → 编码 → 测试 → 运行维护
• 数据流图（DFD）用于需求分析阶段（真题）
• 模块划分准则：高内聚、低耦合（真题）
• 测试：白盒（逻辑路径）与黑盒（功能/等价类、边界值）

数据库

• 数据库系统核心：数据库管理系统 DBMS（真题）
• E-R 图：实体用矩形、属性用椭圆、联系用菱形（真题）
• 关系模型：二维表；主键唯一标识一条记录

时间有限时按下面的优先级投入：先保选择 20 题过关线，再攻操作题填空题。

操作题填空套路

• 基本操作（18 分）：框架补全——类声明、main 方法、创建对象、调用方法、GUI 组件实例化
• 简单应用（24 分）：补业务方法——循环/分支、String 处理、数组操作、数值计算
• 综合应用（18 分）：异常处理 + GUI + 计算组合，多 try-catch 与事件回调填空
• 先读 //Found 上方完整代码语义，再写填空；注意大小写、分号、括号配对

题库分六个年份标签。2021–2024 为公开网络题库的历年真题（考生回忆/整理版）；2025 为中国教育考试网发布的官方样题（依据 2025 年版大纲，4 月发布）；2026 为按 2025 大纲编写的模拟题。 点击选项立即判分，自动显示参考答案与解析。

JAVApublic static int factorial(int n) {
    int f = 1;
    for (int i = 1; i <= n; i++)
        f *= i;                  // 填空处：f = f * i
    return f;
}
public static void main(String[] args) {
    System.out.println(factorial(6));   // 输出 720
}

JAVABufferedReader br = new BufferedReader(
    new InputStreamReader(System.in));
int a = Integer.parseInt(br.readLine());   // 填空：读取第一行并转整数
int b = Integer.parseInt(br.readLine());
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);                    // 整除；注意除零需异常处理

JAVAtry {
    int a = Integer.parseInt(args[0]);      // 填空 1：字符串转整数
    int b = Integer.parseInt(args[1]);
    System.out.println("a / b = " + a / b);
} catch (ArithmeticException e) {            // 填空 2：捕获除零异常
    System.out.println("除数不能为 0");
} catch (NumberFormatException e) {          // 填空 3：捕获格式异常
    System.out.println("输入格式错误");
}