Java程序设计实例教程

前言

为什么选择Java？

• 跨平台性：“一次编写，到处运行”（Write Once, Run Anywhere），Java代码被编译成与平台无关的字节码，由Java虚拟机运行。
• 面向对象：Java是纯粹的面向对象语言，有助于构建模块化、可重用、可维护的大型应用程序。
• 丰富的生态系统：拥有庞大的开源库（如Spring, MyBatis, Maven）和活跃的社区。
• 健壮性与安全性：自动垃圾回收、严格的类型检查和异常处理机制，使程序更加稳定和安全。

本教程将带你完成几个经典的实例,覆盖Java基础、面向对象、集合、I/O和简单的网络编程。

第一部分：Java基础入门

实例1：你好，世界！—— 第一个Java程序

这是学习任何编程语言的“Hello, World!”程序，它将帮助你搭建开发环境并验证配置。

目标：在控制台打印出 "Hello, World!"。

步骤：

1. 安装环境：

   • JDK (Java Development Kit)：包含Java编译器（javac）和运行时环境（java），从Oracle官网或OpenJDK下载并安装。
   • IDE (Integrated Development Environment)：推荐使用 IntelliJ IDEA (社区版免费) 或 Eclipse，它们能极大提升开发效率。

2. 创建项目：

   • 在IDE中,创建一个新的Java项目。
   • 在项目源代码目录（通常是 src）下，创建一个新的Java类，命名为 HelloWorld。

3. 编写代码：

// HelloWorld.java
// 1. 定义一个名为 HelloWorld 的公共类
public class HelloWorld {
    // 2. 这是程序的入口点，Java虚拟机从这里开始执行代码
    public static void main(String[] args) {
        // 3. 使用 System.out.println() 方法在控制台打印文本
        System.out.println("Hello, World!");
    }
}

代码解析：

• public class HelloWorld：定义一个公共的类，Java程序的基本单位是类，文件名必须与公共类名一致（HelloWorld.java）。
• public static void main(String[] args)：这是主方法，是程序的入口。public表示可被任何地方访问，static表示属于类而非对象，void表示方法不返回任何值，String[] args是命令行参数。
• System.out.println("...")：一个标准的输出语句，会在内容后换行。

运行： 在IDE中右键点击 HelloWorld.java，选择 "Run 'HelloWorld.main()'"，你将在控制台看到输出：

Hello, World!

实例2：简易计算器—— 基本数据类型与运算符

目标：编写一个程序，接收用户输入的两个数字和一个运算符，然后输出计算结果。

步骤：

1. 创建一个新类 SimpleCalculator。
2. 使用 Scanner 类来获取用户输入。

代码：

// SimpleCalculator.java
import java.util.Scanner; // 导入Scanner类，用于读取用户输入
public class SimpleCalculator {
    public static void main(String[] args) {
        // 1. 创建Scanner对象，用于从标准输入（键盘）读取数据
        Scanner scanner = new Scanner(System.in);
        // 2. 提示用户输入第一个数字
        System.out.print("请输入第一个数字: ");
        double num1 = scanner.nextDouble(); // 读取一个双精度浮点数
        // 3. 提示用户输入运算符
        System.out.print("请输入运算符 (+, -, *, /): ");
        char operator = scanner.next().charAt(0); // 读取一个字符
        // 4. 提示用户输入第二个数字
        System.out.print("请输入第二个数字: ");
        double num2 = scanner.nextDouble();
        double result;
        // 5. 使用 switch 语句根据运算符进行计算
        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                // 处理除数为零的情况
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("错误：除数不能为零！");
                    return; // 结束程序
                }
                break;
            default:
                System.out.println("错误：无效的运算符！");
                return; // 结束程序
        }
        // 6. 输出结果
        System.out.println("计算结果是: " + result);
        // 7. 关闭Scanner，释放资源
        scanner.close();
    }
}

代码解析：

• import java.util.Scanner;：导入Java工具包中的Scanner类。
• Scanner scanner = new Scanner(System.in);：创建一个Scanner实例，关联到标准输入流（键盘）。
• scanner.nextDouble()：读取用户输入的下一个双精度浮点数。
• scanner.next().charAt(0)：读取用户输入的下一个字符串，并取其第一个字符。
• switch-case：一个多路分支结构，根据operator的值执行不同的计算。
• scanner.close()：非常重要！关闭Scanner以防止资源泄漏。

第二部分：面向对象编程

实例3：学生成绩管理系统—— 类与对象

目标：创建一个Student类来表示学生，然后创建该类的对象（实例）并进行操作。

步骤：

1. 创建Student类，封装学生的属性（姓名、学号、成绩）和行为（显示信息）。
2. 创建StudentManagementSystem类，作为主程序，用于创建和使用Student对象。

代码：

Student.java (模型类)

// Student.java
public class Student {
    // 1. 成员变量（属性），用private修饰，实现封装
    private String name;
    private String id;
    private double score;
    // 2. 构造方法，用于创建对象时初始化属性
    public Student(String name, String id, double score) {
        this.name = name;
        this.id = id;
        this.score = score;
    }
    // 3. Getter 和 Setter 方法，用于安全地访问和修改私有属性
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        // 可以在setter中添加业务逻辑，如验证
        if (score >= 0 && score <= 100) {
            this.score = score;
        } else {
            System.out.println("成绩无效，设置失败！");
        }
    }
    // 4. 显示学生信息的方法
    public void displayInfo() {
        System.out.println("学生姓名: " + name);
        System.out.println("学号: " + id);
        System.out.println("成绩: " + score);
        System.out.println("----------------------");
    }
}

StudentManagementSystem.java (主程序)

// StudentManagementSystem.java
public class StudentManagementSystem {
    public static void main(String[] args) {
        // 1. 使用构造方法创建 Student 对象（实例化）
        Student student1 = new Student("张三", "S001", 85.5);
        Student student2 = new Student("李四", "S002", 92.0);
        // 2. 调用对象的方法
        System.out.println("--- 初始学生信息 ---");
        student1.displayInfo();
        student2.displayInfo();
        // 3. 使用 Setter 方法修改学生信息
        System.out.println("\n--- 修改张三的成绩 ---");
        student1.setScore(88.0); // 修改成绩
        student1.displayInfo();
        // 4. 尝试设置一个无效的成绩
        System.out.println("\n--- 尝试设置无效成绩 ---");
        student2.setScore(150); // 会触发错误提示
        student2.displayInfo(); // 成绩不会被修改
    }
}

核心概念解析：

• 类：Student是一个蓝图，定义了学生应该有什么属性和行为。
• 对象：student1和student2是Student类具体的实例，它们拥有自己的独立数据。
• 封装：将数据（name, id, score）和操作数据的方法捆绑在一起，并通过private隐藏内部细节，通过public的getter/setter提供受控的访问。
• 构造方法：与类同名，用于创建和初始化对象。new Student(...)就是在调用构造方法。
• this关键字：在方法内部指代当前对象本身，用于区分成员变量和局部变量。

实例4：员工与部门—— 继承与多态

目标：使用继承来创建不同类型的员工，并利用多态来统一管理他们。

步骤：

1. 创建一个父类 Employee。
2. 创建子类 Developer 和 Manager，它们继承自 Employee。
3. 在主程序中,创建一个包含不同类型员工的列表，并遍历调用它们的方法，体验多态。

代码：

Employee.java (父类)

// Employee.java
public abstract class Employee { // 使用 abstract，表示这是一个抽象类，不能被实例化
    protected String name;
    protected double salary;
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    // 抽象方法，没有方法体，子类必须实现它
    public abstract void work();
    // 普通方法
    public void getDetails() {
        System.out.println("姓名: " + name + ", 薪资: " + salary);
    }
}

Developer.java (子类)

// Developer.java
public class Developer extends Employee { // 使用 extends 关键字继承 Employee
    public Developer(String name, double salary) {
        super(name, salary); // 调用父类的构造方法
    }
    @Override // 注解，表示重写父类的方法
    public void work() {
        System.out.println(name + " 正在编写代码、调试程序...");
    }
}

Manager.java (子类)

// Manager.java
public class Manager extends Employee {
    public Manager(String name, double salary) {
        super(name, salary);
    }
    @Override
    public void work() {
        System.out.println(name + " 正在开会、制定项目计划...");
    }
}

Company.java (主程序)

// Company.java
import java.util.ArrayList;
import java.util.List;
public class Company {
    public static void main(String[] args) {
        // 创建一个员工列表，可以存放不同类型的子类对象
        List<Employee> employees = new ArrayList<>();
        // 添加不同类型的员工到列表中
        employees.add(new Developer("王五", 15000));
        employees.add(new Manager("赵六", 25000));
        employees.add(new Developer("孙七", 16000));
        System.out.println("--- 公司员工工作情况 ---");
        // 遍历员工列表
        for (Employee emp : employees) {
            // 这就是多态！
            // emp 的实际类型可能是 Developer 或 Manager
            // JVM会根据emp的实际类型，调用对应版本的 work() 方法
            emp.work();
        }
        System.out.println("\n--- 员工详细信息 ---");
        for (Employee emp : employees) {
            emp.getDetails(); // 调用从父类继承来的方法
        }
    }
}

核心概念解析：

• 继承：Developer和Manager继承了Employee，获得了其属性和方法，并可以扩展自己的功能。
• 方法重写：子类提供了与父类相同方法签名的方法，实现自己的特定行为。
• 多态：List<Employee>列表可以存放Employee的任何子类对象，在调用emp.work()时，程序会根据emp在运行时的实际类型来决定调用哪个版本的work()方法，这使得代码更加灵活和可扩展。

第三部分：常用API与实战

实例5：文件读写器—— I/O流与异常处理

目标：将一段文本写入文件，然后再从文件中读取并打印出来。

步骤：

1. 使用 FileWriter 和 BufferedWriter 写入文件。
2. 使用 FileReader 和 BufferedReader 读取文件。
3. 使用 try-with-resources 语句自动管理资源，避免资源泄漏。

代码：

// FileReadWriteDemo.java
import java.io.*;
public class FileReadWriteDemo {
    public static void main(String[] args) {
        String fileName = "my_document.txt";
        String content = "你好，Java世界！\n这是通过Java写入文件的第一行，\n这是第二行。";
        // --- 写入文件 ---
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
            writer.write(content);
            System.out.println("文件 '" + fileName + "' 写入成功！");
        } catch (IOException e) {
            System.err.println("写入文件时发生错误: " + e.getMessage());
        }
        // --- 读取文件 ---
        System.out.println("\n--- 正在读取文件内容 ---");
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            // 逐行读取，直到文件末尾
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.err.println("错误：文件 '" + fileName + "' 未找到！");
        } catch (IOException e) {
            System.err.println("读取文件时发生错误: " + e.getMessage());
        }
    }
}

代码解析：

• I/O流：Java通过“流”来处理输入和输出。FileWriter/FileReader是基本的字符流，BufferedWriter/BufferedReader是带有缓冲区的高效字符流。
• try-with-resources：这是Java 7引入的特性，任何实现了AutoCloseable接口的资源（如文件流）都可以在try语句中声明，try块执行完毕后，会自动调用close()方法，即使发生异常也能保证资源被正确关闭。
• 异常处理：文件操作可能会抛出IOException，必须使用try-catch块来捕获和处理这些异常，使程序更健壮。

总结与下一步

通过以上5个实例,你已经覆盖了Java编程的核心概念：

1. 基础语法：变量、数据类型、运算符、流程控制。
2. 面向对象：类、对象、封装、继承、多态。
3. 常用API：Scanner（输入）、集合（ArrayList）、I/O流。
4. 核心思想：异常处理、资源管理。

下一步你可以学习什么？

• 集合框架：深入学习List, Set, Map接口及其实现类（ArrayList, HashSet, HashMap）。
• 多线程：学习如何创建和管理线程，编写并发程序。
• 网络编程：使用Socket进行客户端和服务端通信。
• 数据库连接：学习使用JDBC连接数据库，进行CRUD操作。
• 主流框架：学习Spring Boot框架，快速开发企业级应用。

练习建议：

• 动手实践：不要只看不练，尝试修改每个实例的代码，看看会发生什么。
• 做小项目：尝试自己动手做一个项目，比如一个待办事项列表、一个简单的图书管理系统，这是检验和巩固所学知识的最好方式。
• 阅读官方文档：学会查阅Java官方API文档，这是每个程序员必备的技能。

希望这份教程能帮助你顺利开启Java编程之旅！祝你学习愉快！