Java初学者上机实践教程

懒癌弓箭手起源

于 2024-10-09 15:11:28 发布

阅读量777

点赞数 15

本文链接：https://blog.csdn.net/weixin_42510243/article/details/142799895

版权

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

简介：本教程专为初学Java语言者设计，通过从基础概念到实际应用的广泛内容，帮助初学者提升编程技能，通过实例操作加强理论学习，使他们能够熟练运用Java。教程重点涵盖Java基础、面向对象编程、异常处理、集合框架、IO流、多线程、GUI编程、JDBC及网络编程，帮助学习者理解并应用这些关键技术。 java上机实践指导教程

1. Java基础语法学习

1.1 Java语言特点

Java作为一种面向对象的语言，它具有跨平台、多线程、高性能、健壮和安全等显著特点。它被称为“一次编写，到处运行”的语言，因为它可以在任意安装有Java运行时环境（JRE）的操作系统上执行。

1.2 Java开发环境搭建

Java的开发环境搭建首先需要下载并安装Java Development Kit（JDK），该套件包括运行时环境（JRE）和编译器（javac）。JDK安装后，设置环境变量JAVA_HOME，并将其添加到PATH中，以便可以在任何目录下运行Java命令。

1.3 Java基本数据类型与变量

Java提供了八种基本数据类型，包括四种整型（byte, short, int, long）、两种浮点型（float, double）、一种字符型（char）和一种布尔型（boolean）。变量是程序中最基本的存储单元，它必须有一个类型、一个名字，并且在使用前必须初始化。

// 一个整型变量和一个浮点型变量的声明与初始化示例
int myInt = 10;
double myDouble = 20.5;

在本章中，我们将探讨这些基础概念，并为后续章节的学习打下坚实的基础。通过了解Java的特性和环境配置，以及掌握基本数据类型和变量的使用，我们能够开始编写简单的Java程序。

2. 面向对象编程概念

面向对象编程（Object-Oriented Programming，OOP）是一种通过对象和类来组织代码的编程范式。它不仅仅是一个编程技术，更是一种思想，让程序的设计更加贴近现实世界，易于理解和维护。

2.1 类与对象的关系

在面向对象编程中，类是对象的蓝图，而对象是类的具体实例。理解类与对象的关系是掌握面向对象编程的基础。

2.1.1 类的定义与对象的创建

类是具有相同属性和行为的一组对象的集合。在Java中，类是通过关键字 class 定义的，它包含字段（fields）和方法（methods）。

public class Person {
    // 成员变量
    String name;
    int age;
    // 方法
    public void introduce() {
        System.out.println("My name is " + name + ", and I am " + age + " years old.");
    }
}

// 创建对象
public static void main(String[] args) {
    Person person = new Person(); // 创建Person类的一个实例
    person.name = "Alice"; // 设置属性
    person.age = 30;
    person.introduce(); // 调用方法
}

在上述代码中， Person 类有两个成员变量： name 和 age ，以及一个方法 introduce() 。创建对象 person 时，使用 new Person() 语句分配内存并调用类的构造方法来初始化对象。

2.1.2 成员变量与局部变量的区别

成员变量是在类中定义的变量，它们是类的一部分，每个对象都有自己的成员变量的副本。局部变量是在方法或代码块中定义的变量，它们只在定义它们的方法或代码块中可见。

public class Difference {
    int memberVar = 10; // 成员变量
    public void method() {
        int localVar = 20; // 局部变量
        System.out.println("Member variable: " + memberVar);
        // System.out.println("Local variable: " + localVar); // 局部变量在类的其他地方不可见
    }
}

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 double getBalance() {
        return balance;
    }
}

在上述 BankAccount 类中， balance 成员变量是私有的，外部无法直接访问，只能通过 deposit 和 getBalance 方法间接操作，这就是封装。

2.2.2 继承的原理与限制

继承是子类继承父类的特征和行为的过程，它提供了代码复用的能力，使程序更加模块化。

class Animal {
    String name;
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

class Cat extends Animal {
    public void meow() {
        System.out.println("Cat meows.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "Kitty";
        cat.eat(); // 继承的方法
        cat.meow(); // 自身的方法
    }
}

在上面的示例中， Cat 类继承自 Animal 类，继承了 name 属性和 eat 方法。

2.2.3 多态的表现与应用

多态是指允许不同类的对象对同一消息做出响应。多态可以通过方法重载和方法重写实现。

class Animal {
    void sound() {
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks.");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Cat meows.");
    }
}

public class PolymorphismExample {
    public static void makeAnimalSound(Animal animal) {
        animal.sound();
    }

    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        makeAnimalSound(myDog); // 输出: Dog barks.
        makeAnimalSound(myCat); // 输出: Cat meows.
    }
}

在上面的示例中， Dog 和 Cat 类重写了 Animal 类的 sound 方法。通过 makeAnimalSound 方法，我们传入不同的对象，实现了多态行为。

3. ```

第三章：异常处理技巧

异常处理是Java语言的一个重要组成部分，它允许程序在出现错误时，可以优雅地处理错误并继续运行，或者提供错误信息给最终用户。本章深入探讨Java异常处理机制，分析其层次结构，以及如何自定义异常处理和异常处理的高级用法。

3.1 异常类的层次结构

3.1.1 常见异常类介绍

Java中的异常分为两大类：检查型异常（checked exceptions）和非检查型异常（unchecked exceptions）。检查型异常是在编译时期就必须处理的异常，如 IOException 。非检查型异常包括运行时异常（如 NullPointerException ）和错误（如 OutOfMemoryError ）。所有的异常类都继承自 java.lang.Throwable 类，其子类 Exception 和 Error 分别代表了检查型异常和错误。

3.1.2 异常处理机制

Java的异常处理通过 try , catch , finally 和 throw 关键字实现。 try 块内代码若发生异常，则 catch 块会捕获并处理。 finally 块用于执行清理工作，无论是否发生异常都会执行。 throw 关键字用于显式地抛出一个异常实例。

3.2 异常捕获与自定义异常

3.2.1 try-catch-finally的使用

代码示例：

try {
    // 可能产生异常的代码
} catch (ExceptionType name) {
    // 异常处理代码
} finally {
    // 清理代码，总是执行
}

这个结构确保了异常发生时，程序不会意外终止，而是进入一个预定的异常处理流程。 catch 块根据不同的 ExceptionType 捕获不同的异常。

3.2.2 自定义异常类的创建和使用

自定义异常类是继承自 Exception 或其子类的类。创建自定义异常类有助于提供更具体的错误信息和处理方式。自定义异常通常包含构造方法，能接受参数，用于初始化异常对象的状态。

代码示例：

public class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
    // 可以添加其他方法和构造函数
}

// 使用自定义异常
try {
    throw new MyException("This is a custom exception message.");
} catch (MyException e) {
    System.out.println("Caught the custom exception: " + e.getMessage());
}

3.3 异常处理的高级用法

3.3.1 throws和throw的使用场景

throws 关键字用于方法签名上，声明该方法可能抛出的异常类型。这是检查型异常处理的一种方式，要求调用者必须处理或再次声明这些异常。

public void myMethod() throws CustomException {
    // ...
}

throw 则在方法体内抛出一个异常实例。使用 throw 抛出异常时，必须在方法签名中使用 throws 声明该异常。

3.3.2 异常链的构造和好处

异常链是通过在一个异常处理程序中捕获一个异常，并抛出一个新异常，同时将原始异常信息作为新异常的“原因”信息。这样做可以在日志中提供更详细的错误上下文，有利于调试和错误追踪。

代码示例：

try {
    // 代码可能发生异常
} catch (IOException e) {
    throw new MyException("A custom error occurred", e);
}

在上述例子中， MyException 是自定义异常，它接收了一个 IOException 作为其构造器参数，这样就创建了异常链。当异常被捕获时，可以使用 getCause() 方法获取原始异常，从而提供更多有用的信息。

通过本章节的介绍，我们了解了异常处理在Java中的重要性，学习了基本的异常类层次结构，并且深入讨论了自定义异常类的创建和使用，以及异常处理的高级技巧。这为编写健壮的Java程序打下了坚实的基础。


# 4. Java集合框架使用

## 4.1 集合框架的基本组成

### 4.1.1 Collection与Map接口

在Java中，Collection接口是集合框架的根接口，所有的单列集合类都实现了这个接口。它提供了添加、删除、获取、遍历集合等基本操作。Map接口则代表了映射表，存储键值对，即一对相关的元素。与Collection不同，Map可以进行快速查找，因为它能够通过键直接找到对应的值。

```java
// 示例代码展示Collection与Map的基本使用
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CollectionAndMapExample {
    public static void main(String[] args) {
        // Collection 示例
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        System.out.println("Collection contains: " + fruits);

        // Map 示例
        Map<String, String> fruitBasket = new HashMap<>();
        fruitBasket.put("Apple", "Red");
        fruitBasket.put("Banana", "Yellow");
        fruitBasket.put("Orange", "Orange");
        System.out.println("Map contains: " + fruitBasket);
    }
}

4.1.2 List、Set与Queue接口的区别

List接口定义了一个有序集合，允许重复元素，可以按照元素的插入顺序进行访问。Set接口定义了一个不允许重复元素的集合，它通常用于对集合元素进行逻辑操作，如并集、交集、差集等。Queue接口则代表了一个先进先出（FIFO）的队列，通常用于实现任务队列。

以下是三种接口的表格比较：

| 特性/接口 | List | Set | Queue | |-------------|----------------|-----------------|-------------------| | 元素顺序 | 有序 | 无序或根据实现 | 先进先出（FIFO） | | 元素唯一性 | 允许重复 | 不允许重复 | 不允许重复 | | 典型实现类 | ArrayList, LinkedList | HashSet, TreeSet | PriorityQueue, LinkedList |

4.2 集合的迭代与排序

4.2.1 迭代器和ListIterator的使用

迭代器（Iterator）是Java集合框架中的一种设计模式，它允许遍历集合中的所有元素，但它不提供对集合元素的随机访问能力。ListIterator是迭代器的一个扩展，用于双向遍历列表和修改列表中的元素。

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        ListIterator<String> iterator = list.listIterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }

        iterator.add("Grapes");
        iterator.previous();
        iterator.set("Grape");
        System.out.println(list);
    }
}

4.2.2 Comparable与Comparator的比较

Comparable接口用于对象的自然排序，也就是说，通过实现Comparable接口，我们可以在类中定义对象排序的方式。Comparator接口用于定义特定的排序规则，当对象的自然排序方式不满足需求时，可以使用Comparator来定义另外的排序规则。

import java.util.Arrays;
import java.util.Collections;
***parator;

public class SortingExample {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 9, 1, 5, 6};

        // 使用Comparable自然排序
        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));

        // 使用Comparator自定义排序
        Arrays.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                ***pareTo(o1); // 降序排序
            }
        });
        System.out.println("Sorted array in reverse: " + Arrays.toString(numbers));
    }
}

4.3 高级集合操作

4.3.1 Java 8 Stream API基础

Java 8 引入了Stream API，它允许以声明式的方式处理集合，能够方便地进行复杂的数据操作。Stream API支持顺序或并行处理，并提供了丰富的操作如filter、map、reduce等。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamAPIExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Orange", "Grapes");

        // 使用Stream API过滤出长度大于6的字符串
        List<String> filteredFruits = fruits.stream()
            .filter(fruit -> fruit.length() > 6)
            .collect(Collectors.toList());

        System.out.println("Filtered fruits: " + filteredFruits);
    }
}

4.3.2 集合的并行处理

Stream API不仅提供了顺序处理数据的方式，还支持并行处理。使用并行流可以显著提高处理大数据集的效率，尤其是在多核处理器上。并行流通过将任务分解到多个处理器核心上并行执行来加速处理过程。

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class ParallelStreamExample {
    public static void main(String[] args) {
        // 使用并行流计算1到100000的平方和
        int sum = IntStream.rangeClosed(1, 100000)
            .parallel()
            .map(n -> n * n)
            .sum();

        System.out.println("Sum of squares using parallel stream: " + sum);
    }
}

并行处理适用于无状态和无副作用的操作，且在大数据集上效率更高。但在使用并行流时，需要考虑线程安全问题，以及避免数据竞争和死锁等问题。

5. 输入输出流操作

5.1 字节流与字符流

5.1.1 InputStream与OutputStream类

在Java中，所有的输入流都继承自抽象类 InputStream ，而所有的输出流都继承自抽象类 OutputStream 。这两个类是处理字节流的核心，它们提供了基础的读取和写入方法，分别对应不同的数据类型和处理模式。

InputStream类

InputStream 是用于读取字节数据的抽象类。它提供了一系列的方法，其中 read() 用于从输入流中读取一个字节， read(byte[] b) 用于从输入流中读取最多 b.length 个字节数据到数组 b 中。此外， InputStream 还提供了 skip(long n) 方法跳过流中的 n 个字节，以及 close() 方法用于关闭输入流。

import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamExample {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("example.txt");
            int data = fileInputStream.read(); // 读取一个字节
            while(data != -1) {
                System.out.print((char) data); // 将字节转换为字符并打印
                data = fileInputStream.read(); // 继续读取下一个字节
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null) {
                    fileInputStream.close(); // 关闭流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在上面的代码中，我们使用 FileInputStream 创建了一个输入流，然后使用 read() 方法逐个字节地读取文件内容，直到读取完毕（返回-1）。字节数据通过强制类型转换被转换为 char 类型，并打印出来。最后，使用 finally 块来确保输入流被关闭。

OutputStream类

OutputStream 是用于输出字节数据的抽象类。它提供了基础的写入方法，如 write(int b) 将指定字节写入输出流，以及 write(byte[] b) 将字节数组写入输出流。此外， OutputStream 还提供了 flush() 方法用来刷新此输出流并强制写出所有缓冲的输出字节，以及 close() 方法用于关闭输出流。

import java.io.OutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamExample {
    public static void main(String[] args) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("output.txt");
            String data = "Hello, World!";
            byte[] bytes = data.getBytes(); // 将字符串转换为字节数组
            fileOutputStream.write(bytes); // 将字节数组写入文件
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close(); // 关闭流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在上面的代码示例中，我们通过 FileOutputStream 创建了一个输出流，将一个字符串转换为字节数组后写入到文件 output.txt 中。同样使用了 try-finally 结构来确保输出流在使用后被正确关闭。

5.1.2 Reader与Writer类

Reader 和 Writer 类是处理字符流的抽象类。它们是用于处理文本数据的，其方法与 InputStream 和 OutputStream 类类似，但它们操作的是16位的 char 类型，而非8位的字节类型。这使得它们更适合处理文本数据。

Reader类

Reader 类用于读取字符数据。它提供的方法，如 read() 用于读取一个字符， read(char[] cbuf) 用于读取最多 cbuf.length 个字符数据到数组 cbuf 中。 Reader 类还支持标记和重置功能，通过 mark(int readlimit) 方法标记当前位置，之后可通过 reset() 方法返回到标记位置。

import java.io.Reader;
import java.io.FileReader;
import java.io.IOException;

public class ReaderExample {
    public static void main(String[] args) {
        Reader fileReader = null;
        try {
            fileReader = new FileReader("example.txt");
            int data = fileReader.read(); // 读取一个字符
            while(data != -1) {
                System.out.print((char) data); // 将字符打印出来
                data = fileReader.read(); // 继续读取下一个字符
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close(); // 关闭流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

上面的代码展示了如何使用 FileReader 来读取一个文本文件。通过 read() 方法逐个字符地读取内容，直到文件末尾。

Writer类

Writer 类用于写入字符数据。它提供了方法，如 write(int c) 用于写入一个字符， write(char[] cbuf) 用于写入一个字符数组，以及 write(String str) 用于写入一个字符串。 Writer 类还有 flush() 方法来刷新输出流，确保所有缓冲的输出字节都被写出。

import java.io.Writer;
import java.io.FileWriter;
import java.io.IOException;

public class WriterExample {
    public static void main(String[] args) {
        Writer fileWriter = null;
        try {
            fileWriter = new FileWriter("output.txt");
            String data = "Hello, World!";
            fileWriter.write(data); // 写入字符串到文件
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null) {
                try {
                    fileWriter.close(); // 关闭流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在上面的示例中，我们使用 FileWriter 类将字符串 "Hello, World!" 写入到文件 output.txt 中。注意，在写入字符数据到文件时，应当关闭 Writer 以释放相关资源。

5.1.3 字节流与字符流的选择

在选择使用字节流还是字符流时，需要根据实际的应用场景来决定。字节流适用于所有类型的数据，包括文本数据和二进制数据。而字符流则专门用于处理文本数据，能够处理字符编码转换的问题，比如将字符串转换为字节序列。

字节流的优势

字节流可用于读写二进制文件，如图片、音频等。
字节流可以精确控制每个字节的读写。

字符流的优势

字符流处理文本数据时更加方便，自动处理了字符编码问题。
字符流通常与缓冲区一起使用，提高了读写效率。

综上所述，在处理文本文件时，字符流提供了一个更为直接和方便的途径，可以减少编码转换的复杂性。而在处理二进制文件时，字节流提供了更高的灵活性和精确性。开发者应根据实际需求选择合适的输入输出流来实现功能。

6. 多线程编程基础

6.1 线程的创建与管理

6.1.1 Thread类与Runnable接口

在Java中，创建多线程主要有两种方式：继承 Thread 类或实现 Runnable 接口。两种方法都能达到创建和管理线程的目的，但选择哪一种依赖于特定的应用场景。

继承 Thread 类是创建线程的传统方式，通过重写 run() 方法定义线程执行的代码。这种方式的缺点是Java不支持多重继承，因此如果一个类已经继承了另一个类，则无法再继承 Thread 类。

class MyThread extends Thread {
    public void run() {
        // 线程任务代码
    }
}

MyThread thread = new MyThread();
thread.start(); // 启动线程

实现 Runnable 接口相对更灵活。接口实现方式允许我们继承其他类（例如 Applet 或 Servlet ），因此可以更好地复用代码。在实现 Runnable 接口时，需要将线程执行的代码放入实现类的 run() 方法中，然后将该实现类的实例传递给 Thread 类的构造函数。

class MyRunnable implements Runnable {
    public void run() {
        // 线程任务代码
    }
}

Thread thread = new Thread(new MyRunnable());
thread.start(); // 启动线程

6.1.2 线程的生命周期和优先级

线程的生命周期包括五个主要状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Terminated）。了解这些状态有助于更好地管理线程。

当线程被创建后，它就处于新建状态。调用 start() 方法后，线程进入就绪状态，等待线程调度器分配CPU资源。一旦获得CPU资源，线程就进入运行状态。如果线程调用了 yield() 方法、由于同步机制被阻塞、执行了睡眠、或者等待用户输入等，它将进入阻塞状态。线程执行完毕后进入死亡状态。

线程优先级是线程调度的重要参数。优先级高的线程得到更多的执行机会，但优先级并不保证线程执行的顺序。Java中线程的优先级范围是1到10，通过 setPriority(int) 方法来设置。

MyThread t = new MyThread();
t.setPriority(Thread.MAX_PRIORITY); // 设置线程优先级为最高

需要注意的是，高优先级的线程会抢占低优先级线程的CPU资源，但这并不意味着低优先级线程永远不会执行。此外，操作系统对线程调度的影响也是存在的。

6.2 线程同步与通信

6.2.1 synchronized关键字的应用

在多线程环境中，多个线程可能会同时访问和修改共享资源，这可能导致数据不一致。为了防止这种冲突，Java提供了 synchronized 关键字，用于实现线程间的同步。

synchronized 可以应用于方法或代码块上。当 synchronized 修饰一个方法时，整个方法为同步方法，调用该方法的线程需要获得对象的锁。如果 synchronized 修饰代码块，则需要指定锁对象。

public class Counter {
    private int count = 0;

    public void increment() {
        synchronized(this) {
            count++;
        }
    }

    public int getCount() {
        synchronized(this) {
            return count;
        }
    }
}

在上面的例子中， increment() 和 getCount() 方法都使用 synchronized 关键字同步。当一个线程调用 increment() 方法时，其他线程不能同时进入这两个方法中任何一个，因为它们共享同一个锁（ this 对象）。

6.2.2 wait/notify机制的使用

synchronized 关键字提供了基本的线程安全支持，但有时我们需要更复杂的线程间协作。这时可以使用 wait() 和 notify() / notifyAll() 方法来实现线程间的通信。

当一个线程调用对象的 wait() 方法时，它必须拥有该对象的锁，然后它会放弃该锁并进入等待状态。直到其他线程调用同一个对象上的 notify() 或 notifyAll() 方法，或者经过指定的超时时间。

public class SharedResource {
    private boolean available = false;

    public synchronized void produce() {
        while (available) {
            try {
                wait(); // 如果资源可用，等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        // 生产资源
        available = true;
        notifyAll(); // 通知所有等待的线程
    }

    public synchronized void consume() {
        while (!available) {
            try {
                wait(); // 如果资源不可用，等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        // 消费资源
        available = false;
        notifyAll(); // 通知所有等待的线程
    }
}

在 SharedResource 类中， produce() 和 consume() 方法使用 wait() 来等待资源的生产或消费。当资源可用时，相应的线程会调用 notifyAll() 来通知所有等待的线程。

6.3 高级多线程技术

6.3.1 线程池的原理与实践

线程池是一种线程管理机制，可以预先创建一定数量的线程，并将任务放入队列中，线程池中的线程会按需从队列中取出任务执行。线程池的好处是可以减少在创建和销毁线程上所花的时间和资源消耗，同时也提高了响应速度。

Java提供了 ExecutorService 和 ThreadPoolExecutor 等类来支持线程池。创建线程池通常使用 Executors 工厂类中的静态方法来实现：

// 使用Executors工厂类创建一个固定大小的线程池
ExecutorService executorService = Executors.newFixedThreadPool(4);

// 提交任务到线程池
executorService.execute(new RunnableTask());

// 关闭线程池并回收资源
executorService.shutdown();

6.3.2 并发工具类的使用

Java并发包 java.util.concurrent 提供了一系列高级并发工具类，用于解决多线程中的各种问题，如 CountDownLatch 、 CyclicBarrier 和 Semaphore 等。

CountDownLatch 可以用于等待一个或多个线程完成某项操作。 CyclicBarrier 用于多个线程相互等待直到所有线程到达某个公共点。 Semaphore 则用于控制同时访问特定资源的线程数量。

// 使用CountDownLatch等待三个线程执行完毕
CountDownLatch latch = new CountDownLatch(3);

for(int i = 0; i < 3; i++) {
    new Thread(() -> {
        // 执行任务
        latch.countDown(); // 完成后通知
    }).start();
}

latch.await(); // 等待所有任务完成

System.out.println("所有任务执行完毕！");

以上便是Java多线程编程基础的详细介绍。理解了这些基础后，可以进一步探索Java并发包中的其他高级工具，并尝试将这些概念应用到实际的项目中。

7. Java GUI开发（Swing或JavaFX）

7.1 基础组件使用

在Java中，图形用户界面（GUI）开发是一个非常重要的方面，而Swing是Java用于GUI开发最常用的库之一。另一个较为现代的选择是JavaFX，它提供了更丰富的界面和更好的性能。在本节中，我们将重点介绍如何使用Swing库来进行GUI开发。

7.1.1 窗口（JFrame）的创建与布局

创建一个基本的窗口（JFrame）是学习Swing的第一步。你可以通过继承 JFrame 类并重写其构造方法来实现这一目标。

import javax.swing.JFrame;

public class SimpleFrameExample extends JFrame {
    public SimpleFrameExample() {
        // 设置窗口标题
        setTitle("Simple Swing Frame");
        // 设置窗口关闭行为
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置窗口大小
        setSize(300, 200);
        // 设置布局管理器
        setLayout(new java.awt.FlowLayout());
        // 添加组件
        add(new javax.swing.JLabel("Hello, Swing!"));
    }

    public static void main(String[] args) {
        // 在事件调度线程中创建和显示GUI
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                SimpleFrameExample frame = new SimpleFrameExample();
                // 显示窗口
                frame.setVisible(true);
            }
        });
    }
}

在上面的代码中，我们创建了一个包含一个 JLabel 组件的 JFrame 窗口。 JFrame 的构造方法设置了窗口的标题、默认关闭操作、大小和布局管理器。之后，我们添加了一个 JLabel 组件到窗口中，并且通过 setVisible 方法来显示窗口。

7.1.2 常用GUI组件介绍

Swing提供了丰富的GUI组件，如按钮( JButton )、文本框( JTextField )、标签( JLabel )、复选框( JCheckBox )等。这些组件都继承自 JComponent 类，允许它们在窗口中进行放置和操作。

下面的代码演示了如何创建一个带有按钮和文本框的简单窗口：

import javax.swing.*;

public class BasicComponentsExample extends JFrame {
    public BasicComponentsExample() {
        setTitle("Components Example");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(300, 200);
        // 添加一个文本框
        JTextField textField = new JTextField(20);
        add(textField);
        // 添加一个按钮，点击时会触发事件
        JButton button = new JButton("Click Me!");
        add(button);
        // 设置布局管理器为边框布局
        setLayout(new BorderLayout());
        // 将文本框放入内容区域，按钮放入南区域
        add(textField, BorderLayout.CENTER);
        add(button, BorderLayout.SOUTH);
    }

    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new BasicComponentsExample().setVisible(true);
            }
        });
    }
}

在上述例子中，我们使用了 BorderLayout 布局管理器，并且向窗口添加了一个文本框和一个按钮。布局管理器负责管理组件的布局和大小，以适应窗口的大小变化。

GUI组件的创建和布局是Swing库中最基础的部分。在下一节中，我们将讨论如何使用事件监听器来响应用户的操作。

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

简介：本教程专为初学Java语言者设计，通过从基础概念到实际应用的广泛内容，帮助初学者提升编程技能，通过实例操作加强理论学习，使他们能够熟练运用Java。教程重点涵盖Java基础、面向对象编程、异常处理、集合框架、IO流、多线程、GUI编程、JDBC及网络编程，帮助学习者理解并应用这些关键技术。

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