本文还有配套的精品资源，点击获取

简介：本文详细介绍了如何利用Java语言和Swing图形用户界面库开发一款具有基本计算功能和保存计算历史功能的计算器。通过这个项目，开发者可以加深对Java面向对象编程和Swing组件使用技巧的理解，同时学习到事件处理、计算逻辑、设计模式应用、错误处理、文件I/O、UI样式设计以及测试与调试等多方面的知识。

1. Java面向对象编程

面向对象编程（OOP）是Java语言的核心理念，它通过对象的概念来组织软件。Java是一种纯粹的面向对象语言，它的每一个代码片段都与对象有关。在这一章中，我们将探索OOP的三个基本特征：封装、继承和多态性，以及它们在Java中的实现方式。

1.1 封装的实现与优势

封装是隐藏对象的内部状态和行为的过程，只通过公共接口暴露必要的操作。它允许我们在不影响其他部分的情况下更改对象内部的实现细节。在Java中，通过创建类和使用访问修饰符来实现封装。

public class Counter {
    private int count = 0; // 私有变量，封装了数据

    public int getCount() {
        return count; // 提供公共方法访问私有变量
    }

    public void increment() {
        count++; // 提供公共方法修改私有变量
    }
}

封装的优势在于它提供了一个抽象层，降低了软件的复杂性，增强了代码的可维护性。

1.2 继承与代码复用

继承是面向对象编程中的一个关键概念，它允许一个类继承另一个类的属性和方法。Java通过关键字 extends 来实现继承。继承带来了代码复用的好处，可以减少重复代码，增强程序的可扩展性和可维护性。

public class Vehicle {
    private String brand;

    // 方法和其他属性...
}

public class Car extends Vehicle {
    // Car类继承了Vehicle的属性和方法
}

在上述代码中， Car 类继承了 Vehicle 类，这意味着 Car 对象可以访问 Vehicle 类定义的所有方法和属性。

1.3 多态性的实现与作用

多态性允许我们使用父类的引用指向子类的对象，增强了程序的灵活性。在Java中，多态性通常是通过方法重写和抽象类或者接口来实现的。

public abstract class Animal {
    abstract void makeSound();
}

public class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark!");
    }
}

public class Cat extends Animal {
    void makeSound() {
        System.out.println("Meow!");
    }
}

通过多态性，我们可以编写更通用的代码，例如：

Animal animal1 = new Dog();
animal1.makeSound(); // 输出 "Bark!"

Animal animal2 = new Cat();
animal2.makeSound(); // 输出 "Meow!"

多态性使得程序能够通过统一的接口来处理不同类型的对象，降低了代码间的耦合度，使得程序更加灵活。

在下一章节中，我们将深入了解Swing组件的使用，这些组件对于创建图形用户界面（GUI）至关重要。我们还将探索如何利用Java的事件处理机制与这些组件进行交互。

2. Swing组件使用技巧

Swing是Java的一个用户界面工具包，它提供了大量用于创建图形用户界面的组件。本章将深入探讨Swing组件的使用技巧，旨在帮助开发者更加高效地利用Swing构建出美观、功能齐全的应用程序界面。

2.1 Swing组件基础

2.1.1 Swing组件架构概述

Swing组件的架构基于MVC模式（Model-View-Controller），它将组件的功能分为三个部分：模型（Model）、视图（View）和控制器（Controller）。这种设计允许Swing组件进行灵活的扩展和自定义。

模型（Model） ：模型是组件的数据部分，负责数据的存储和获取。例如，在一个文本框组件中，模型会包含文本内容。

视图（View） ：视图是用户看到的部分，即组件的外观。它通常会将模型中的数据以视觉形式展现给用户。

控制器（Controller） ：控制器是用户与组件交互的部分，负责响应用户的操作，并更新模型中的数据。

2.1.2 核心组件功能与特性

Swing提供了一系列核心组件，这些组件都遵循MVC架构，下面我们将简要介绍几种常用的Swing组件及其特性。

• JButton : 按钮组件，用于触发用户操作。
• JTextField : 文本输入框，允许用户输入和编辑单行文本。
• JLabel : 标签组件，用于展示文本或图像信息，不接受用户输入。
• JComboBox : 下拉列表组件，提供一个下拉菜单供用户选择。
• JCheckBox : 复选框组件，表示一个可以选中或取消选中的选项。
• JRadioButton : 单选按钮，用于在多个选项中选择一个。

这些组件是构建复杂用户界面的基石。开发者可以通过组合和嵌套使用这些基本组件，来创建满足各种需求的复杂界面。

2.2 复杂界面布局管理

2.2.1 使用BorderLayout管理界面布局

BorderLayout是Swing中的一种布局管理器，它可以将界面分为五个区域：东、南、西、北和中心。这种布局方式非常灵活，特别适合管理包含少数几个组件的简单界面。

import javax.swing.*;

public class BorderLayoutExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("BorderLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 400);

        frame.setLayout(new BorderLayout());

        frame.add(new JButton("East"), BorderLayout.EAST);
        frame.add(new JButton("South"), BorderLayout.SOUTH);
        frame.add(new JButton("West"), BorderLayout.WEST);
        frame.add(new JButton("North"), BorderLayout.NORTH);
        frame.add(new JButton("Center"), BorderLayout.CENTER);

        frame.setVisible(true);
    }
}

在上面的例子中，我们创建了一个JFrame窗口，并设置了其布局管理器为BorderLayout。随后，我们在五个区域中各添加了一个按钮。

2.2.2 网格布局GridBagLayout的应用

GridBagLayout是一种更复杂的布局管理器，它可以按照网格的形式排列组件，并允许组件占据多个网格单元。这种布局提供了更大的灵活性，适合于需要精细控制组件位置和大小的复杂界面。

GridBagLayout的使用需要借助于GridBagConstraints类，通过设置各种约束参数（如gridx, gridy, gridwidth, gridheight, fill, anchor等）来控制组件的位置和大小。

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

public class GridBagLayoutExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("GridBagLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 400);

        frame.setLayout(new GridBagLayout());
        GridBagConstraints gbc = new GridBagConstraints();

        gbc.gridwidth = 1;
        gbc.gridheight = 1;
        frame.add(new JButton("Button 1"), gbc);

        gbc.gridx = 1;
        gbc.gridy = 1;
        frame.add(new JButton("Button 2"), gbc);

        gbc.gridwidth = 2;
        gbc.gridheight = 2;
        frame.add(new JButton("Button 3"), gbc);

        frame.setVisible(true);
    }
}

在这段代码中，我们展示了如何使用GridBagLayout来布局三个按钮。每个按钮通过设置不同的gridx, gridy, gridwidth, gridheight参数，被放置在网格的不同位置，并占据不同大小的空间。

2.3 高级Swing组件应用

2.3.1 JTable与数据模型绑定

JTable是Swing中用于展示和编辑二维表格数据的组件。它通常与表格模型（TableModel）一起使用，其中数据模型负责提供数据，JTable负责显示这些数据。

import javax.swing.*;
import javax.swing.table.DefaultTableModel;

public class JTableExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("JTable Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 200);

        String[] columnNames = {"Column 1", "Column 2", "Column 3"};
        Object[][] data = {
            {"Row 1, Col 1", "Row 1, Col 2", "Row 1, Col 3"},
            {"Row 2, Col 1", "Row 2, Col 2", "Row 2, Col 3"},
            {"Row 3, Col 1", "Row 3, Col 2", "Row 3, Col 3"}
        };

        DefaultTableModel tableModel = new DefaultTableModel(data, columnNames);
        JTable table = new JTable(tableModel);

        frame.add(new JScrollPane(table));
        frame.setVisible(true);
    }
}

在上述代码中，我们创建了一个包含三列三行的简单表格。这个例子展示了如何创建一个DefaultTableModel，将数据填充到模型中，并将模型绑定到JTable上显示。

2.3.2 JTree的节点管理与自定义渲染

JTree是Swing中用于显示树状结构数据的组件。通过使用自定义的TreeNode实现，JTree可以展示任意复杂的数据结构。此外，通过自定义渲染器（CellRenderer），开发者可以控制树节点的显示方式，包括颜色、字体、图标等。

import javax.swing.*;
import javax.swing.tree.*;

public class JTreeExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("JTree Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 200);

        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
        DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("Child1");
        DefaultMutableTreeNode child2 = new DefaultMutableTreeNode("Child2");
        root.add(child1);
        root.add(child2);

        JTree tree = new JTree(root);
        tree.setCellRenderer(new DefaultTreeCellRenderer() {
            public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel,
                boolean expanded, boolean leaf, int row, boolean hasFocus) {
                Component c = super.getTreeCellRendererComponent(
                    tree, value, sel, expanded, leaf, row, hasFocus);
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
                if (node.getParent() == root) {
                    c.setFont(new Font("Serif", Font.BOLD, 18));
                }
                return c;
            }
        });

        frame.add(new JScrollPane(tree));
        frame.setVisible(true);
    }
}

在上面的代码中，我们创建了一个简单的树形结构，并通过自定义的渲染器来改变根节点的字体样式。这种方式可以用于更复杂的UI自定义场景，使得JTree的显示更加符合应用程序的风格和需求。

3. 事件监听器应用

事件监听器的应用是构建交互式用户界面不可或缺的一部分。本章节将深入探讨事件监听器的工作原理，并将重点放在实现常见事件类型的响应和处理上。

3.1 事件处理模型

3.1.1 事件监听机制的工作原理

Java事件处理模型建立在观察者模式的基础上，其核心概念是事件源（Event Source）、事件（Event）、事件监听器（Listener）和事件适配器（Adapter）。事件源是触发事件的对象，事件代表了正在发生的事情，事件监听器负责监听并响应事件，而事件适配器则提供了一个空白的事件处理模板供实现者扩展。

事件对象通常继承自java.util.EventObject类，并包含触发事件的相关信息。而事件监听器是一个接口，它定义了针对特定类型事件的处理方法。例如，MouseListener接口定义了处理鼠标事件的方法。

3.1.2 实现事件监听器接口的步骤与方法

实现事件监听器接口通常包含以下步骤：

1. 为事件源添加事件监听器。
2. 实现对应的事件监听接口。
3. 在事件处理方法中编写响应逻辑。

例如，实现一个鼠标事件监听器需要实现MouseListener接口，并提供mouseClicked, mousePressed等方法的实现，然后将此监听器添加到相应的Swing组件上。

// 一个简单的鼠标事件监听器实现示例
class MyMouseListener implements MouseListener {
    public void mouseClicked(MouseEvent e) {
        // 鼠标点击处理
    }
    public void mousePressed(MouseEvent e) { /* ... */ }
    public void mouseReleased(MouseEvent e) { /* ... */ }
    public void mouseEntered(MouseEvent e) { /* ... */ }
    public void mouseExited(MouseEvent e) { /* ... */ }
}

// 添加监听器
component.addMouseListener(new MyMouseListener());

3.2 常见事件类型与响应

3.2.1 鼠标事件与键盘事件处理

鼠标事件和键盘事件是最常见的用户输入方式。鼠标事件包括鼠标点击、按下、释放等，键盘事件则涉及按键的按下和释放。

// 鼠标事件处理示例
component.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
        // 鼠标点击的处理
    }
});

// 键盘事件处理示例
component.addKeyListener(new KeyAdapter() {
    @Override
    public void keyPressed(KeyEvent e) {
        // 按键按下的处理
    }
});

3.2.2 菜单事件与按钮事件处理

菜单事件和按钮事件通常用于响应用户的命令操作。例如，使用ActionListener接口可以监听按钮点击事件，并执行相应的命令。

// 按钮事件处理示例
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // 按钮点击后的处理
    }
});

菜单项也可以添加事件监听器，以便在用户选择特定菜单项时触发事件。

// 菜单事件处理示例
menu.getItem("Menu Item").addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // 菜单项选择后的处理
    }
});

事件监听器的应用不仅仅局限于上述简单案例。在实际开发中，可能需要结合事件适配器来简化事件处理代码，并根据需要创建自定义的事件类和监听器接口。理解和应用这些基本概念和模式对于创建交互式和响应式的用户界面至关重要。

4. 计算器的计算逻辑实现

4.1 设计计算逻辑框架

为了构建一个功能齐全的计算器，首先必须设计出合理、高效的计算逻辑框架。计算器程序的核心功能是根据用户输入的数字和运算符，进行计算并输出结果。因此，设计计算逻辑框架是实现计算器功能的基础。

4.1.1 数字处理与运算符解析

在计算器应用中，对用户输入的处理是至关重要的。数字处理机制确保了用户输入的每个数字能够被正确地识别并存储。对于运算符的解析，程序需要能够区分并识别用户输入的各种运算符（如加号 + 、减号 - 、乘号 * 、除号 / 等），以及可能涉及的更复杂的运算符和函数（如指数运算符 ^ 或三角函数等）。

在实现时，一个简单的办法是使用字符串来表示表达式，例如用户输入的"3+5"，然后通过字符串处理技术提取数字和运算符。下面是一个简单的代码示例，展示如何从用户输入的字符串中提取数字和运算符：

String input = "3 + 5 * 2";
int[] numbers = new int[10]; // 假设表达式中的数字不超过10个
String[] operators = new String[9]; // 运算符数量比数字少一个
int numberIndex = 0;
int operatorIndex = 0;
int i = 0;
int length = input.length();

while (i < length) {
    char c = input.charAt(i);
    if (Character.isDigit(c)) {
        int number = 0;
        while (i < length && Character.isDigit(input.charAt(i))) {
            number = number * 10 + (input.charAt(i) - '0');
            i++;
        }
        numbers[numberIndex++] = number;
        if (i < length && input.charAt(i) == '.') {
            double decimal = number + 0.1;
            while (i < length && Character.isDigit(input.charAt(i))) {
                decimal *= 0.1;
                decimal += input.charAt(i) - '0';
                i++;
            }
            numbers[numberIndex - 1] = (int) decimal; // 取整数部分
        }
    } else if (c == '+' || c == '-' || c == '*' || c == '/') {
        operators[operatorIndex++] = String.valueOf(c);
        while (i < length && Character.isWhitespace(input.charAt(i))) {
            i++; // 跳过空格
        }
    } else {
        i++;
    }
}

4.1.2 计算流程的设计思路

一旦数字和运算符被正确提取，下一步就是设计计算流程。这个流程应该考虑到运算符的优先级，因为不同的运算符有不同的执行顺序。例如，乘法和除法通常比加法和减法有更高的优先级。

为了简化计算流程，可以使用栈（Stack）这种数据结构来处理运算符的优先级。一个常见的计算方法是使用两个栈：一个用于存储数字，另一个用于存储运算符。对于输入的每个运算符，遵循如下的规则进行处理：

• 如果栈为空或者遇到左括号 ( ，直接将运算符入栈。
• 如果优先级高于栈顶运算符，也将运算符入栈。
• 如果优先级低于或等于栈顶运算符，则从数字栈中弹出两个数字进行计算，将结果压回数字栈，然后将运算符入栈。

以下是一个简化的计算流程伪代码，展示了如何处理运算符优先级：

Stack<Integer> numbers = new Stack<>();
Stack<Character> operators = new Stack<>();
String input = "3 + 5 * 2"; // 用户输入的字符串
// ... (省略数字和运算符的提取过程)
for (int i = 0; i < operators.size(); i++) {
    Character op = operators.get(i);
    if (op.equals('+') || op.equals('-')) {
        int number1 = numbers.pop();
        int number2 = numbers.pop();
        numbers.push(op.equals('+') ? number2 + number1 : number2 - number1);
    } else if (op.equals('*') || op.equals('/')) {
        double number1 = numbers.pop();
        double number2 = numbers.pop();
        numbers.push(op.equals('*') ? number2 * number1 : number2 / number1);
    }
}
double result = numbers.pop(); // 栈顶的数字即为最终结果

上面的代码片段基于后缀表达式（也称为逆波兰表达式，Reverse Polish Notation）的计算方法，它是一种非常有效的计算表达式的方式，适用于计算器的设计。

4.2 实现基本运算功能

在计算器中实现基本的数学运算（加、减、乘、除）是核心功能之一。这些运算不仅要求结果的准确性，还要求程序具备良好的错误处理机制，以应对如除以零这样的非法操作。

4.2.1 加、减、乘、除运算实现

对于加法、减法、乘法和除法这四种基本运算，计算器程序需要提供准确的计算方法。以下是每种运算的简单Java实现：

public static double add(double a, double b) { return a + b; }
public static double subtract(double a, double b) { return a - b; }
public static double multiply(double a, double b) { return a * b; }
public static double divide(double a, double b) {
    if (b == 0) {
        throw new ArithmeticException("Division by zero is not allowed.");
    }
    return a / b;
}

4.2.2 运算优先级处理

在计算器中处理运算符优先级通常使用前面提到的两个栈的方案。然而，为了使处理过程更加直观，我们可以借助抽象语法树（Abstract Syntax Tree，AST）。AST是一种表示程序语法结构的树形表示方法，通过这种结构可以方便地处理运算符优先级和运算顺序。

构建AST的步骤可以分为：

• 读取并分析表达式。
• 根据运算符优先级，递归地构建子表达式的AST。
• 当读取到操作数时，创建一个叶节点。
• 当读取到运算符时，根据优先级决定是创建一个新的节点还是合并到现有节点。

计算表达式的AST可以按照如下方法：

public static double evaluateAST(Node ast) {
    if (ast.isLeaf()) {
        return Double.parseDouble(ast.getValue());
    }
    double left = evaluateAST(ast.getLeft());
    double right = evaluateAST(ast.getRight());
    switch (ast.getValue()) {
        case "+": return left + right;
        case "-": return left - right;
        case "*": return left * right;
        case "/": return left / right;
        default: throw new UnsupportedOperationException("Unsupported operation");
    }
}

在实现计算逻辑时，计算器应能够处理包含括号的表达式。例如，用户可能输入“(1 + 2) * 3”。为了实现这一点，需要在构建AST时正确地处理括号，当遇到左括号 ( 时，将当前运算符的优先级设为最低，直到遇到右括号 ) ，才开始处理括号内的表达式。

通过上述方法，计算器可以准确地计算出用户的输入结果，无论表达式多么复杂。这一计算逻辑的实现是现代计算器应用的基础。

5. 计算过程保存机制

5.1 实现计算历史记录

在现代计算机软件中，记录用户的操作历史是一种常见的功能，不仅方便用户回顾之前的计算过程，还能够在出现误操作时帮助用户恢复到之前的某个状态。为了实现这个功能，我们需要设计一种计算历史的存储方式，能够方便地进行增、删、查、改等操作。

5.1.1 计算历史的存储方法

存储计算历史可以采用多种数据结构，比如栈、队列或链表等。栈（Stack）是一种后进先出（LIFO）的数据结构，特别适合用来实现撤销（Undo）功能，因为撤销操作的本质就是取出最近一次的操作。队列（Queue）是一种先进先出（FIFO）的数据结构，适合用来实现重做（Redo）功能。链表（LinkedList）的插入和删除操作比较灵活，适合在历史记录中动态地添加和移除节点。

在这个案例中，我们将采用栈来保存用户的计算历史记录。每次用户进行一个计算操作后，我们都会将当前的操作结果以及操作内容压入历史栈中。当用户需要撤销操作时，我们从历史栈中弹出最近的操作，并将结果存入一个单独的重做栈中。如果用户执行了重做操作，我们就从重做栈中取出内容并重新压入历史栈。

import java.util.Stack;
import java.util.LinkedList;
import java.util.List;

public class CalculatorHistory {
    private Stack<String> historyStack;
    private Stack<String> redoStack;

    public CalculatorHistory() {
        historyStack = new Stack<>();
        redoStack = new Stack<>();
    }

    public void addHistory(String operation) {
        historyStack.push(operation);
        redoStack.clear(); // 撤销操作被清空
    }

    public String undo() {
        if (!historyStack.isEmpty()) {
            String operation = historyStack.pop();
            redoStack.push(operation);
            return operation;
        }
        return null;
    }

    public String redo() {
        if (!redoStack.isEmpty()) {
            String operation = redoStack.pop();
            historyStack.push(operation);
            return operation;
        }
        return null;
    }
}

5.1.2 历史记录的增删查改操作

在计算器应用中，除了基本的增加历史记录（Add）和撤销（Undo）功能外，我们还可能需要实现查找（Search）历史记录以及清空历史记录（Clear）等功能。查找历史记录可以通过遍历栈实现，而清空历史记录则意味着清空历史栈。

• Add ：每次用户执行计算操作后，都会执行此操作。
• Undo ：撤销上一步操作，将最近的操作弹出历史栈，并保存到重做栈中。
• Redo ：重做之前撤销的操作，从重做栈中取出操作并压入历史栈。
• Search ：根据用户输入的关键字，遍历历史栈查找历史记录。
• Clear ：清空历史栈。

以下是这些功能的代码实现：

// ...（前面代码保持不变）

public void clearHistory() {
    historyStack.clear();
    redoStack.clear();
}

public String searchHistory(String keyword) {
    for (int i = historyStack.size() - 1; i >= 0; i--) {
        String operation = historyStack.get(i);
        if (operation.contains(keyword)) {
            return operation;
        }
    }
    return null;
}

使用上述方法，我们可以有效地管理用户的计算历史记录，为计算器应用增加撤销与重做功能，从而提供更好的用户体验。在下一小节中，我们将进一步探讨撤销与重做功能的设计与实现。

6. 策略模式在设计中的应用

策略模式是一种行为设计模式，它允许在运行时选择算法的行为。这个模式定义了算法的集合，并将每个算法封装起来，使得它们可以互换使用。策略模式让算法的变化独立于使用算法的客户端。

6.1 策略模式概述

策略模式通过定义一系列的算法，将算法的使用与其内部实现分离。这样算法可以独立于客户端变化，同时策略模式也为算法的扩展提供了方便。

6.1.1 策略模式的定义与结构

策略模式主要包含以下角色：

• 策略（Strategy） ：定义所有支持的算法的公共接口。策略可以是抽象类也可以是接口。
• 具体策略（Concrete Strategies） ：实现策略接口的具体算法。
• 环境（Context） ：持有一个策略类的引用，最终给客户端调用。

// Strategy接口
public interface Strategy {
    void execute();
}

// ConcreteStrategyA类
public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

// ConcreteStrategyB类
public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
    }
}

// Context类
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

在上面的代码中，我们定义了策略接口，并创建了两个具体策略。Context类则根据传入的策略执行相应的算法。

6.1.2 策略模式的优势与适用场景

策略模式的主要优势在于：

• 算法可以自由切换。
• 避免使用多重条件语句。
• 提高算法的保密性和安全性。

该模式适用于：

• 多个类仅在行为方面有所不同，可以使用策略模式提供可互换的行为。
• 需要使用一个算法的不同变体时。
• 对客户隐藏算法的实现细节，彼此之间独立。

6.2 策略模式在计算器中的应用

在计算器应用中，我们可以使用策略模式来处理不同类型的运算。例如，加法、减法、乘法、除法可以被视为不同的策略。

6.2.1 不同计算策略的实现

我们可以定义一个运算接口和实现此接口的具体运算类。

// 运算接口
public interface Operation {
    double calculate(double a, double b);
}

// 加法运算类
public class Addition implements Operation {
    @Override
    public double calculate(double a, double b) {
        return a + b;
    }
}

// 减法运算类
public class Subtraction implements Operation {
    @Override
    public double calculate(double a, double b) {
        return a - b;
    }
}

// 乘法运算类
public class Multiplication implements Operation {
    @Override
    public double calculate(double a, double b) {
        return a * b;
    }
}

// 除法运算类
public class Division implements Operation {
    @Override
    public double calculate(double a, double b) {
        if(b != 0) {
            return a / b;
        }
        throw new IllegalArgumentException("Cannot divide by zero");
    }
}

6.2.2 策略模式与客户端交互

客户端只需决定使用哪种运算策略即可，而无需关心具体的运算逻辑。

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new Addition());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context.setStrategy(new Subtraction());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context.setStrategy(new Multiplication());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));

        context.setStrategy(new Division());
        System.out.println("10 / 5 = " + context.executeStrategy(10, 5));
    }
}

在以上示例中，我们展示了如何在客户端代码中切换策略以执行不同的运算，而无需修改具体的算法实现。

策略模式通过定义一系列的算法并将它们封装起来，使它们可以相互替换使用，这增加了程序的灵活性和扩展性。在计算器应用中，不同的计算策略可以轻松地被添加或替换，而不会影响到客户端的使用。

7. 异常处理方法与文件I/O操作

异常处理是Java程序中至关重要的一个部分，它允许程序在遇到错误或者不正常的条件时能够继续执行。文件I/O操作则是程序与外部存储设备间交换数据的基本方式。合理利用异常处理机制和文件I/O操作，可以提高程序的健壮性和用户数据的持久性。

7.1 异常处理机制

7.1.1 Java异常类层次结构

在Java中，所有的异常类都继承自Throwable类，该类有两个重要的子类：Error和Exception。Error类用于表示严重的错误，如虚拟机错误、系统崩溃等，这些错误通常不由程序来处理，而是交给系统处理。Exception类用于表示程序中的可恢复性错误，它又分为检查型异常（checked exception）和非检查型异常（unchecked exception）。

检查型异常必须被显式处理，例如IOException，而非检查型异常则不需要显式声明，例如NullPointerException和ArrayIndexOutOfBoundsException。学习异常的层次结构有助于我们更好地理解异常处理机制，并合理选择捕获或抛出异常。

7.1.2 异常捕获与处理策略

异常捕获通常使用try-catch语句来实现。基本的异常捕获策略如下：

try {
    // 可能会抛出异常的代码块
} catch (ExceptionType1 e1) {
    // 异常类型为ExceptionType1的处理代码
} catch (ExceptionType2 e2) {
    // 异常类型为ExceptionType2的处理代码
} finally {
    // 无论是否捕获到异常都会执行的代码块
}

一个常见的异常处理策略是捕获具体的异常类型，处理或记录错误信息，然后将异常向上抛出。这种策略使得错误能够在合适的层级被处理，并且不会在try块内部留下未处理的异常。

try {
    // 尝试执行可能会抛出IOException的操作
    // 例如：FileInputStream fis = new FileInputStream("somefile.txt");
} catch (IOException ex) {
    // 处理异常，并记录错误信息
    ex.printStackTrace();
    // 抛出异常或进行其他操作
} finally {
    // 执行清理工作，例如关闭文件流
}

7.2 文件输入输出操作

7.2.1 使用File类进行文件操作

File类是Java中用于表示文件和目录路径名的抽象表示形式。File类提供了一系列用于创建、删除、重命名文件和目录的方法，以及判断文件或目录属性的方法。

File file = new File("example.txt");
if (file.exists()) {
    System.out.println("文件已存在");
} else {
    try {
        boolean newFile = file.createNewFile();
        if (newFile) {
            System.out.println("文件创建成功");
        } else {
            System.out.println("文件创建失败");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

上述代码演示了如何使用File类创建一个新文件，并在创建成功或失败时打印出相应的信息。

7.2.2 实现计算结果的文件保存与读取

假设我们的计算器应用需要将用户的计算结果保存到一个文本文件中，并能够从文件中读取结果进行显示，这可以通过Java的文件I/O流来实现。

// 将计算结果保存到文件
try (FileWriter fw = new FileWriter("calculation_results.txt")) {
    fw.write("计算结果: " + calculationResult);
    System.out.println("计算结果已保存到文件");
} catch (IOException e) {
    e.printStackTrace();
}

// 从文件读取计算结果
try (BufferedReader br = new BufferedReader(new FileReader("calculation_results.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

上述代码展示了如何使用FileWriter和BufferedReader将字符串写入文件，并使用BufferedReader从文件中读取数据。这种方式常用于持久化存储用户数据，例如日志信息、配置文件等。正确地使用异常处理机制，可以避免程序在执行I/O操作时因文件不存在、没有读写权限等问题突然崩溃，保证程序的稳定性和数据的安全性。

本文还有配套的精品资源，点击获取

简介：本文详细介绍了如何利用Java语言和Swing图形用户界面库开发一款具有基本计算功能和保存计算历史功能的计算器。通过这个项目，开发者可以加深对Java面向对象编程和Swing组件使用技巧的理解，同时学习到事件处理、计算逻辑、设计模式应用、错误处理、文件I/O、UI样式设计以及测试与调试等多方面的知识。

本文还有配套的精品资源，点击获取