java学习笔记

目录

第 1 章: Java 语言概述

1.1 Java 的汗青与发展

• 略
  

1.2 Java 的特点

• 略
  

1.3 Java 的运行环境（JRE）和开发工具包（JDK）

• 略
  

1.4 第一个 Java 程序（Hello World 示例）

• 略
  

1.5 Java 程序的基本结构

Java 程序由以下几个部分组成：

• 包声明：定义类所属的包。
  1. package com.example.myapp;

  复制代码
• 导入声明：导入需要使用的外部类。
  1. import java.util.List;
  2. import java.util.ArrayList;

  复制代码
• 类声明：定义Java类。
  1. public class HelloWorld {
  2.     // 类体
  3. }

  复制代码
• 主方法：程序的入口方法。
  1. public static void main(String[] args) {
  2.     // 主方法体
  3. }

  复制代码
• 成员变量：类的属性。
  1. private String message;

  复制代码
• 构造方法：初始化对象。
  1. public HelloWorld(String message) {
  2.     this.message = message;
  3. }

  复制代码
• 成员方法：类的行为。
  1. public void printMessage() {
  2.     System.out.println(message);
  3. }

  复制代码

完整示例

1. package com.example.myapp;import java.util.List;
2. import java.util.ArrayList;public class HelloWorld {    private String message;    public HelloWorld(String message) {        this.message = message;    }    public void printMessage() {        System.out.println(message);    }    public static void main(String[] args) {        HelloWorld helloWorld = new HelloWorld("Hello, World!");        helloWorld.printMessage();    }}

复制代码

第 2 章: 数据范例与运算符

2.1 基本数据范例（整型、浮点型、字符型、布尔型）

Java 提供了八种基本数据范例，每种数据范例都有特定的用途：

• 整型（整数范例）：
  
  
  
  • byte：8 位有符号整数。范围：-128 到 127。
    
  • short：16 位有符号整数。范围：-32,768 到 32,767。
    
  • int：32 位有符号整数。范围：-2^31 到 2^31-1。
    
  • long：64 位有符号整数。范围：-2^63 到 2^63-1。
    
  
  
• 浮点型（小数范例）：
  
  
  
  • float：32 位单精度浮点数。
    
  • double：64 位双精度浮点数。
    
  
  
• 字符型：
  
  
  
  • char：16 位 Unicode 字符。范围：0 到 65,535。
    
  
  
• 布尔型：
  
  
  
  • boolean：表示两个值：true 或 false。
    
  
  

2.2 数据范例转换（自动范例转换、强制范例转换）

数据范例转换可以分为自动范例转换和强制范例转换：

• 自动范例转换（隐式范例转换）：
  
  
  
  • 由低精度范例向高精度范例的转换。
    
  • 比方：int 可以自动转换为 long，float 可以自动转换为 double。
    
  
  
• 强制范例转换（显式范例转换）：
  
  
  
  • 由高精度范例向低精度范例的转换，需要显式声明。
    
  • 语法：(目的数据范例) 变量/值。
    
  • 比方：double 转换为 int：
    java
    1. double d = 9.78;
    2. int i = (int) d; // i 的值为 9

    复制代码
  
  

2.3 运算符（算术、关系、逻辑、位运算、赋值等运算符）

Java 提供了多种运算符，用于各种计算和逻辑操作：

• 算术运算符：
  
  
  
  • + 加法;  - 减法;  * 乘法;  / 除法;  % 取余;
    
  
  
• 关系运算符：
  
  
  
  • == 即是;  != 不即是;  > 大于;  = 大于即是;  >> 无符号右移
    
  
  
• 赋值运算符：
  
  
  
  • = 赋值;  += 加并赋值;  -= 减并赋值;  *= 乘并赋值;  /= 除并赋值;  %= 取余并赋值
    
  
  

2.4 表达式和语句

• 略
  

第 3 章: 控制流程语句

3.1 顺序结构

顺序结构是程序最基本的控制结构。
程序中的语句按照它们在源代码中的顺序依次执行。
所有流程控制语句的默认执行方式都是顺序结构。
3.2 选择结构（if - else、switch - case）

选择结构用于根据条件的真假来决定程序的执行路径。

• if - else 语句：
  1. if (condition) {
  2.     // 当条件为 true 时执行
  3. } else {
  4.     // 当条件为 false 时执行
  5. }

  复制代码
• switch - case 语句：
  1. int day = 3;
  2. switch (day) {
  3.     case 1:
  4.         System.out.println("Monday");
  5.         break;
  6.     case 2:
  7.         System.out.println("Tuesday");
  8.         break;
  9.     case 3:
  10.         System.out.println("Wednesday");
  11.         break;
  12.     // 可以有任意数量的 case 语句
  13.     default:
  14.         System.out.println("Invalid day");
  15.         break;
  16. }

  复制代码

3.3 循环结构（for、while、do - while）

循环结构用于重复执行一段代码块，直到某个条件为假。

• for 循环：
  1. for (int i = 0; i < 10; i++) {
  2.     System.out.println(i);
  3. }

  复制代码
• while 循环：
  1. int i = 0;
  2. while (i < 10) {
  3.     System.out.println(i);
  4.     i++;
  5. }

  复制代码
• do - while 循环：
  1. int i = 0;
  2. do {
  3.     System.out.println(i);
  4.     i++;
  5. } while (i < 10);

  复制代码

3.4 跳转语句（break、continue、return）

跳转语句用于控制循环的执行流程或退出函数。

• break：跳出当前循环或 switch 语句。
  1. for (int i = 0; i < 10; i++) {
  2.     if (i == 5) {
  3.         break; // 结束循环
  4.     }
  5.     System.out.println(i);
  6. }

  复制代码
• continue：跳过当前循环的剩余语句并进入下一次循环。
  1. for (int i = 0; i < 10; i++) {
  2.     if (i == 5) {
  3.         continue; // 跳过剩余语句，继续下一次循环
  4.     }
  5.     System.out.println(i);
  6. }

  复制代码
• return：结束当前方法并返回一个值（如果方法的返回范例不是 void）。
  1. public int add(int a, int b) {
  2.     return a + b; // 返回 a 和 b 的和
  3. }

  复制代码

第 4 章: 数组

4.1 数组的概念与定义

数组是用于存储相同范例数据的集合。它使用一个单一变量名，通过索引来访问详细的元素。数组在内存中是连续存储的，每个元素占用相同的存储空间。
4.2 一维数组的初始化与访问

一维数组是最简朴的数组范例。它可以通过两种方式进行初始化：

• 静态初始化：
  1. int[] numbers = {1, 2, 3, 4, 5};

  复制代码
• 动态初始化：
  1. int[] numbers = new int[5]; // 创建一个长度为5的数组，默认值为0
  2. numbers[0] = 1;
  3. numbers[1] = 2;
  4. // 依次类推

  复制代码

访问一维数组的元素可以通过索引，索引从0开始。比方：

1. int firstNumber = numbers[0]  //访问第一个元素

复制代码

4.3 二维数组及多维数组

二维数组可以看作是数组的数组。它通常用于表示矩阵或表格数据：

• 初始化二维数组：
  1. int[][] matrix = {
  2.     {1, 2, 3},
  3.     {4, 5, 6},
  4.     {7, 8, 9}
  5. };
  6. // 或者
  7. int[][] matrix = new int[3][3]; // 创建一个3x3的矩阵
  8. matrix[0][0] = 1;
  9. matrix[0][1] = 2;
  10. // 依次类推

  复制代码

访问二维数组的元素也通过索引。比方：

1. int element = matrix[1][2]; // 访问第二行第三列的元素

复制代码

4.4 数组的常见操作（排序、查找等）

• 排序：可以使用 Arrays.sort() 方法对数组进行排序。
  1. int[] numbers = {5, 3, 8, 1, 2};
  2. Arrays.sort(numbers); // 对数组进行排序

  复制代码
• 查找：可以使用 Arrays.binarySearch() 方法在排序后的数组中查找元素的位置。
  1. int index = Arrays.binarySearch(numbers, 3); // 查找元素3的位置

  复制代码

第 5 章: 类与对象

5.1 面向对象编程（OOP）概念引入

面向对象编程（OOP）是一种编程范式，它将程序计划使命分解为一组相互协作的对象。每个对象都是类的实例，类定义了对象的属性和行为。OOP的四大基本原则是：封装、继续、多态和抽象。
5.2 类的定义（成员变量、成员方法）

类是对象的蓝图，它定义了对象的属性（成员变量）和行为（成员方法）。

• 成员变量：用于存储对象的属性。
  1. public class Person {
  2.     String name;
  3.     int age;
  4. }

  复制代码
• 成员方法：用于定义对象的行为。
  1. public class Person {
  2.     String name;
  3.     int age;
  4.    
  5.     void introduce() {
  6.         System.out.println("Hello, my name is " + name);
  7.     }
  8. }

  复制代码

5.3 对象的创建与使用

对象是类的实例，通过 new 关键字创建。

1. Person person = new Person();
2. person.name = "Alice";
3. person.age = 30;
4. person.introduce();

复制代码

5.4 构造方法

构造方法用于初始化对象。它的名称与类名相同，没有返回范例。

1. public class Person {
2.     String name;
3.     int age;
4.    
5.     // 构造方法
6.     public Person(String name, int age) {
7.         this.name = name;
8.         this.age = age;
9.     }
10. }

复制代码

使用构造方法创建对象：

1. Person person = new Person("Alice", 30

复制代码

5.5 this 关键字

this 关键字用于引用当前对象的实例。它常用于区分成员变量和局部变量。

1. public class Person {
2.     String name;
3.    
4.     public Person(String name) {
5.         this.name = name; // 使用 this 来区分成员变量和局部变量
6.     }

复制代码

第 6 章: 封装、继续与多态

6.1 封装（访问控制修饰符: private、protected、public）

封装是面向对象编程的基本原则之一，它通过访问控制修饰符来保护对象的属性和方法。Java 提供了三种访问控制修饰符：

• private：私有，成员只能在类内部访问。
  
• protected：受保护，成员可以在同一个包内或子类中访问。
  
• public：公共，成员可以在任何地方访问。
  

示例：

1. public class Person {
2.     private String name; // 私有成员变量
3.     protected int age;   // 受保护成员变量
4.     public void setName(String name) {
5.         this.name = name;
6.     }
7.     public String getName() {
8.         return name;
9.     }
10. }

复制代码

6.2 继续（extends 关键字、super 关键字、方法重写）

继续允许一个类从另一个类继续属性和方法，从而实现代码重用。

• extends 关键字：用于声明一个类继续自另一个类。
  
• super 关键字：用于调用父类的构造方法或父类的方法。
  
• 方法重写（Override）：子类可以重写父类的方法以提供新的实现。
  

示例：

1. public class Animal {
2.     public void eat() {
3.         System.out.println("This animal eats food");
4.     }
5. }
7. public class Dog extends Animal {
8.     @Override
9.     public void eat() {
10.         System.out.println("This dog eats bones");
11.     }
12. }

复制代码

6.3 多态（方法重载、对象的多态性）

多态性允许一个接口被多种不同范例的对象实现，程序可以动态选择调用哪个方法实现。

• 方法重载（Overloading）：同一类中可以有多个同名方法，但它们的参数列表不同。
  
• 对象的多态性：一个父类的引用可以指向子类对象。
  

示例：

1. public class MathOperation {
2.     public int add(int a, int b) {
3.         return a + b;
4.     }
5.    
6.     public double add(double a, double b) {
7.         return a + b;
8.     }
9. }
11. Animal myDog = new Dog();
12. myDog.eat(); // 调用 Dog 类的 eat 方法

复制代码

6.4 抽象类与抽象方法

抽象类是不能被实例化的类，可以包罗抽象方法，这些方法必须在子类中实现。

• abstract 关键字：用于声明抽象类和抽象方法。
  
• 抽象方法：没有方法体，只在抽象类中声明。
  

示例：

1. public abstract class Animal {
2.     public abstract void makeSound(); // 抽象方法
3. }
5. public class Dog extends Animal {
6.     @Override
7.     public void makeSound() {
8.         System.out.println("Woof");
9.     }
10. }

复制代码

6.5 接口（interface）

接口定义了一组方法，但不包罗实现。类可以实现多个接口，从而支持多继续的特性。

• interface 关键字：用于声明接口。
  
• implements 关键字：用于实现接口。
  

示例：

1. public interface Animal {
2.     void eat();
3.     void sleep();
4. }
6. public class Dog implements Animal {
7.     @Override
8.     public void eat() {
9.         System.out.println("Dog eats");
10.     }
12.     @Override
13.     public void sleep() {
14.         System.out.println("Dog sleeps");
15.     }
16. }

复制代码

第 7 章: 异常处置惩罚

7.1 异常的概念与分类

异常是程序在运行过程中发生的意外事件，通常是由程序错误或外部因素导致的。异常的处置惩罚是确保程序在发生错误时仍能正常运行的重要机制。

• 异常分类：
  
  
  
  • 检查型异常（Checked Exception）：必须在编译时处置惩罚的异常。常见于文件操作、网络通讯等。比方：IOException。
    
  • 非检查型异常（Unchecked Exception）：包罗运行时异常和错误。程序可以不显式处置惩罚此类异常。比方：NullPointerException。
    
  • 错误（Error）：通常是体系级别的问题，程序无法恢复。比方：OutOfMemoryError。
    
  
  

7.2 异常处置惩罚机制（try - catch - finally）

Java提供了 try - catch - finally 结构来处置惩罚异常，确保即使在异常发生时，程序也能继续运行或安全退出。

• try 块：包罗可能发生异常的代码。
  
• catch 块：捕捉并处置惩罚异常。
  
• finally 块：无论是否发生异常，都会执行的代码块。常用于开释资源。
  

示例：

1. try {
2.     // 可能发生异常的代码
3.     int result = 10 / 0;
4. } catch (ArithmeticException e) {
5.     // 处理异常
6.     System.out.println("Cannot divide by zero");
7. } finally {
8.     // 必定执行的代码
9.     System.out.println("This block is always executed");

复制代码

7.3 自定义异常

有时，需要创建自定义异常来表示特定的错误环境。可以通过继续 Exception 类或 RuntimeException 类来实现。
示例：

1. public class CustomException extends Exception {
2.     public CustomException(String message) {
3.         super(message);
4.     }
5. }
7. // 使用自定义异常
8. public class Main {
9.     public static void main(String[] args) {
10.         try {
11.             throw new CustomException("This is a custom exception");
12.         } catch (CustomException e) {
13.             System.out.println(e.getMessage());
14.         }
15.     }
16. }

复制代码

7.4 异常处置惩罚的最佳实践

• 提前捕捉和处置惩罚异常：尽早在异常发生的位置处置惩罚它们。
  
• 提供有用的错误信息：异常信息应包罗足够的信息，资助调试和解决问题。
  
• 制止空捕捉块：捕捉异常后应采取适当的处置惩罚措施，不要忽略异常。
  
• 使用finally块开释资源：确保资源（如文件、数据库毗连）在程序结束时得到开释。
  
• 抛出特定异常：不要使用过于宽泛的异常范例，应尽可能抛出特定的异常范例。
  

第 8 章: 字符串处置惩罚

8.1 String 类的基本操作（创建、毗连、比力等）

• 创建字符串：
  1. String str1 = "Hello";
  2. String str2 = new String("World");

  复制代码
• 毗连字符串：
  1. String str3 = str1 + " " + str2; // 使用 + 号
  2. String str4 = str1.concat(" ").concat(str2); // 使用 concat 方法

  复制代码
• 比力字符串：
  1. boolean isEqual = str1.equals(str2); // 内容比较
  2. int compareResult = str1.compareTo(str2); // 按字典顺序比较

  复制代码

8.2 StringBuffer 和 StringBuilder 类

• StringBuffer：线程安全，实用于多线程操作的字符串缓冲区。
  1. StringBuffer sb = new StringBuffer("Hello");
  2. sb.append(" World");

  复制代码
• StringBuilder：非线程安全，但性能较高，实用于单线程操作的字符串缓冲区。
  1. StringBuilder sb = new StringBuilder("Hello");
  2. sb.append(" World");

  复制代码

8.3 字符串的格式化输出

• 使用 String.format() 方法：
  1. String formattedString = String.format("My name is %s and I am %d years old.", "Alice", 25);

  复制代码
• 使用 System.out.printf() 方法：
  1. System.out.printf("My name is %s and I am %d years old.%n", "Alice", 25);

  复制代码

8.4 字符串相干的常用方法与应用场景

• 获取字符串长度：
  1. int length = str1.length();

  复制代码
• 字符串转小写或大写：
  1. String lowerCaseStr = str1.toLowerCase();
  2. String upperCaseStr = str2.toUpperCase();

  复制代码
• 去除字符串两头的空格：
  1. String trimmedStr = str1.trim();

  复制代码
• 获取子字符串：
  1. String subStr = str1.substring(1, 3); // 从索引1开始到索引3（不包括）

  复制代码
• 字符串替换：
  1. String replacedStr = str1.replace("H", "J"); // 替换所有出现的字符

  复制代码
• 字符串拆分：
  1. String[] words = str3.split(" "); // 根据空格拆分字符串

  复制代码
• 检查字符串是否包罗某子字符串：
  1. boolean contains = str1.contains("He");

  复制代码

第 9 章: 集合框架

9.1 集合框架概述（接口与实现类）

集合框架提供了用于存储和操作数据的标准方法。它包罗多个接口和实现类，主要接口有 List、Set、Map 等，每个接口有多个实现类，如 ArrayList、HashSet、HashMap 等。
9.2 List 接口（ArrayList、LinkedList）

ArrayList：

• 动态数组实现，支持快速随机访问。
  
• 添加和删除元素较慢，因为可能需要移动其他元素。
  

示例：

1. List<String> arrayList = new ArrayList<>();
2. arrayList.add("Element1");
3. arrayList.add("Element2");

复制代码

LinkedList：

• 链表实现，支持快速添加和删除操作。
  
• 随机访问较慢，因为需要从头部或尾部遍历。
  

示例：

1. List<String> linkedList = new LinkedList<>();
2. linkedList.add("Element1");
3. linkedList.add("Element2");

复制代码

9.3 Set 接口（HashSet、TreeSet）

HashSet：

• 基于哈希表的实现，不保证元素的顺序。
  
• 支持快速插入、删除和查找操作。
  

示例：

1. Set<String> hashSet = new HashSet<>();
2. hashSet.add("Element1");
3. hashSet.add("Element2");

复制代码

TreeSet：

• 基于红黑树的实现，保证元素的自然顺序。
  
• 支持有序遍历。
  

示例：

1. Set<String> treeSet = new TreeSet<>();
2. treeSet.add("Element1");
3. treeSet.add("Element2");

复制代码

9.4 Map 接口（HashMap、TreeMap）

HashMap：

• 基于哈希表的实现，键值对存储。
  
• 不保证键的顺序，支持快速插入、删除和查找操作。
  

示例：

1. Map<String, Integer> hashMap = new HashMap<>();
2. hashMap.put("Key1", 1);
3. hashMap.put("Key2", 2);

复制代码

TreeMap：

• 基于红黑树的实现，键值对存储，保证键的自然顺序。
  
• 支持有序遍历。
  

示例：

1. Map<String, Integer> treeMap = new TreeMap<>();
2. treeMap.put("Key1", 1);
3. treeMap.put("Key2", 2);

复制代码

9.5 集合的遍历（迭代器、增强 for 循环等）

迭代器：

• 使用 Iterator 接口遍历集合元素。
  

示例：

1. List<String> list = new ArrayList<>();
2. list.add("Element1");
3. list.add("Element2");
4. Iterator<String> iterator = list.iterator();
5. while (iterator.hasNext()) {
6.     System.out.println(iterator.next());
7. }

复制代码

增强 for 循环：

• 简化了遍历集合的代码。
  

示例：

1. for (String element : list) {
2.     System.out.println(element);
3. }

复制代码

第 10 章: 输入/输出(I/O)流

10.1 I/O 流的概念与分类

I/O（输入/输出）流是Java中处置惩罚读写数据的机制，主要用于文件操作、网络通讯等场景。I/O流按照数据处置惩罚方式和数据范例分类：

• 按数据处置惩罚方式分类：
  
  
  
  • 输入流：从数据源读取数据。
    
  • 输出流：向数据目的写入数据。
    
  
  
• 按数据范例分类：
  
  
  
  • 字节流：处置惩罚字节数据（8位）。
    
  • 字符流：处置惩罚字符数据（16位）。
    
  
  

10.2 字节流（InputStream、OutputStream）

字节流用于处置惩罚二进制数据（如图像、音频文件等）。

• InputStream：字节输入流的抽象基类，表示从数据源读取字节的类。
  1. FileInputStream fis = new FileInputStream("input.txt");
  2. int data = fis.read();
  3. while (data != -1) {
  4.     System.out.print((char) data);
  5.     data = fis.read();
  6. }
  7. fis.close();

  复制代码
• OutputStream：字节输出流的抽象基类，表示向数据目的写入字节的类。
  1. FileOutputStream fos = new FileOutputStream("output.txt");
  2. String str = "Hello, World!";
  3. fos.write(str.getBytes());
  4. fos.close();

  复制代码

10.3 字符流（Reader、Writer）

字符流用于处置惩罚文本数据（如文本文件）。

• Reader：字符输入流的抽象基类，表示从数据源读取字符的类。
  1. FileReader fr = new FileReader("input.txt");
  2. int data = fr.read();
  3. while (data != -1) {
  4.     System.out.print((char) data);
  5.     data = fr.read();
  6. }
  7. fr.close();

  复制代码
• Writer：字符输出流的抽象基类，表示向数据目的写入字符的类。
  1. FileWriter fw = new FileWriter("output.txt");
  2. String str = "Hello, World!";
  3. fw.write(str);
  4. fw.close();

  复制代码

10.4 文件操作（文件读取、写入、复制等）

文件读取：

1. BufferedReader br = new BufferedReader(new FileReader("input.txt"));
2. String line;
3. while ((line = br.readLine()) != null) {
4.     System.out.println(line);
5. }
6. br.close();

复制代码

文件写入：

1. BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
2. bw.write("Hello, World!");
3. bw.newLine();
4. bw.write("Goodbye, World!");
5. bw.close();

复制代码

文件复制：

1. FileInputStream fis = new FileInputStream("input.txt");
2. FileOutputStream fos = new FileOutputStream("output.txt");
3. byte[] buffer = new byte[1024];
4. int length;
5. while ((length = fis.read(buffer)) > 0) {
6.     fos.write(buffer, 0, length);
7. }
8. fis.close();
9. fos.close();

复制代码

10.5 缓冲流和对象流

缓冲流：用于进步I/O操作的服从，通过减少直接对物理设备的读写次数来实现。

1. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));
2. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"));

复制代码

对象流：用于读写Java对象，实现对象的序列化和反序列化。

1. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
2. oos.writeObject(new Person("Alice", 30));
3. oos.close();
5. ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
6. Person person = (Person) ois.readObject();
7. ois.close();

复制代码

第 11 章: 多线程编程

11.1 线程的基本概念

线程是程序中的一个单独执行路径。多线程编程允许程序同时执行多个操作，进步程序的并发性和性能。
11.2 线程的创建（继续 Thread 类、实现 Runnable 接口）

继续 Thread 类：

1. public class MyThread extends Thread {
2.     public void run() {
3.         System.out.println("Thread is running");
4.     }
5. }
7. MyThread t1 = new MyThread();
8. t1.start();

复制代码

实现 Runnable 接口：

1. public class MyRunnable implements Runnable {
2.     public void run() {
3.         System.out.println("Thread is running");
4.     }
5. }
7. Thread t2 = new Thread(new MyRunnable());
8. t2.start();

复制代码

11.3 线程的生命周期与状态转换

线程的生命周期包罗以下几种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）、计时等待（Timed Waiting）和停止（Terminated）。

• 新建：线程对象被创建。
  
• 就绪：线程被调理器选中，预备运行。
  
• 运行：线程正在执利用命。
  
• 阻塞：线程被阻塞，等待资源。
  
• 等待：线程等待另一线程通知或停止。
  
• 计时等待：线程等待一定时间后自动恢复。
  
• 停止：线程执行完毕或被停止。
  

11.4 线程同步（synchronized 关键字、Lock 接口）

synchronized 关键字：

1. public class Counter {
2.     private int count = 0;
3.    
4.     public synchronized void increment() {
5.         count++;
6.     }
7. }

复制代码

Lock 接口：

1. import java.util.concurrent.locks.Lock;
2. import java.util.concurrent.locks.ReentrantLock;
4. public class Counter {
5.     private int count = 0;
6.     private Lock lock = new ReentrantLock();
7.    
8.     public void increment() {
9.         lock.lock();
10.         try {
11.             count++;
12.         } finally {
13.             lock.unlock();
14.         }
15.     }
16. }

复制代码

11.5 线程间通讯（wait、notify、notifyAll）

线程间通讯用于和谐多个线程之间的操作。

• wait() 方法：使当前线程等待，直到其他线程调用 notify() 或 notifyAll() 方法。
  1. synchronized(obj) {
  2.     while (condition) {
  3.         obj.wait();
  4.     }
  5.     // 执行操作
  6. }

  复制代码
• notify() 方法：唤醒在等待该对象监视器上的某个线程。
  1. synchronized(obj) {
  2.     obj.notify();
  3. }

  复制代码
• notifyAll() 方法：唤醒在等待该对象监视器上的所有线程。
  1. synchronized(obj) {
  2.     obj.notifyAll();
  3. }

  复制代码

第 12 章: Java 图形用户界面（GUI）编程

12.1 GUI 编程概述（AWT 和 Swing 简介）

AWT（Abstract Window Toolkit）：Java最早的GUI工具包，提供了一些基本的GUI组件，如按钮、文本框等。AWT直接依靠于本地平台的GUI组件，因此具有较好的性能，但其跨平台体现较差。
Swing：基于AWT开发的更先辈的GUI工具包，提供了一套更加丰富的组件，如表格、树、标签等。Swing是纯Java实现的，具有精良的跨平台兼容性，并提供了更多的外貌和感觉。
12.2 简朴的窗口创建（JFrame）

JFrame 是Swing提供的顶层容器，用于创建窗口。
示例：

1. import javax.swing.JFrame;
3. public class SimpleWindow {
4.     public static void main(String[] args) {
5.         JFrame frame = new JFrame("My First Swing Application");
6.         frame.setSize(400, 300);
7.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
8.         frame.setVisible(true);
9.     }
10. }

复制代码

12.3 布局管理器（FlowLayout、BorderLayout 等）

布局管理器用于管理组件在容器中的布局。

• FlowLayout：组件按添加顺序排列，默认居中对齐。
  1. frame.setLayout(new FlowLayout());

  复制代码
• BorderLayout：将容器分为五个地区（上、下、左、右、中）。
  1. frame.setLayout(new BorderLayout());
  2. frame.add(new JButton("North"), BorderLayout.NORTH);

  复制代码
• GridLayout：将容器分为均匀的网格。
  1. frame.setLayout(new GridLayout(2, 2));
  2. frame.add(new JButton("Button 1"));
  3. frame.add(new JButton("Button 2"));

  复制代码

12.4 常用组件（按钮、文本框、标签等）

按钮（JButton）：

1. JButton button = new JButton("Click Me");
2. frame.add(button);

复制代码

文本框（JTextField）：

1. JTextField textField = new JTextField(20);
2. frame.add(textField);

复制代码

标签（JLabel）：

1. JLabel label = new JLabel("This is a label");
2. frame.add(label);

复制代码

12.5 事件处置惩罚机制（ActionListener 等）

事件处置惩罚机制用于响应用户的操作，如点击按钮、输入文本等。

• ActionListener：用于处置惩罚按钮点击事件。
  1. button.addActionListener(new ActionListener() {
  2.     public void actionPerformed(ActionEvent e) {
  3.         System.out.println("Button Clicked");
  4.     }
  5. });

  复制代码

示例：

1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.ActionEvent;
4. import java.awt.event.ActionListener;
6. public class SimpleGUI {
7.     public static void main(String[] args) {
8.         JFrame frame = new JFrame("Simple GUI");
9.         frame.setSize(400, 300);
10.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
11.         frame.setLayout(new FlowLayout());
13.         JButton button = new JButton("Click Me");
14.         button.addActionListener(new ActionListener() {
15.             public void actionPerformed(ActionEvent e) {
16.                 System.out.println("Button Clicked");
17.             }
18.         });
20.         frame.add(button);
21.         frame.setVisible(true);
22.     }
23. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。