Java编程入门教程：从零开始学习Java

概述

Java是一种面向对象的编程语言，由James Gosling于1991年开发。Java的历史可以追溯到多个重要版本，从最初的1.0版本到最新的11版本，不断引入新的特性和改进。本文将详细介绍Java的环境搭建、基本语法、面向对象编程以及一些高级概念和实用技术。

Java简介与环境搭建

Java的历史与发展

Java 是一种面向对象的编程语言，由 James Gosling 于1991年在 Sun Microsystems（现已被 Oracle 收购）开发。Java 最初设计目的是用于交互式电视（Set-top boxes）的开发，但随着互联网的兴起，Java 成为了 Web 开发的重要组成部分。Java 1.0 于1995年发布，后续版本不断更新，引入了更多的特性与改进。

Java 的发展历史可以分为几个主要阶段：

1. Java 1.0（1995年）：首次发布，引入了 Java 语言的基本概念，如面向对象编程、自动内存管理。
2. Java 1.1（1997年）：增加了 Java Beans 和 Java Reflection，提供了更多的库支持。
3. Java 1.2（1998年）：引入了集合框架与 Java 编译器 API。
4. Java 1.3（2000年）：引入了 Java Sound API 和 Java XML API。
5. Java 1.4（2002年）：引入了正则表达式与增强的异常处理。
6. Java 1.5（2004年）：引入了泛型、可变参数、增强的 for 循环等新特性。
7. Java 1.6（2006年）：引入了并发支持与改进的垃圾回收。
8. Java 1.7（2011年）：改进了编译器性能，引入了 try-with-resources 语句。
9. Java 1.8（2014年）：引入了 Lambda 表达式与函数式编程。
10. Java 11（2018年）及后续版本：引入了更多的新特性，如模块化、HTTP 2.0 客户端、局部变量类型推断等。

Java的特点与优势

Java 具有以下主要特点与优势：

1. 跨平台性：Java 代码在任何支持 Java 的平台上都可以编译并运行，具有“一次编写，到处运行”的特性。
2. 面向对象：Java 是一种完全的面向对象语言，支持封装、继承和多态等特性。
3. 自动内存管理：Java 通过垃圾回收机制自动管理内存，减少内存泄漏的可能性。
4. 安全性：Java 有严格的安全模型，支持沙箱环境，可以运行在控制严格的环境中。
5. 强大的库支持：Java 提供了庞大的标准库支持，包括集合框架、输入输出、网络编程等。
6. 多线程支持：Java 内置了多线程处理能力，可以轻松实现复杂并发操作。
7. 动态特性：Java 支持反射机制，允许在运行时动态加载类和调用方法。

开发环境安装与配置（JDK、IDE）

JDK安装

Java Development Kit (JDK) 包含 Java Runtime Environment (JRE) 和 Java Development Kit 工具。以下是在 Windows 系统上安装 JDK 的步骤：

1. 访问 Oracle 官方网站下载 JDK，选择合适的版本（例如，JDK 11）。
2. 运行下载的安装包，按照提示完成安装。
3. 在安装过程中，确保将 JDK 的 bin 目录添加到环境变量 Path 中。例如，安装路径为 C:\Program Files\Java\jdk-11.0.1\bin，则需要添加 C:\Program Files\Java\jdk-11.0.1\bin 到 Path 环境变量中。
4. 验证安装是否成功，打开命令行窗口，输入 java -version 会显示 Java 版本信息。

java -version

IDE配置

Integrated Development Environment (IDE) 是一种集成开发环境，为开发者提供了丰富的功能来编写、调试、运行代码。以下是配置 IntelliJ IDEA（一个流行的 Java IDE）的步骤：

1. 访问 JetBrains 官方网站下载 IntelliJ IDEA。
2. 安装 IntelliJ IDEA，按照提示完成安装。
3. 打开 IntelliJ IDEA，选择 "Configure" -> "SDK Manager"，检查是否已经安装了 Java SDK。如果没有，点击 "Add" 添加安装好的 JDK。
4. 在项目设置中选择已添加的 JDK，这样就可以开始编写 Java 代码了。

Java基本语法入门

变量与数据类型

Java 中的数据类型分为两大类：基本数据类型（Primitive Types）和引用数据类型（Reference Types）。

基本数据类型包括整型（int、short、long、byte）、浮点型（float、double）、布尔型（boolean）和字符型（char）。

变量是用于存储数据的标识符，其类型决定了它可以存储的数据类型。以下是一些示例代码：

public class DataTypesExample {
    public static void main(String[] args) {
        // 整型变量
        int age = 18;
        short year = 2023;
        long population = 7900000000L;

        // 浮点型变量
        float pi = 3.14f;
        double precision = 3.14159265359;

        // 布尔型变量
        boolean isJavaFun = true;
        boolean isLearningJava = false;

        // 字符型变量
        char letter = 'A';

        // 输出变量值
        System.out.println("Age: " + age);
        System.out.println("Year: " + year);
        System.out.println("Population: " + population);
        System.out.println("Pi: " + pi);
        System.out.println("Precision: " + precision);
        System.out.println("Is Java Fun: " + isJavaFun);
        System.out.println("Is Learning Java: " + isLearningJava);
        System.out.println("Letter: " + letter);
    }
}

引用数据类型包括数组（Array）、类（Class）和接口（Interface）等。数组是存储多个相同类型元素的变量。以下是一个数组的例子：

public class ArrayExample {
    public static void main(String[] args) {
        // 创建整型数组
        int[] numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;

        // 输出数组中的值
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number " + (i + 1) + ": " + numbers[i]);
        }
    }
}

运算符与表达式

Java 支持多种运算符，包括算术运算符（+、-、、/、%）、赋值运算符（=、+=、-=、=、/=、%=）、关系运算符（==、!=、>、<、>=、<=）、逻辑运算符（&&、||、!）等。

以下是一些示例代码，展示了这些运算符的用法：

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        // 算术运算
        int sum = a + b;
        int difference = a - b;
        int product = a * b;
        int quotient = a / b;
        int remainder = a % b;

        // 赋值运算
        a += 2;
        a -= 3;
        a *= 4;
        a /= 2;
        a %= 5;

        // 关系运算
        boolean isEqual = (a == b);
        boolean isNotEqual = (a != b);
        boolean isGreaterThan = (a > b);
        boolean isLessThan = (a < b);
        boolean isGreaterThanOrEqual = (a >= b);
        boolean isLessThanOrEqual = (a <= b);

        // 逻辑运算
        boolean result1 = true && false;
        boolean result2 = true || false;
        boolean result3 = !true;

        // 输出结果
        System.out.println("Sum: " + sum);
        System.out.println("Difference: " + difference);
        System.out.println("Product: " + product);
        System.out.println("Quotient: " + quotient);
        System.out.println("Remainder: " + remainder);

        System.out.println("Is Equal: " + isEqual);
        System.out.println("Is Not Equal: " + isNotEqual);
        System.out.println("Is Greater Than: " + isGreaterThan);
        System.out.println("Is Less Than: " + isLessThan);
        System.out.println("Is Greater Than or Equal: " + isGreaterThanOrEqual);
        System.out.println("Is Less Than or Equal: " + isLessThanOrEqual);

        System.out.println("Logical Result 1: " + result1);
        System.out.println("Logical Result 2: " + result2);
        System.out.println("Logical Result 3: " + result3);
    }
}

控制流程语句（条件、循环）

Java 中的控制流程语句包括条件语句（if、else、switch）和循环语句（for、while、do-while）。

条件语句

条件语句用于基于一个条件执行不同的代码块。以下是一个 if-else 语句的例子：

public class ConditionalExample {
    public static void main(String[] args) {
        int age = 18;

        if (age >= 18) {
            System.out.println("Adult");
        } else {
            System.out.println("Minor");
        }
    }
}

以下是一个 switch 语句的例子：

public class SwitchExample {
    public static void main(String[] args) {
        int number = 2;
        String result = "";

        switch (number) {
            case 1:
                result = "One";
                break;
            case 2:
                result = "Two";
                break;
            case 3:
                result = "Three";
                break;
            default:
                result = "Unknown";
                break;
        }

        System.out.println("Number: " + result);
    }
}

循环语句

循环语句用于重复执行一段代码，直到满足某个条件为止。以下是一个 for 循环的例子：

public class LoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }
    }
}

以下是一个 while 循环的例子：

public class WhileLoopExample {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            System.out.println("Count: " + i);
            i++;
        }
    }
}

以下是一个 do-while 循环的例子：

public class DoWhileLoopExample {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("Count: " + i);
            i++;
        } while (i <= 5);
    }
}

对象与类的初步理解

Java面向对象基础

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想是将数据和操作数据的方法组织成对象。Java 是一种纯面向对象的语言，所有代码都是基于类（Class）和对象（Object）的。

类与对象

类是一个抽象的模板，定义了对象的属性（数据）和行为（方法）。对象是类的实例化，具有类定义的属性和方法。

类的定义

类的定义包括属性（成员变量）和方法（成员方法）。以下是一个简单的类定义的例子：

public class Person {
    // 成员变量
    String name;
    int age;

    // 成员方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

对象的实例化

通过 new 关键字可以创建类的实例，实例化后的对象可以访问类中的成员变量和方法。

public class ObjectExample {
    public static void main(String[] args) {
        // 创建 Person 类的实例
        Person person = new Person();

        // 设置成员变量
        person.name = "Alice";
        person.age = 25;

        // 调用成员方法
        person.sayHello();
    }
}

类的定义与实例化

类的定义包括属性和方法。属性是类的状态，方法是类的操作。以下是一个更复杂的类定义的例子：

public class Car {
    // 成员变量
    String brand;
    int year;
    boolean isRunning;

    // 构造方法
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
        this.isRunning = false;
    }

    // 成员方法
    public void start() {
        if (!isRunning) {
            System.out.println(brand + " " + year + " 开始运行");
            isRunning = true;
        } else {
            System.out.println(brand + " " + year + " 已经在运行");
        }
    }

    public void stop() {
        if (isRunning) {
            System.out.println(brand + " " + year + " 停止运行");
            isRunning = false;
        } else {
            System.out.println(brand + " " + year + " 未运行");
        }
    }
}

构造方法

构造方法是用于创建对象时初始化对象的特殊方法。构造方法的名称必须与类名相同，并且没有返回类型。以下是一个构造方法的例子：

public Car(String brand, int year) {
    this.brand = brand;
    this.year = year;
    this.isRunning = false;
}

成员方法

成员方法是定义在类中的方法，可以访问类的成员变量。以下是一些成员方法的例子：

public void start() {
    if (!isRunning) {
        System.out.println(brand + " " + year + " 开始运行");
        isRunning = true;
    } else {
        System.out.println(brand + " " + year + " 已经在运行");
    }
}

public void stop() {
    if (isRunning) {
        System.out.println(brand + " " + year + " 停止运行");
        isRunning = false;
    } else {
        System.out.println(brand + " " + year + " 未运行");
    }
}

对象的实例化

通过 new 关键字可以创建类的实例，并调用构造方法进行初始化。以下是一个对象实例化和调用成员方法的例子：

public class ObjectInstantiationExample {
    public static void main(String[] args) {
        // 创建 Car 类的实例
        Car car1 = new Car("Toyota", 2020);
        Car car2 = new Car("Honda", 2018);

        // 调用成员方法
        car1.start();
        car2.stop();
    }
}

对象的方法与属性

对象的方法和属性是通过类定义的。方法是对象的行为，属性是对象的状态。以下是一个对象方法与属性的例子：

public class Student {
    // 成员变量
    String name;
    int age;
    double gpa;

    // 构造方法
    public Student(String name, int age, double gpa) {
        this.name = name;
        this.age = age;
        this.gpa = gpa;
    }

    // 成员方法
    public void study() {
        System.out.println(name + " 正在学习");
    }

    public void printInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("GPA: " + gpa);
    }
}

对象的属性访问

通过点操作符 . 可以访问对象的属性。以下是一个访问对象属性的例子：

public class PropertyAccessExample {
    public static void main(String[] args) {
        // 创建 Student 类的实例
        Student student = new Student("John", 20, 3.5);

        // 访问属性
        System.out.println("Name: " + student.name);
        System.out.println("Age: " + student.age);
        System.out.println("GPA: " + student.gpa);
    }
}

对象的方法调用

通过点操作符 . 可以调用对象的方法。以下是一个调用对象方法的例子：

public class MethodCallExample {
    public static void main(String[] args) {
        // 创建 Student 类的实例
        Student student = new Student("Jane", 21, 3.8);

        // 调用成员方法
        student.study();
        student.printInfo();
    }
}

高级概念介绍

继承与多态

继承是一种机制，允许一个类继承另一个类的属性和方法。类的继承可以提高代码的重用性，使程序结构更加清晰。多态是一种机制，允许子类重写父类的方法，实现不同的行为。

继承

继承通过 extends 关键字实现。子类可以继承父类的所有非私有成员。以下是一个继承的例子：

public class Animal {
    String name;
    int age;

    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " 正在吠叫");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        // 创建 Dog 类的实例
        Dog dog = new Dog();

        // 设置属性
        dog.name = "Buddy";
        dog.age = 3;

        // 调用方法
        dog.eat();
        dog.bark();
    }
}

多态

多态允许子类重写父类的方法，实现不同的行为。以下是一个多态的例子：

public class Vehicle {
    public void move() {
        System.out.println("Vehicle is moving");
    }
}

public class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Car is moving on the road");
    }
}

public class Truck extends Vehicle {
    @Override
    public void move() {
        System.out.println("Truck is moving on the road");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        // 创建 Car 和 Truck 的实例
        Vehicle car = new Car();
        Vehicle truck = new Truck();

        // 调用方法
        car.move();
        truck.move();
    }
}

接口与抽象类

接口和抽象类是抽象概念的实现，允许定义一组方法的签名，而不需要提供实现。接口只能包含抽象方法，而抽象类可以包含抽象方法和具体方法。接口和抽象类都是为了实现多态性和重用性。

接口

接口通过 interface 关键字定义。接口可以包含常量和抽象方法。以下是一个接口的例子：

public interface Movable {
    void move();
    void stop();
}

public class Car implements Movable {
    @Override
    public void move() {
        System.out.println("Car is moving");
    }

    @Override
    public void stop() {
        System.out.println("Car is stopped");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        // 创建 Car 实例
        Car car = new Car();

        // 调用接口方法
        car.move();
        car.stop();
    }
}

抽象类

抽象类通过 abstract 关键字定义。抽象类可以包含抽象方法和具体方法。以下是一个抽象类的例子：

public abstract class Animal {
    public abstract void eat();

    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        // 创建 Dog 实例
        Dog dog = new Dog();

        // 调用方法
        dog.eat();
        dog.sleep();
    }
}

异常处理

异常处理是 Java 中的一种机制，用于处理程序运行时发生的错误。通过捕获和处理异常，可以提高程序的健壮性和稳定性。Java 中的异常处理使用 try-catch 块和 finally 块来实现。

捕获异常

通过 try-catch 块可以捕获和处理异常。以下是一个捕获异常的例子：

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为零");
        } finally {
            System.out.println("程序执行完毕");
        }
    }
}

抛出异常

通过 throw 关键字可以抛出异常。以下是一个抛出异常的例子：

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            throw new ArithmeticException("除数不能为零");
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        }
    }
}

Java实用技术

常用库的使用

Java 提供了丰富的标准库，包括集合框架、输入输出、网络编程等。以下是一些常用库的使用示例：

集合框架

集合框架提供了多种数据结构，如 List、Set、Map 等，用于存储和操作数据。以下是一个集合框架的例子：

import java.util.ArrayList;
import java.util.List;

public class CollectionExample {
    public static void main(String[] args) {
        // 创建 List
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 输出 List
        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}

输入输出

Java 提供了多种输入输出流，用于读写文件。以下是一个文件读写的例子：

import java.io.*;

public class FileIOExample {
    public static void main(String[] args) throws IOException {
        // 写入文件
        try (FileWriter fileWriter = new FileWriter("output.txt")) {
            fileWriter.write("Hello, world");
        }

        // 读取文件
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("output.txt"))) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

文件操作与流处理

文件操作是 Java 程序开发中常见的需求之一。Java 的标准库提供了多种文件读写的方法，包括 File、FileReader、FileWriter、BufferedReader、BufferedWriter 等。

文件读写

以下是一个文件读写的完整示例：

import java.io.*;

public class FileReadWriteExample {
    public static void main(String[] args) throws IOException {
        // 写入文件
        try (FileWriter fileWriter = new FileWriter("output.txt")) {
            fileWriter.write("Hello, world");
        }

        // 读取文件
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("output.txt"))) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

网络编程基础

Java 提供了多种网络编程的方法，包括 Socket、ServerSocket、DatagramSocket 等。以下是一个简单的客户端-服务器网络通信的例子：

服务器端

服务器端通过 ServerSocket 监听端口，接收客户端连接并进行通信：

import java.io.*;
import java.net.*;

public class SimpleServer {
    public static void main(String[] args) throws IOException {
        // 创建服务器端 Socket
        try (ServerSocket serverSocket = new ServerSocket(8080)) {
            System.out.println("服务器已启动，等待客户端连接...");

            // 接收客户端连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端已连接");

            // 读取客户端消息
            try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("客户端消息: " + inputLine);
                }
            }
        }
    }
}

客户端

客户端通过 Socket 连接到服务器端，并进行通信：

import java.io.*;
import java.net.*;

public class SimpleClient {
    public static void main(String[] args) throws IOException {
        // 创建客户端 Socket
        try (Socket socket = new Socket("localhost", 8080)) {
            System.out.println("客户端已连接服务器");

            // 向服务器发送消息
            try (PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true)) {
                out.println("Hello, server");
            }
        }
    }
}

项目实战与调试技巧

小项目实战演练

以下是一个简单的项目示例，实现一个简单的投票系统。该项目包括前端界面和后端逻辑。

前端界面

前端界面使用 HTML 和 JavaScript 实现。以下是一个简单的 HTML 页面示例：

<!DOCTYPE html>
<html>
<head>
    <title>投票系统</title>
</head>
<body>
    <h1>投票系统</h1>
    <form id="voteForm">
        <input type="radio" name="option" value="Option 1"> 选项 1<br>
        <input type="radio" name="option" value="Option 2"> 选项 2<br>
        <input type="radio" name="option" value="Option 3"> 选项 3<br>
        <input type="submit" value="投票">
    </form>

    <div id="result"></div>

    <script>
        document.getElementById('voteForm').onsubmit = function(event) {
            event.preventDefault();
            const option = document.querySelector('input[name="option"]:checked').value;
            fetch('/vote', {
                method: 'POST',
                body: JSON.stringify({ option }),
                headers: { 'Content-Type': 'application/json' }
            }).then(response => response.json())
             .then(data => {
                 document.getElementById('result').innerText = data.message;
             });
        };
    </script>
</body>
</html>

后端逻辑

后端逻辑使用 Java 实现。以下是一个简单的 Java 服务器示例：

import java.io.*;
import java.net.*;
import javax.servlet.ServletException;
import javax.servlet.http.*;
import javax.servlet.annotation.*;

@WebServlet("/vote")
public class VoteServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String option = request.getParameter("option");
        System.out.println("投票选项: " + option);

        // 记录投票结果
        String message = "投票成功";
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write("{\"message\": \"" + message + "\"}");
    }
}

常见错误调试与解决方法

调试是找出并修正程序错误的过程。常见的调试方法包括打印调试信息、使用调试器等。

打印调试信息

通过输出关键变量的值，可以找出程序中的错误。例如：

public class DebugExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = a / b;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为零");
        }
    }
}

使用调试器

使用调试器可以逐步执行代码，观察变量的变化。以下是在 IntelliJ IDEA 中使用调试器的步骤：

1. 在代码中设置断点。
2. 在运行模式下启动程序。
3. 使用调试工具逐步执行代码，观察变量的变化。

代码优化与重构

代码优化是提高代码性能和可读性的过程。代码重构是修改代码结构，而保持功能不变的过程。

代码优化

以下是一个代码优化的例子：

public class OptimizationExample {
    public static void main(String[] args) {
        int[] numbers = new int[1000000];
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i;
        }

        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }

        System.out.println("Sum: " + sum);
    }
}

可以通过减少循环次数来优化代码：

public class OptimizedExample {
    public static void main(String[] args) {
        int[] numbers = new int[1000000];
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i;
        }

        int sum = 0;
        for (int i = 0; i < numbers.length; i += 2) {
            sum += numbers[i];
        }
        for (int i = 1; i < numbers.length; i += 2) {
            sum += numbers[i];
        }

        System.out.println("Sum: " + sum);
    }
}

代码重构

代码重构是修改代码结构，提高代码可读性和可维护性的过程。以下是一个代码重构的例子：

public class OriginalExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + b;
        int d = a - b;
        int e = a * b;
        int f = a / b;

        System.out.println("Sum: " + c);
        System.out.println("Difference: " + d);
        System.out.println("Product: " + e);
        System.out.println("Quotient: " + f);
    }
}

可以通过提取方法来重构代码：

public class RefactoredExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("Sum: " + calculateSum(a, b));
        System.out.println("Difference: " + calculateDifference(a, b));
        System.out.println("Product: " + calculateProduct(a, b));
        System.out.println("Quotient: " + calculateQuotient(a, b));
    }

    public static int calculateSum(int a, int b) {
        return a + b;
    }

    public static int calculateDifference(int a, int b) {
        return a - b;
    }

    public static int calculateProduct(int a, int b) {
        return a * b;
    }

    public static int calculateQuotient(int a, int b) {
        return a / b;
    }
}
``

通过上述步骤，可以逐步掌握 Java 编程的基础知识与进阶技巧，为开发更复杂的应用奠定坚实的基础。