简介：清华大学提供的Java教程是一份旨在帮助初学者及有经验开发者深入理解Java的全面学习资源。教程包含实例和实际操作练习，涵盖Java基础语法、面向对象编程（OOP）核心概念、异常处理、集合框架、线程与并发处理、I/O流和Java标准库的使用。通过这份教程，学生可以学习Java编程语言的各个方面，并提升开发更复杂Java系统的能力。 ![[清华大学]JAVA教程](https://d1g9li960vagp7.cloudfront.net/wp-content/uploads/2018/10/While-Schleife_WP_04-1024x576.png)
1. Java基础语法教学
1.1 Java语言简介
Java是一种面向对象的编程语言，由Sun Microsystems公司于1995年推出，其设计目标旨在“一次编写，到处运行”，使得Java程序可以在任何安装了Java虚拟机（JVM）的平台上执行。Java广泛应用于企业级应用开发、安卓应用开发等领域，因其良好的跨平台特性和丰富的标准库支持，成为IT行业最受欢迎的编程语言之一。
1.2 基本数据类型和运算符
Java提供了八种基本数据类型：byte、short、int、long、float、double、char和boolean。这些类型为Java程序的运行提供了底层的数据支持。对于基本类型的变量，Java提供了一套丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符等，以支持基本数据类型的运算和比较操作。
1.3 控制流程
控制流程是编程中的核心概念，Java提供了多种控制结构来实现流程控制，包括选择结构的if-else和switch-case，以及循环结构的for、while和do-while。这些结构使得程序能够根据不同的条件执行不同的代码路径，或者重复执行同一段代码，从而实现复杂的逻辑控制。
代码示例
下面是一个简单的Java程序示例，演示了基本数据类型的定义和使用，以及控制流程的应用：
public class Main {
public static void main(String[] args) {
// 定义并初始化基本数据类型变量
int number = 10;
boolean isEven = (number % 2 == 0); // 运算符使用示例
// 控制流程示例
if (isEven) {
System.out.println(number + " 是偶数");
} else {
System.out.println(number + " 是奇数");
}
}
}
在上述代码中，定义了一个整型变量 number 并判断其是否为偶数，根据结果输出不同的信息。这展示了基本的数据类型定义、运算符的使用以及控制结构的应用。
2. 面向对象编程深入讲解
2.1 类与对象的本质
2.1.1 类的定义和属性
在Java中，类是创建对象的蓝图或模板。它定义了创建对象时可以指定的一组属性（字段）和方法。属性是类中声明的变量，可以是基本数据类型或对象类型，而方法是类中定义的行为。
public class Person {
private String name; // 属性
private int age; // 属性
private String address; // 属性
// 方法：获取人名
public String getName() {
return name;
}
// 方法：设置人名
public void setName(String name) {
this.name = name;
}
// 其他方法...
}
在这个例子中， Person 类有三个属性： name 、 age 和 address 。每个属性都有一个访问修饰符，这里使用了 private ，意味着它们只能在类的内部被访问。类中还定义了几个方法，用于访问和修改这些属性。
2.1.2 对象的创建和使用
对象是根据类的定义创建的实例。创建对象通常需要使用 new 关键字，后跟类名和一对括号，如下所示：
Person person = new Person();
person.setName("John Doe");
person.setAge(30);
person.setAddress("123 Main St");
对象创建后，就可以调用其方法和访问其属性。在Java中，对象的内存是动态分配的，必须通过 new 关键字显式创建。
2.2 面向对象的三大特性
2.2.1 封装性的实现和意义
封装是面向对象编程的一个基本原则，它涉及将数据（属性）和操作数据的代码（方法）捆绑在一起，对外隐藏对象的实现细节。这样可以提高数据的安全性和方法的可用性。
public class BankAccount {
private double balance; // 私有属性，外部不能直接访问
// 构造函数，初始化余额
public BankAccount(double initialBalance) {
this.balance = initialBalance;
}
// 方法：存钱
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
// 方法：取钱，包含逻辑判断
public boolean withdraw(double amount) {
if (amount > balance) {
return false;
}
balance -= amount;
return true;
}
// 获取余额的方法
public double getBalance() {
return balance;
}
}
在这个 BankAccount 类中， balance 属性是私有的，这样它就不能被外部直接访问，只能通过公共方法 deposit 和 withdraw 来修改。这确保了只有在方法中添加逻辑的情况下，余额才能被改变，增强了封装性。
2.2.2 继承机制的规则与应用
继承是面向对象编程的另一个关键特性，它允许一个类继承另一个类的属性和方法。继承的类（子类）可以添加新的属性和方法，也可以重写父类的方法。
public class SavingAccount extends BankAccount {
private double interestRate; // 特有属性
// 构造函数，调用父类构造函数并添加额外属性
public SavingAccount(double initialBalance, double rate) {
super(initialBalance);
this.interestRate = rate;
}
// 重写父类的存款方法
@Override
public void deposit(double amount) {
amount *= (1 + interestRate);
super.deposit(amount);
}
// 其他特有方法...
}
在这个例子中， SavingAccount 类继承自 BankAccount 类。它有自己的特有属性 interestRate ，并且重写了 deposit 方法以包含利息计算。通过继承， SavingAccount 能够利用 BankAccount 中已有的功能，减少了代码重复，并且增强了程序的模块性。
2.2.3 多态的表现和在代码中的实现
多态是指允许不同类的对象对同一消息做出响应的能力。在Java中，多态通常通过方法重载和重写实现，以及通过接口实现。
public class Employee {
private String name;
private String id;
public Employee(String name, String id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public String getId() {
return id;
}
}
public class Manager extends Employee {
public Manager(String name, String id) {
super(name, id);
}
// 重写方法
@Override
public String getName() {
return "Manager: " + super.getName();
}
}
public class Executive extends Manager {
public Executive(String name, String id) {
super(name, id);
}
// 重写方法
@Override
public String getName() {
return "Executive: " + super.getName();
}
}
在这个例子中， Employee 类是一个基类， Manager 和 Executive 类是从 Employee 继承而来的子类，并且重写了 getName 方法。由于Java方法重写的特性，当我们用父类类型来引用子类对象，并调用 getName 方法时，将执行对应子类的实现。这种行为被称为运行时多态。
Employee emp = new Manager("John", "M001");
System.out.println(emp.getName()); // 输出 "Manager: John"
emp = new Executive("Doe", "E001");
System.out.println(emp.getName()); // 输出 "Executive: Doe"
通过这种方式，一个父类的引用变量可以指向不同类型但具有相同方法签名的子类对象。这使得程序更加灵活，易于扩展。
2.3 抽象类与接口的对比
2.3.1 抽象类的特点和应用场景
抽象类是不能实例化的类，它可以包含抽象方法（没有方法体的方法），子类需要提供这些抽象方法的具体实现。抽象类通常用于描述具有某些共同特征的类的共性。
public abstract class Shape {
private String color;
public Shape(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
// 抽象方法：计算面积
public abstract double area();
}
public class Circle extends Shape {
private double radius;
public Circle(double radius, String color) {
super(color);
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
}
在这个例子中， Shape 是一个抽象类，它定义了一个颜色属性和一个计算面积的抽象方法 area() 。 Circle 类继承自 Shape 类，并提供了 area() 方法的具体实现。抽象类适用于那些希望分享代码给多个子类，但又想让子类具体实现某些方法的场景。
2.3.2 接口的定义和实现
接口在Java中是一种特殊类型，它完全由抽象方法和常量组成。接口定义了一个类应该做什么，但是不关心具体如何实现。从Java 8开始，接口也可以包含默认方法和静态方法。
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 has stopped.");
}
}
在这个例子中， Movable 接口定义了两个抽象方法： move 和 stop 。 Car 类实现了 Movable 接口，并提供了这两个方法的具体实现。接口通常用于表示具有相同行为的不同类之间的共同约定。
2.3.3 抽象类与接口的选择与对比
选择抽象类还是接口取决于你的设计需求。抽象类和接口都有自己的用例和限制：
- 抽象类可以提供一些方法的具体实现，这允许子类直接继承这些方法。
- 接口只定义方法签名，这确保了实现接口的类必须提供方法的具体实现。
- 一个类可以继承一个抽象类，并实现多个接口。
最终，你选择哪一个取决于你希望你的类继承多少行为和状态。如果多个类具有相似的功能但不共享相同的状态，则接口可能是更好的选择。如果这些类之间有共享的状态，并且你需要共享一些通用的方法实现，则应考虑使用抽象类。
3. 异常处理的实践
异常处理是Java编程中不可或缺的一部分，它允许程序以优雅的方式处理运行时出现的错误，提高程序的健壮性和用户体验。本章节将深入探讨异常处理的基本概念、自定义异常与异常链的应用，以及异常处理的最佳实践。
3.1 异常处理基本概念
异常是程序运行过程中出现的不正常情况，如除以零、文件不存在等。Java通过一系列的异常类来处理这些运行时错误。
3.1.1 异常类的层次结构
Java的异常类主要分为两大类：检查型异常（checked exceptions）和非检查型异常（unchecked exceptions）。检查型异常需要在代码中显式处理（使用try-catch或者声明抛出），而非检查型异常则不需要（如运行时异常 RuntimeException ）。
异常类的层次结构如下：
graph TD
Exception[Exception] --> RuntimeException[RuntimeException]
Exception --> IOException[IOException]
Exception --> Exception2[...]
RuntimeException --> NullPointerException[NullPointerException]
RuntimeException --> ArrayIndexOutOfBoundsException[ArrayIndexOutOfBoundsException]
RuntimeException --> ArithmeticException[ArithmeticException]
IOException --> FileNotFoundException[FileNotFoundException]
IOException --> EOFException[EOFException]
IOException --> IOException2[...]
3.1.2 try-catch-finally语句的使用
try-catch-finally 是异常处理的核心语法结构。 try 块中包含可能会抛出异常的代码， catch 块用于捕获并处理异常，而 finally 块中的代码无论是否抛出异常都会执行。
try {
// 尝试执行的代码
} catch (ExceptionType1 e1) {
// 异常类型为 ExceptionType1 时的处理逻辑
} catch (ExceptionType2 e2) {
// 异常类型为 ExceptionType2 时的处理逻辑
} finally {
// 不管是否发生异常，都必须执行的代码
}
异常处理不仅有助于程序的正常运行，还能通过捕获异常提供更详细的错误信息给用户或记录到日志中，便于后续的调试和问题解决。
3.2 自定义异常与异常链
在实际开发中，Java提供的异常类往往无法完全满足需求。此时，开发者可以根据业务逻辑的需要自定义异常类。
3.2.1 创建自定义异常类
自定义异常类通常继承自 Exception 类或者其子类。例如，创建一个 CustomException 类：
public class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
3.2.2 异常链的构造与意义
异常链是一种将当前异常与另一个异常关联起来的技术，便于跟踪异常的根本原因。使用 Throwable 的 initCause 方法和 getCause 方法可以构建和获取异常链。
Throwable previousException = new Exception("Previous exception");
CustomException newException = new CustomException("New custom exception");
newException.initCause(previousException);
// 获取异常链中的前一个异常
Throwable cause = newException.getCause();
异常链的构造使得异常处理可以更加精确地定位问题，通过逐层分析异常链，开发者可以快速地定位到最初的问题点。
3.3 异常处理的最佳实践
编写健壮的代码离不开良好的异常处理实践。下面是一些在异常处理中应遵循的最佳实践。
3.3.1 异常处理策略
- 尽量捕获最具体的异常类型 ：这样可以提供更精确的错误处理逻辑。
- 不要忽略捕获的异常 ：捕获异常后应进行适当处理，即使仅记录日志也应该明确指出。
- 避免在catch块中捕获
Throwable或Exception：这可能会隐藏非检查型异常，使得问题难以发现。 - 不要在catch块中返回或继续执行可能导致错误的代码 ：这可能导致数据不一致或程序状态的混乱。
3.3.2 异常日志记录与分析
记录异常日志是定位和解决问题的重要手段。合理地记录异常信息可以帮助开发和运维人员快速定位问题。
try {
// 可能抛出异常的代码
} catch (Exception e) {
// 记录异常信息到日志文件
Logger.getLogger(MyClass.class.getName()).log(Level.SEVERE, "An error occurred", e);
}
在记录异常时，应包括以下信息：
- 异常类型
- 异常消息
- 异常栈跟踪
- 相关的环境信息（如操作系统、JVM版本等）
- 重要的业务上下文信息
合理地使用异常处理不仅可以提高程序的可读性和可维护性，还可以增强程序的健壮性，减少因错误处理不当导致的系统崩溃和数据丢失风险。因此，掌握异常处理的高级技巧对任何Java开发者来说都是必不可少的。
4. Java集合框架应用
4.1 集合框架概述
4.1.1 集合框架的主要接口
Java集合框架提供了一系列接口和类，用于存储和操作对象集合。核心接口包括List, Set, 和Map。List接口代表有序集合，可以包含重复元素；Set接口代表无序集合，且不允许重复元素；而Map接口代表键值对集合，能够存储键和值的关联映射。
// 示例代码：集合接口使用示例
import java.util.*;
public class CollectionInterfaces {
public static void main(String[] args) {
// List集合示例
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
// Set集合示例
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Cherry");
// Map集合示例
Map<String, Integer> map = new HashMap<>();
map.put("One", 1);
map.put("Two", 2);
}
}
集合接口之间的关系和实现类构成了集合框架的基础，了解它们之间的关系对于高效使用Java集合至关重要。例如，了解ArrayList和LinkedList的不同之处以及如何根据需要选择合适的实现。
4.1.2 集合框架的实现类特点
Java集合框架提供了多个实现类，每个类都有其特定的用途和特点。例如，ArrayList提供基于数组的动态数组实现，而LinkedList提供双向链表实现。HashMap基于哈希表实现，而TreeMap基于红黑树实现，保证键的排序。
// 示例代码：比较ArrayList和LinkedList
List<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
// ArrayList使用数组存储，适合快速随机访问，但是中间插入和删除成本较高。
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
// LinkedList使用链表存储，适合在列表中间进行插入和删除操作，但随机访问性能较ArrayList差。
理解不同集合类的内部数据结构和算法是进行性能优化和选择合适集合类的关键。根据具体需求，选择恰当的集合类型可以显著提升性能。
4.2 集合操作进阶
4.2.1 Map、Set、List的高级用法
集合的高级用法包括使用Java 8引入的流API进行高效的数据处理。Map可以使用computeIfAbsent等方法进行高级键值映射操作。Set接口的子接口NavigableSet提供了有序集合的操作，如floor、ceiling等。List接口的subList等方法可以高效地处理子列表。
// 示例代码：使用Map的computeIfAbsent方法
Map<String, List<String>> map = new HashMap<>();
List<String> list = ***puteIfAbsent("fruit", k -> new ArrayList<>());
list.add("Apple");
// computeIfAbsent方法会检查Map中是否存在键"fruit"，不存在则使用提供的函数创建一个新***List并关联"fruit"键。
// 示例代码：使用NavigableSet进行高级操作
NavigableSet<String> sortedSet = new TreeSet<>();
sortedSet.add("Banana");
sortedSet.add("Apple");
String lower = sortedSet.lower("Apple");
// 使用lower方法获取"Apple"在集合中的前一个元素，即"Banana"。
高级用法还包括自定义比较器（Comparator），允许开发者根据特定逻辑对集合元素进行排序。这些用法在处理复杂数据集合时非常有用。
4.2.2 迭代器与泛型
迭代器模式提供了一种访问集合元素的方式，通过这种方式可以在不暴露集合内部细节的情况下，遍历集合中的所有元素。Java的集合框架广泛使用了迭代器模式。
// 示例代码：使用迭代器遍历List
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
泛型是集合框架中使用的关键特性，它提供了在编译时进行类型检查的能力。泛型可以应用于集合类和方法，以创建类型安全的集合。
// 示例代码：使用泛型创建List
List<String> stringList = new ArrayList<>();
// 不允许添加非String类型的对象，否则编译器将报错。
理解迭代器和泛型，可以帮助开发者安全高效地遍历和操作集合数据。
4.3 集合性能优化技巧
4.3.1 集合的选择标准
选择合适的集合类是性能优化的关键。如果需要频繁地对集合进行随机访问，ArrayList可能是更好的选择；而对于频繁的插入和删除操作，LinkedList可能更合适。对于需要键值映射的场景，HashMap通常是首选项，但如果需要有序映射，可以选择TreeMap。
// 示例代码：根据需求选择合适的List实现
List<String> randomAccessList = new ArrayList<>();
List<String> linkedList = new LinkedList<>();
Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();
选择集合类时，应考虑集合操作的频率和类型，以及预期的集合大小，这样可以做出更合适的决策。
4.3.2 集合框架中的算法效率
Java集合框架中的集合类使用了多种高效的算法来处理数据。了解这些算法对于优化集合性能至关重要。例如，HashMap的get和put方法的时间复杂度接近O(1)，这使得它们在处理大量键值对时非常高效。同样，TreeMap内部使用红黑树来维护键的排序，时间复杂度为O(log n)。
// 示例代码：使用HashMap的高效算法
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("One", 1);
hashMap.put("Two", 2);
int value = hashMap.get("One");
// HashMap的get和put操作依赖于键的哈希码，通常具有很高的效率。
当需要执行更复杂的集合操作，如排序或搜索时，应考虑使用集合框架提供的辅助方法，比如Collections.sort()或Collections.binarySearch()，这些方法内部使用了最优化的算法。
通过了解和运用集合框架中的算法效率，开发者可以编写出更高效、性能更优的代码。
5. Java高级主题深入
5.1 线程与并发编程
5.1.1 线程的生命周期和状态
在Java中，线程的生命周期可以分为五个主要状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Terminated）。创建一个新线程后，线程处于新建状态。一旦调用start()方法，线程就进入就绪状态，等待JVM线程调度器的调度。当线程获得CPU时间片后，它进入运行状态。如果线程因为某种原因放弃CPU，它将再次回到就绪状态。线程在执行过程中可能会因为调用sleep()、wait()或被I/O阻塞而进入阻塞状态，在阻塞结束后，线程重新进入就绪状态。线程执行完run()方法后，或者因为异常退出run()方法后，线程将进入死亡状态。
public class ThreadStateDemo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
System.out.println("线程状态: " + Thread.currentThread().getState());
});
System.out.println("线程状态: " + thread.getState());
thread.start();
Thread.sleep(1000);
System.out.println("线程状态: " + thread.getState());
thread.join();
System.out.println("线程状态: " + thread.getState());
}
}
5.1.2 同步机制与锁的应用
同步是Java中实现线程安全的重要机制。通过synchronized关键字，可以确保同一时刻只有一个线程可以执行某个方法或代码块。Java中的锁分为内部锁和显式锁。内部锁就是synchronized，显式锁则通过java.util.concurrent.locks包下的Lock接口实现。
public class SynchronizedDemo {
public synchronized void synchronizedMethod() {
System.out.println("线程名: " + Thread.currentThread().getName() + ", 执行同步方法。");
}
public static void main(String[] args) {
SynchronizedDemo demo = new SynchronizedDemo();
Thread thread1 = new Thread(demo::synchronizedMethod);
Thread thread2 = new Thread(demo::synchronizedMethod);
thread1.start();
thread2.start();
}
}
5.2 I/O流操作知识
5.2.1 字节流与字符流的区别
Java I/O流分为字节流和字符流。字节流主要操作数据为8位的字节，例如音频、视频文件；字符流主要操作字符数据，例如文本文件。字节流读写的是原始数据，字符流读写的是经过编码转换后的数据。
import java.io.*;
public class StreamsDemo {
public static void main(String[] args) throws IOException {
byte[] bytes = "Hello, byte stream!".getBytes();
char[] chars = "Hello, char stream!".toCharArray();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
CharArrayReader charArrayReader = new CharArrayReader(chars);
int b;
while ((b = byteArrayInputStream.read()) != -1) {
System.out.print((char) b);
}
System.out.println();
int c;
while ((c = charArrayReader.read()) != -1) {
System.out.print((char) c);
}
}
}
5.2.2 输入输出流的高级操作
Java I/O流支持多种高级操作，例如缓冲区的使用、随机访问文件、流的合并与分割等。这些操作让I/O流更加灵活高效。
import java.io.*;
public class AdvancedStreamsDemo {
public static void main(String[] args) throws IOException {
String[] lines = {"First line\n", "Second line\n", "Third line\n"};
StringBuilder sb = new StringBuilder();
for (String line : lines) {
sb.append(line);
}
String contents = sb.toString();
// 将字符串内容写入到文件
try (FileOutputStream out = new FileOutputStream("example.txt");
OutputStreamWriter writer = new OutputStreamWriter(out)) {
writer.write(contents);
}
// 从文件中读取内容
try (FileInputStream fis = new FileInputStream("example.txt");
InputStreamReader isr = new InputStreamReader(fis)) {
int c;
while ((c = isr.read()) != -1) {
System.out.print((char) c);
}
}
}
}
5.3 Java标准库类和接口使用
5.3.1 标准库中常见类的深入应用
Java标准库中提供了大量的类和接口，如java.lang.String、java.util.List、java.util.Map等。深入理解这些类的特性，可以使我们编写更加高效、安全、易于维护的代码。
import java.util.*;
public class CollectionsDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("is");
list.add("Powerful");
list.add("!");
Collections.sort(list);
System.out.println(list);
}
}
5.3.2 接口在Java标准库中的使用案例
Java标准库中的接口通常定义了一组行为规范，允许不同类实现同一接口，从而具有相同的功能。例如，Comparable和Comparator接口是用于比较对象的典型例子。
import java.util.*;
class Student implements Comparable<Student> {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Student other) {
***pare(this.age, other.age);
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
public class ComparableDemo {
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
students.add(new Student("Alice", 20));
students.add(new Student("Bob", 18));
students.add(new Student("Charlie", 22));
Collections.sort(students);
System.out.println(students);
}
}
5.4 图形用户界面（GUI）开发
5.4.1 Swing和JavaFX的选择
Swing是Java的一个GUI工具包，它使用了AWT中的本地GUI组件，而JavaFX是Java的最新GUI平台，提供了更丰富的API和更好的性能。
import javax.swing.*;
public class SwingDemo {
public static void main(String[] args) {
JFrame frame = new JFrame("Swing Demo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 200);
frame.setVisible(true);
}
}
5.4.2 事件处理机制与GUI布局管理
Java的GUI事件处理机制基于观察者模式，通过添加事件监听器来响应用户的操作。布局管理器则负责组件在容器中的位置与尺寸管理。
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class EventDemo extends JFrame {
private JButton button;
private JLabel label;
public EventDemo() {
super("Event Demo");
setLayout(new FlowLayout());
button = new JButton("Click me");
label = new JLabel("Button not clicked");
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
label.setText("Button clicked");
}
});
add(button);
add(label);
pack();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
EventDemo eventDemo = new EventDemo();
eventDemo.setVisible(true);
}
}
5.5 数据库连接实现
5.5.1 JDBC API的使用步骤与原理
JDBC（Java Database Connectivity）API是Java语言中用于执行SQL语句的接口。通过JDBC，Java程序可以与多种数据库进行交互。
import java.sql.*;
public class JdbcDemo {
public static void main(String[] args) {
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
// 加载数据库驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 建立数据库连接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "username", "password");
// 创建Statement对象
statement = connection.createStatement();
// 执行查询语句
resultSet = statement.executeQuery("SELECT * FROM users");
// 处理结果集
while (resultSet.next()) {
System.out.println(resultSet.getInt("id") + ", " + resultSet.getString("name"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭资源
try {
if (resultSet != null) resultSet.close();
if (statement != null) statement.close();
if (connection != null) connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
5.5.2 连接池技术与事务管理
连接池是一种对象池，在数据库连接频繁使用且创建成本高的情况下，可以提高性能。事务管理确保了数据库操作的原子性、一致性、隔离性和持久性。
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class ConnectionPoolDemo {
public static void main(String[] args) {
DataSource dataSource = ...; // 获取DataSource实例
Connection connection = null;
try {
connection = dataSource.getConnection();
// 使用connection执行数据库操作
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
5.6 JavaMail API应用
5.6.1 配置和发送电子邮件
JavaMail API为Java应用程序提供了一种发送电子邮件的方式。通过简单的配置和编码，可以实现邮件的发送功能。
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Properties;
public class JavaMailDemo {
public static void main(String[] args) {
Properties properties = new Properties();
properties.put("mail.smtp.host", "***");
properties.put("mail.smtp.port", "587");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.starttls.enable", "true");
Session session = Session.getInstance(properties, new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("***", "password");
}
});
try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress("***"));
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse("***"));
message.setSubject("Test Email from JavaMail");
message.setText("Hello, this is a test email from JavaMail API.");
Transport.send(message);
System.out.println("Email sent successfully.");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}
5.6.2 处理邮件附件与多部分内容
在邮件中添加附件和多部分内容，可以增强邮件的实用性。JavaMail API提供了操作附件和多部分内容的API。
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Properties;
public class JavaMailAttachmentDemo {
public static void main(String[] args) {
Properties properties = new Properties();
// ...（配置属性同上）
Session session = Session.getInstance(properties);
try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress("***"));
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse("***"));
message.setSubject("Test Email with Attachment from JavaMail");
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setContent("This is an attachment test message.", "text/plain");
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
// 添加附件
BodyPart attachment = new MimeBodyPart();
DataSource source = new FileDataSource("path/to/attachment.txt");
attachment.setDataHandler(new DataHandler(source));
attachment.setFileName("attachment.txt");
multipart.addBodyPart(attachment);
message.setContent(multipart);
Transport.send(message);
System.out.println("Email with attachment sent successfully.");
} catch (MessagingException e) {
throw new RuntimeException(e);
}
}
}
以上是针对Java高级主题深入章节的详细介绍。接下来的章节中，我们将继续探讨Java在企业级应用开发中的其他高级应用，如网络编程、多线程与并发处理等。
简介：清华大学提供的Java教程是一份旨在帮助初学者及有经验开发者深入理解Java的全面学习资源。教程包含实例和实际操作练习，涵盖Java基础语法、面向对象编程（OOP）核心概念、异常处理、集合框架、线程与并发处理、I/O流和Java标准库的使用。通过这份教程，学生可以学习Java编程语言的各个方面，并提升开发更复杂Java系统的能力。