Java考试复习资料整理-MuQYY的博客

📋 一、考试基本信息

考试范围：教材前十章（不考网络编程和数据库）
题型分布：

简答题：6题 × 5分 = 30分
程序分析及填空：4题 × 10分 = 40分
综合编程题：2题 × 15分 = 30分

☕ 二、面向对象编程 (OOP) - 核心重点

1. 三大基本特征

封装 (Encapsulation)

概念：将数据和操作数据的方法捆绑在一起，隐藏内部实现细节
实现：通过private修饰符隐藏属性，提供public的getter/setter方法
代码示例：

public class Student {
    private String name;  // 私有属性，外部不可直接访问
    private int age;

    public String getName() { return name; }  // getter
    public void setName(String name) { this.name = name; }  // setter
}

继承 (Inheritance)

概念：子类继承父类的属性和方法，实现代码复用
关键字：extends（类继承类）、implements（类实现接口）
注意：Java只支持单继承，但可以多实现接口

多态 (Polymorphism)

概念：同一操作作用于不同对象，产生不同结果
实现条件：继承、方法重写、父类引用指向子类对象
典型代码分析题：

class Animal { void speak() { System.out.println("动物叫"); } }
class Dog extends Animal { void speak() { System.out.println("汪汪"); } }
class Cat extends Animal { void speak() { System.out.println("喵喵"); } }

Animal a = new Dog();  // 向上转型
a.speak();  // 输出"汪汪" - 运行时动态绑定

2. 重载 vs 重写（⭐ 高频简答题）

对比维度	重载 (Overloading)	重写 (Overriding)
发生位置	同一个类中	子类与父类之间
参数列表	必须不同	必须相同
返回类型	可以不同	必须相同或是子类
访问修饰符	不限	不能更严格
绑定机制	静态绑定（编译时）	动态绑定（运行时）
关键字	无	`@Override`（建议标注）

记忆口诀： "重载同类不同参，重写父子同签名"

3. 抽象类 vs 接口（⭐ 高频简答题）

对比维度	抽象类 (Abstract Class)	接口 (Interface)
定义	`abstract class`	`interface`
方法类型	可有抽象方法和具体方法	JDK8前只能有抽象方法；JDK8+可有default/static方法
继承/实现	单继承	多实现
变量	普通成员变量	只能是`public static final`常量
构造方法	有（不能实例化）	无
设计理念	"is-a"关系，代码复用	"has-a"关系，定义规范

编程题示例：

// 定义接口
interface Shape {
    double getArea();
    double getPerimeter();
}

// 实现接口
class Rectangle implements Shape {
    private double width, height;

    public Rectangle(double w, double h) {
        width = w; height = h;
    }

    @Override
    public double getArea() { return width * height; }

    @Override
    public double getPerimeter() { return 2 * (width + height); }

    @Override
    public String toString() {
        return "Rectangle[area=" + getArea() + ", perimeter=" + getPerimeter() + "]";
    }
}

4. 关键字专项

final 关键字

修饰类：类不能被继承（如String、Integer）
修饰方法：方法不能被重写
修饰变量：变量变为常量，值只能赋值一次
典型代码：

final class FinalClass { }  // 不能被继承
class Parent {
    final void finalMethod() { }  // 子类不能重写
    void normalMethod(final int x) {  // 参数x在方法内不可修改
        // x = 10; // 编译错误！
    }
}

static 关键字

修饰成员变量：类变量，所有对象共享
修饰方法：类方法，可通过类名直接调用
修饰代码块：静态代码块，类加载时执行一次
典型应用：

class Student {
    static int count = 0;  // 统计学生人数
    public Student() { count++; }
    public static void showCount() { System.out.println("总人数：" + count); }
}

5. 绑定机制

静态绑定（编译时绑定）

针对private、static、final方法和成员变量
在编译时确定调用哪个方法

动态绑定（运行时绑定）

针对实例方法（非static、非final）
在运行时根据对象实际类型确定调用哪个方法
是实现多态的基础

🧵 三、多线程 - 必考编程题

1. 三种实现方式（⭐ 简答题必考）

方式一：继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行中：" + Thread.currentThread().getName());
    }
}
// 启动方式
new MyThread().start();

方式二：实现Runnable接口（推荐）

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行中：" + Thread.currentThread().getName());
    }
}
// 启动方式
new Thread(new MyRunnable()).start();

方式三：实现Callable接口（有返回值）

class MyCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        return 100;
    }
}
// 启动方式
FutureTask task = new FutureTask<>(new MyCallable());
new Thread(task).start();
System.out.println("返回值：" + task.get());

重要对比：

继承Thread：代码简单，但Java单继承限制
实现Runnable：更灵活，可继承其他类，适合资源共享
实现Callable：可返回结果，可抛异常

2. 线程同步与互斥（⭐ 编程题重点）

synchronized关键字

修饰方法：整个方法同步
修饰代码块：更精细的锁控制
银行账户示例（必背）：

class BankAccount {
    private double balance;

    // 同步方法：保证线程安全
    public synchronized void deposit(double amount) {
        balance += amount;
        System.out.println(Thread.currentThread().getName() + "存入" + amount + "，余额：" + balance);
    }

    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println(Thread.currentThread().getName() + "取出" + amount + "，余额：" + balance);
        } else {
            System.out.println("余额不足");
        }
    }
}

// 测试类
public class BankTest {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();

        // 两人同时取款
        new Thread(() -> account.withdraw(500), "张三").start();
        new Thread(() -> account.withdraw(500), "李四").start();

        // 一人存钱一人取钱
        new Thread(() -> account.deposit(1000), "王五").start();
        new Thread(() -> account.withdraw(300), "赵六").start();
    }
}

互斥概念：多个线程访问共享资源时，通过锁机制保证同一时刻只有一个线程访问，避免数据不一致。

3. 数据输入统计题（常见编程题）

import java.util.*;

public class DataProcessor implements Runnable {
    private List numbers = new ArrayList<>();

    @Override
    public void run() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字（输入'exit'结束）：");

        while (true) {
            String input = scanner.nextLine();
            if ("exit".equalsIgnoreCase(input)) break;
            try {
                numbers.add(Double.parseDouble(input));
            } catch (NumberFormatException e) {
                System.out.println("非法数字，请重新输入！");
            }
        }

        // 计算统计结果
        if (!numbers.isEmpty()) {
            double min = Collections.min(numbers);
            double max = Collections.max(numbers);
            double avg = numbers.stream().mapToDouble(d -> d).average().getAsDouble();

            System.out.println("最小值：" + min);
            System.out.println("最大值：" + max);
            System.out.println("平均值：" + avg);
        }
    }
}

🖥️ 四、GUI编程 - 必考综合题

1. 核心组件与布局

常用组件：

JFrame：主窗口
JPanel：面板容器
JLabel：标签
JTextField：单行文本框
JButton：按钮

布局管理器：

FlowLayout：流式布局，从左到右排列（最常考）
BorderLayout：边界布局
GridLayout：网格布局

2. 事件监听机制（⭐ 核心）

ActionListener接口

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 按钮点击后的逻辑
    }
});

// Lambda表达式简化（重要）
button.addActionListener(e -> {
    // 处理逻辑
});

完整GCD/LCM计算器示例（必背模板）

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class GCDLCMFrame extends JFrame {
    private JTextField num1Field, num2Field, resultField;
    private JButton calcButton, exitButton;

    public GCDLCMFrame() {
        setTitle("GCD/LCM计算器");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());  // 流式布局

        // 创建组件
        add(new JLabel("数1："));
        num1Field = new JTextField(10);
        add(num1Field);

        add(new JLabel("数2："));
        num2Field = new JTextField(10);
        add(num2Field);

        add(new JLabel("结果："));
        resultField = new JTextField(15);
        resultField.setEditable(false);  // 只读
        add(resultField);

        calcButton = new JButton("计算");
        exitButton = new JButton("退出");
        add(calcButton);
        add(exitButton);

        // "计算"按钮事件
        calcButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    int a = Integer.parseInt(num1Field.getText());
                    int b = Integer.parseInt(num2Field.getText());

                    int gcd = calculateGCD(a, b);
                    int lcm = a * b / gcd;

                    resultField.setText("GCD=" + gcd + ", LCM=" + lcm);
                } catch (NumberFormatException ex) {
                    JOptionPane.showMessageDialog(null, "请输入有效数字！");
                }
            }
        });

        // "退出"按钮事件
        exitButton.addActionListener(e -> System.exit(0));
    }

    // 辗转相除法求最大公约数
    private int calculateGCD(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            new GCDLCMFrame().setVisible(true);
        });
    }
}

重要注意事项：

必须在事件处理方法中捕获NumberFormatException
System.exit(0)用于退出程序
JOptionPane.showMessageDialog()用于弹出提示框

🗃️ 五、集合框架

1. ArrayList + Collections.sort（⭐ 编程题重点）

import java.util.*;

public class CollectionDemo {
    public static void main(String[] args) {
        // 1. 创建ArrayList
        List numbers = new ArrayList<>();

        // 2. 添加元素（从控制台输入5个数字）
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入5个数字：");
        for (int i = 0; i < 5; i++) {
            numbers.add(scanner.nextInt());
        }

        // 3. 排序
        Collections.sort(numbers);

        // 4. 遍历输出
        System.out.println("排序后：");
        numbers.forEach(System.out::println);  // 使用Lambda表达式
    }
}

2. 学生管理系统示例

class Student implements Comparable {
    private String id, name;
    private double score;

    public Student(String id, String name, double score) {
        this.id = id; this.name = name; this.score = score;
    }

    // 按成绩排序
    @Override
    public int compareTo(Student other) {
        return Double.compare(this.score, other.score);
    }

    @Override
    public String toString() {
        return "Student{id='" + id + "', name='" + name + "', score=" + score + "}";
    }

    // Getters
    public String getId() { return id; }
    public String getName() { return name; }
}

// 使用示例
public class StudentManager {
    private List students = new ArrayList<>();

    public void addStudent(Student s) { students.add(s); }
    public void removeStudent(String id) { students.removeIf(s -> s.getId().equals(id)); }
    public Student findStudent(String name) { 
        return students.stream().filter(s -> s.getName().equals(name)).findFirst().orElse(null);
    }
    public void sortStudents() { Collections.sort(students); }
}

⚠️ 六、异常处理

try-catch-finally执行流程

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            System.out.println("statement1");
            int result = 10 / 0;  // 抛出ArithmeticException
            System.out.println("statement2");  // 不会执行
        } catch (ArithmeticException e) {
            System.out.println("statement3");  // 捕获异常后执行
        } finally {
            System.out.println("statement4");  // 总会执行
        }
        System.out.println("statement5");  // catch块后继续执行
    }
}

输出结果：

statement1
statement3
statement4
statement5

重要结论：

try块中异常发生后，后续代码不再执行
catch块执行完后，程序继续向下执行
finally块始终会执行（除非JVM退出）

📄 七、I/O流 - 程序填空重点

文本文件复制（必背模板）

import java.io.*;

public class FileCopy {
    public static void copyFile(String source, String dest) throws IOException {
        BufferedReader reader = null;
        BufferedWriter writer = null;

        try {
            // 填空常考：FileReader, InputStreamReader, BufferedReader
            reader = new BufferedReader(new FileReader(source));
            writer = new BufferedWriter(new FileWriter(dest));

            String line;
            // 填空常考：readLine()
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();  // 写入换行符
            }
        } finally {
            // 关闭流（填空常考：close()）
            if (reader != null) reader.close();
            if (writer != null) writer.close();
        }
    }
}

填空高频考点：

IOException - 异常类型
FileReader / FileInputStream - 文件输入流
InputStreamReader - 字节流转字符流
BufferedReader - 缓冲流，提高效率
readLine() - 读取一行
close() - 关闭流

🔢 八、数组与基础语法

1. 杨辉三角（编程题重点）

public class YangHuiTriangle {
    public static void printTriangle(int n) {
        int[][] triangle = new int[n][];

        for (int i = 0; i < n; i++) {
            triangle[i] = new int[i + 1];
            triangle[i][0] = triangle[i][i] = 1;  // 首尾为1

            for (int j = 1; j < i; j++) {
                triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j];
            }
        }

        // 打印
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(triangle[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

2. 基础算法

辗转相除法求GCD：

public static int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

冒泡排序：

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

📚 九、编程题专项突破

高频题型总结

题型	核心考点	分值	难度
GCD/LCM计算器	GUI+事件监听+异常处理	15分	⭐⭐
银行账户模拟	多线程+synchronized	15分	⭐⭐⭐
学生管理系统	集合+排序+封装	15分	⭐⭐
数字统计	多线程+输入处理	15分	⭐⭐
文件复制	I/O流+异常处理	10分	⭐

编程题万能模板

1. GUI类模板

public class MyFrame extends JFrame {
    public MyFrame() {
        setTitle("标题");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());

        // 添加组件...

        setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new MyFrame());
    }
}

2. 多线程模板

class MyTask implements Runnable {
    private final Object lock;  // 锁对象
    public MyTask(Object lock) { this.lock = lock; }

    @Override
    public void run() {
        synchronized(lock) {
            // 临界区代码
        }
    }
}

🎯 十、复习策略与建议

1. 简答题必背清单（按重要性排序）

OOP三大特征（封装、继承、多态）- 每年必考
重载vs重写 - 高频考点，必须画表对比
抽象类vs接口 - 高频考点，至少5个区别点
多线程三种实现方式 - 必须会写代码示例
final关键字三种用法 - 修饰类、方法、变量的区别
静态绑定vs动态绑定 - 概念清晰，举例说明

2. 代码题冲刺计划

第一阶段（2天）：背熟模板

背熟GCD/LCM计算器完整代码
背熟银行账户多线程代码
背熟ArrayList+Collections.sort模式

第二阶段（2天）：理解核心

理解事件监听机制执行流程
理解synchronized锁的原理
理解try-catch-finally执行顺序

第三阶段（1天）：查漏补缺

默写所有常见I/O类名
默写杨辉三角代码
练习异常处理代码纠错

3. 考场技巧

GUI题：先搭框架，再填事件，最后调试异常
多线程题：一定记得synchronized，锁对象要共享
填空题：看到文件操作就想到IOException和close()
分析题：注意多态时方法调用的实际对象类型

4. 最后提醒

考试时间：合理分配，编程题每题控制在25分钟内
代码规范：注意缩进和命名，会影响印象分
边界测试：自己写完后用异常数据测试一下
应急方案：如果GUI事件监听写不出来，先写简单功能，保证能编译运行

1
本网站名称：MuQYY
2
本站永久网址：www.muqyy.top
3
本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长微信：bwj-1215 进行删除处理。
4
本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5
本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6
本站资源大多存储在云盘，如发现链接失效，请联系我们我们会在第一时间更新。

THE END

java

Java考试复习资料整理