java学习笔记

目录

第 1 章: Java 语言概述

1.1 Java 的历史与发展

• 略

1.2 Java 的特点

• 略

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

• 略

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

• 略

1.5 Java 程序的基本结构

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

• 包声明：定义类所属的包。

  package com.example.myapp;
  

• 导入声明：导入需要使用的外部类。

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

• 类声明：定义Java类。

  public class HelloWorld {
      // 类体
  }
  

• 主方法：程序的入口方法。

  public static void main(String[] args) {
      // 主方法体
  }
  

• 成员变量：类的属性。

  private String message;
  

• 构造方法：初始化对象。

  public HelloWorld(String message) {
      this.message = message;
  }
  

• 成员方法：类的行为。

  public void printMessage() {
      System.out.println(message);
  }
  

完整示例

package com.example.myapp;

import java.util.List;
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

    double d = 9.78;
    int i = (int) d; // i 的值为 9
    

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

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

• 算术运算符：
  • + 加法; - 减法; * 乘法; / 除法; % 取余;
• 关系运算符：
  • == 等于; != 不等于; > 大于; < 小于; >= 大于等于; <= 小于等于;
• 逻辑运算符：
  • && 逻辑与; || 逻辑或; ! 逻辑非;
• 位运算符：
  • & 按位与; | 按位或; ^ 按位异或; ~ 按位非; << 左移; >> 右移; >>> 无符号右移
• 赋值运算符：
  • = 赋值; += 加并赋值; -= 减并赋值; *= 乘并赋值; /= 除并赋值; %= 取余并赋值

2.4 表达式和语句

• 略

第 3 章: 控制流程语句

3.1 顺序结构

顺序结构是程序最基本的控制结构。

程序中的语句按照它们在源代码中的顺序依次执行。

所有流程控制语句的默认执行方式都是顺序结构。

3.2 选择结构（if - else、switch - case）

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

• if - else 语句：

  if (condition) {
      // 当条件为 true 时执行
  } else {
      // 当条件为 false 时执行
  }
  

• switch - case 语句：

  int day = 3;
  switch (day) {
      case 1:
          System.out.println("Monday");
          break;
      case 2:
          System.out.println("Tuesday");
          break;
      case 3:
          System.out.println("Wednesday");
          break;
      // 可以有任意数量的 case 语句
      default:
          System.out.println("Invalid day");
          break;
  }
  

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

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

• for 循环：

  for (int i = 0; i < 10; i++) {
      System.out.println(i);
  }
  

• while 循环：

  int i = 0;
  while (i < 10) {
      System.out.println(i);
      i++;
  }
  

• do - while 循环：

  int i = 0;
  do {
      System.out.println(i);
      i++;
  } while (i < 10);
  

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

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

• break：跳出当前循环或 switch 语句。

  for (int i = 0; i < 10; i++) {
      if (i == 5) {
          break; // 结束循环
      }
      System.out.println(i);
  }
  

• continue：跳过当前循环的剩余语句并进入下一次循环。

  for (int i = 0; i < 10; i++) {
      if (i == 5) {
          continue; // 跳过剩余语句，继续下一次循环
      }
      System.out.println(i);
  }
  

• return：结束当前方法并返回一个值（如果方法的返回类型不是 void）。

  public int add(int a, int b) {
      return a + b; // 返回 a 和 b 的和
  }
  

第 4 章: 数组

4.1 数组的概念与定义

数组是用于存储相同类型数据的集合。它使用一个单一变量名，通过索引来访问具体的元素。数组在内存中是连续存储的，每个元素占用相同的存储空间。

4.2 一维数组的初始化与访问

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

• 静态初始化：

  int[] numbers = {1, 2, 3, 4, 5};
  

• 动态初始化：

  int[] numbers = new int[5]; // 创建一个长度为5的数组，默认值为0
  numbers[0] = 1;
  numbers[1] = 2;
  // 依次类推
  

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

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

4.3 二维数组及多维数组

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

• 初始化二维数组：

  int[][] matrix = {
      {1, 2, 3},
      {4, 5, 6},
      {7, 8, 9}
  };
  // 或者
  int[][] matrix = new int[3][3]; // 创建一个3x3的矩阵
  matrix[0][0] = 1;
  matrix[0][1] = 2;
  // 依次类推
  

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

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

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

• 排序：可以使用 Arrays.sort() 方法对数组进行排序。

  int[] numbers = {5, 3, 8, 1, 2};
  Arrays.sort(numbers); // 对数组进行排序
  

• 查找：可以使用 Arrays.binarySearch() 方法在排序后的数组中查找元素的位置。

  int index = Arrays.binarySearch(numbers, 3); // 查找元素3的位置
  

第 5 章: 类与对象

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

面向对象编程（OOP）是一种编程范式，它将程序设计任务分解为一组相互协作的对象。每个对象都是类的实例，类定义了对象的属性和行为。OOP的四大基本原则是：封装、继承、多态和抽象。

5.2 类的定义（成员变量、成员方法）

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

• 成员变量：用于存储对象的属性。

  public class Person {
      String name;
      int age;
  }
  

• 成员方法：用于定义对象的行为。

  public class Person {
      String name;
      int age;
      
      void introduce() {
          System.out.println("Hello, my name is " + name);
      }
  }
  

5.3 对象的创建与使用

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

Person person = new Person();
person.name = "Alice";
person.age = 30;
person.introduce();

5.4 构造方法

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

public class Person {
    String name;
    int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

使用构造方法创建对象：

Person person = new Person("Alice", 30

5.5 this 关键字

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

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

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

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

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

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

示例：

public class Person {
    private String name; // 私有成员变量
    protected int age;   // 受保护成员变量
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

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

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

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

示例：

public class Animal {
    public void eat() {
        System.out.println("This animal eats food");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("This dog eats bones");
    }
}

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

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

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

示例：

public class MathOperation {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

Animal myDog = new Dog();
myDog.eat(); // 调用 Dog 类的 eat 方法

6.4 抽象类与抽象方法

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

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

示例：

public abstract class Animal {
    public abstract void makeSound(); // 抽象方法
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

6.5 接口（interface）

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

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

示例：

public interface Animal {
    void eat();
    void sleep();
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eats");
    }

    @Override
    public void sleep() {
        System.out.println("Dog sleeps");
    }
}

第 7 章: 异常处理

7.1 异常的概念与分类

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

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

7.2 异常处理机制（try - catch - finally）

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

• try 块：包含可能发生异常的代码。
• catch 块：捕获并处理异常。
• finally 块：无论是否发生异常，都会执行的代码块。常用于释放资源。

示例：

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

7.3 自定义异常

有时，需要创建自定义异常来表示特定的错误情况。可以通过继承 Exception 类或 RuntimeException 类来实现。

示例：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// 使用自定义异常
public class Main {
    public static void main(String[] args) {
        try {
            throw new CustomException("This is a custom exception");
        } catch (CustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

7.4 异常处理的最佳实践

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

第 8 章: 字符串处理

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

• 创建字符串：

  String str1 = "Hello";
  String str2 = new String("World");
  

• 连接字符串：

  String str3 = str1 + " " + str2; // 使用 + 号
  String str4 = str1.concat(" ").concat(str2); // 使用 concat 方法
  

• 比较字符串：

  boolean isEqual = str1.equals(str2); // 内容比较
  int compareResult = str1.compareTo(str2); // 按字典顺序比较
  

8.2 StringBuffer 和 StringBuilder 类

• StringBuffer：线程安全，适用于多线程操作的字符串缓冲区。

  StringBuffer sb = new StringBuffer("Hello");
  sb.append(" World");
  

• StringBuilder：非线程安全，但性能较高，适用于单线程操作的字符串缓冲区。

  StringBuilder sb = new StringBuilder("Hello");
  sb.append(" World");
  

8.3 字符串的格式化输出

• 使用 String.format() 方法：

  String formattedString = String.format("My name is %s and I am %d years old.", "Alice", 25);
  

• 使用 System.out.printf() 方法：

  System.out.printf("My name is %s and I am %d years old.%n", "Alice", 25);
  

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

• 获取字符串长度：

  int length = str1.length();
  

• 字符串转小写或大写：

  String lowerCaseStr = str1.toLowerCase();
  String upperCaseStr = str2.toUpperCase();
  

• 去除字符串两端的空格：

  String trimmedStr = str1.trim();
  

• 获取子字符串：

  String subStr = str1.substring(1, 3); // 从索引1开始到索引3（不包括）
  

• 字符串替换：

  String replacedStr = str1.replace("H", "J"); // 替换所有出现的字符
  

• 字符串拆分：

  String[] words = str3.split(" "); // 根据空格拆分字符串
  

• 检查字符串是否包含某子字符串：

  boolean contains = str1.contains("He");
  

第 9 章: 集合框架

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

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

9.2 List 接口（ArrayList、LinkedList）

ArrayList：

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

示例：

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

LinkedList：

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

示例：

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

9.3 Set 接口（HashSet、TreeSet）

HashSet：

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

示例：

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

TreeSet：

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

示例：

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

9.4 Map 接口（HashMap、TreeMap）

HashMap：

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

示例：

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

TreeMap：

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

示例：

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

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

迭代器：

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

示例：

List<String> list = new ArrayList<>();
list.add("Element1");
list.add("Element2");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

增强 for 循环：

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

示例：

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

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

10.1 I/O 流的概念与分类

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

• 按数据处理方式分类：
  • 输入流：从数据源读取数据。
  • 输出流：向数据目标写入数据。
• 按数据类型分类：
  • 字节流：处理字节数据（8位）。
  • 字符流：处理字符数据（16位）。

10.2 字节流（InputStream、OutputStream）

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

• InputStream：字节输入流的抽象基类，表示从数据源读取字节的类。

  FileInputStream fis = new FileInputStream("input.txt");
  int data = fis.read();
  while (data != -1) {
      System.out.print((char) data);
      data = fis.read();
  }
  fis.close();
  

• OutputStream：字节输出流的抽象基类，表示向数据目标写入字节的类。

  FileOutputStream fos = new FileOutputStream("output.txt");
  String str = "Hello, World!";
  fos.write(str.getBytes());
  fos.close();
  

10.3 字符流（Reader、Writer）

字符流用于处理文本数据（如文本文件）。

• Reader：字符输入流的抽象基类，表示从数据源读取字符的类。

  FileReader fr = new FileReader("input.txt");
  int data = fr.read();
  while (data != -1) {
      System.out.print((char) data);
      data = fr.read();
  }
  fr.close();
  

• Writer：字符输出流的抽象基类，表示向数据目标写入字符的类。

  FileWriter fw = new FileWriter("output.txt");
  String str = "Hello, World!";
  fw.write(str);
  fw.close();
  

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

文件读取：

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

文件写入：

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

文件复制：

FileInputStream fis = new FileInputStream("input.txt");
FileOutputStream fos = new FileOutputStream("output.txt");
byte[] buffer = new byte[1024];
int length;
while ((length = fis.read(buffer)) > 0) {
    fos.write(buffer, 0, length);
}
fis.close();
fos.close();

10.5 缓冲流和对象流

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

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

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

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
oos.writeObject(new Person("Alice", 30));
oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
Person person = (Person) ois.readObject();
ois.close();

第 11 章: 多线程编程

11.1 线程的基本概念

线程是程序中的一个单独执行路径。多线程编程允许程序同时执行多个操作，提高程序的并发性和性能。

11.2 线程的创建（继承 Thread 类、实现 Runnable 接口）

继承 Thread 类：

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

MyThread t1 = new MyThread();
t1.start();

实现 Runnable 接口：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
}

Thread t2 = new Thread(new MyRunnable());
t2.start();

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

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

• 新建：线程对象被创建。
• 就绪：线程被调度器选中，准备运行。
• 运行：线程正在执行任务。
• 阻塞：线程被阻塞，等待资源。
• 等待：线程等待另一线程通知或中断。
• 计时等待：线程等待一定时间后自动恢复。
• 终止：线程执行完毕或被终止。

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

synchronized 关键字：

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
}

Lock 接口：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

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

线程间通信用于协调多个线程之间的操作。

• wait() 方法：使当前线程等待，直到其他线程调用 notify() 或 notifyAll() 方法。

  synchronized(obj) {
      while (condition) {
          obj.wait();
      }
      // 执行操作
  }
  

• notify() 方法：唤醒在等待该对象监视器上的某个线程。

  synchronized(obj) {
      obj.notify();
  }
  

• notifyAll() 方法：唤醒在等待该对象监视器上的所有线程。

  synchronized(obj) {
      obj.notifyAll();
  }
  

第 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提供的顶层容器，用于创建窗口。

示例：

import javax.swing.JFrame;

public class SimpleWindow {
    public static void main(String[] args) {
        JFrame frame = new JFrame("My First Swing Application");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

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

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

• FlowLayout：组件按添加顺序排列，默认居中对齐。

  frame.setLayout(new FlowLayout());
  

• BorderLayout：将容器分为五个区域（上、下、左、右、中）。

  frame.setLayout(new BorderLayout());
  frame.add(new JButton("North"), BorderLayout.NORTH);
  

• GridLayout：将容器分为均匀的网格。

  frame.setLayout(new GridLayout(2, 2));
  frame.add(new JButton("Button 1"));
  frame.add(new JButton("Button 2"));
  

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

按钮（JButton）：

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

文本框（JTextField）：

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

标签（JLabel）：

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

12.5 事件处理机制（ActionListener 等）

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

• ActionListener：用于处理按钮点击事件。

  button.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
          System.out.println("Button Clicked");
      }
  });
  

示例：

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SimpleGUI {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Simple GUI");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new FlowLayout());

        JButton button = new JButton("Click Me");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button Clicked");
            }
        });

        frame.add(button);
        frame.setVisible(true);
    }
}