全国计算机java二级考试经验分享网上java二级相关的资料还是太少了，下面是自己考试当时写的的笔记，想着还是分享出来，

网上java二级相关的资料还是太少了，下面是自己考试当时写的的笔记，想着还是分享出来，之前考试的时候写的，值得一提的是考试所用的ide非常弱智，我们考场的老师都不会用，最后当txt写的代码，都没跑着试一下，可能是因为java考的人太少的原因(ﾟ∀ﾟ)

java的知识点是所有二级考试中最多的，除了线程外还会考一个早就被淘汰的gui技术，不过其实答起来很容易，因为操作题其实都是填空样式的，主要是把gui常用的那几个方法背一下，我个人复习了5天就去考了，最后通过了，难度真不大。

推荐题库：java.code2ji.cn

能在线展示实际的gui，这确实是绝无仅有的功能，并且支持手机端写操作题。

在这里插入图片描述

Java 基础语法笔记

1. Java 基本概念

Java 是一种面向对象的编程语言，广泛应用于开发桌面应用、Web应用和Android应用。
Java程序是由类（Class）组成的，每个程序必须有一个入口点，main 方法。

2. Java 程序结构

一个基本的 Java 程序结构如下：

public class HelloWorld {
    public static void main(String[] args) {
        // 这是输出语句
        System.out.println("Hello, World!");
    }
}

说明：

public class HelloWorld：定义一个类，类名通常与文件名相同。
public static void main(String[] args)：main 方法是Java程序的入口点。
System.out.println：用于输出到控制台。

3. 基本数据类型

Java有8种基本数据类型：

类型	描述	默认值
`byte`	8位整数	0
`short`	16位整数	0
`int`	32位整数	0
`long`	64位整数	0L
`float`	单精度浮点数	0.0f
`double`	双精度浮点数	0.0d
`char`	单个字符	'\u0000'
`boolean`	布尔值	`false`

4. 变量声明与赋值

声明和初始化变量：

int x = 10;         // 整型变量
double y = 3.14;    // 双精度浮点型变量
boolean isJava = true;  // 布尔型变量
char grade = 'A';   // 字符型变量

常见操作：

x = 20;             // 变量赋值
int sum = x + 10;   // 变量计算

5. 控制结构

条件语句

Java 使用 if, else if, 和 else 来进行条件判断。

int age = 18;
if (age >= 18) {
    System.out.println("You are an adult.");
} else {
    System.out.println("You are a minor.");
}

循环语句

Java 提供了 for、while 和 do-while 三种循环结构。

`for` 循环：

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

`while` 循环：

int j = 0;
while (j < 5) {
    System.out.println("j = " + j);
    j++;
}

`do-while` 循环：

int k = 0;
do {
    System.out.println("k = " + k);
    k++;
} while (k < 5);

6. 数组

一维数组

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[0]);  // 输出 1

二维数组

int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
System.out.println(matrix[1][2]);  // 输出 6

🔥 真题实战：5×5上三角矩阵题目来源

在这里插入图片描述

来看这道经典的数组操作题：

题目要求： 构造一个5×5的上三角矩阵并输出

public class Main{
   public static void main(String args[]) { 
      int a[][] = new int[5][5];  // 声明5×5二维数组
      int i,j,k = 1;
      for(i=0;i<5;i++)
         for(j=0;j<5;j++)
            if((i+j)<5){          // 上三角条件
               a[i][j] = k;
               k++;               // 递增
               if (k > 9) k = 1;  // 大于9重置为1
            }else
               a[i][j]=0;         // 下三角设为0
      for(i=0;i<5;i++){ 
         for(j=0;j<5;j++)
            System.out.print(a[i][j]+ "   ");
         System.out.println();    // 换行
      }
   }
}

解题思路： 这道题考查二维数组操作和上三角矩阵的构造，需要理解数组索引与矩阵位置的关系。

知识点解析：

二维数组声明：int a[][] = new int[5][5] 创建5×5数组
数组初始化：Java中数组元素自动初始化为0
嵌套循环：外层控制行，内层控制列
条件判断：(i+j)<5 判断是否在上三角区域
循环赋值：k值循环使用1-9，超过9重置为1

算法步骤：

创建5×5二维数组
双重循环遍历所有位置
判断当前位置是否在上三角区域：(i+j)<5
上三角区域赋值递增的k值，下三角区域赋值0
k值超过9时重置为1，实现循环

记忆技巧：

二维数组：a[行][列]，先行后列
上三角：行索引+列索引 < 总行数
System.out.println() 用于换行输出

数组操作常见考点：

二维数组的声明和初始化
嵌套循环遍历数组
矩阵的上下三角区域判断
数组元素的条件赋值

7. 方法（函数）

在 Java 中，方法是由关键字 void 或返回类型来声明的。

方法声明和调用：

public class Main {
    public static void main(String[] args) {
        greet();  // 调用方法
    }

    public static void greet() {
        System.out.println("Hello, Java!");
    }
}

带参数的方法：

public static void greet(String name) {
    System.out.println("Hello, " + name);
}

调用：

greet("Alice");  // 输出: Hello, Alice

8. 面向对象

类与对象

Java 是一种面向对象的编程语言，所有的代码都在类中定义，类是创建对象的蓝图。

class Person {
    String name;
    int age;

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

    // 方法
    public void greet() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Alice", 30);  // 创建对象
        p.greet();  // 调用对象方法
    }
}

继承与多态

Java 支持继承和多态：

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

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

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();  // 输出: Dog barks.
    }
}

9. 常见类库

Java 提供了丰富的标准类库。

`String` 类

String greeting = "Hello, World!";
System.out.println(greeting.length());  // 输出字符串长度
System.out.println(greeting.toUpperCase());  // 转换为大写

`ArrayList`（动态数组）

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list.get(0));  // 输出: Apple

`Scanner`（输入）

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = scanner.nextLine();
System.out.println("Hello, " + name + "!");

从下面开始都是比较深入的部分，也不知道为什么唯独java考这么深，除了线程还要考gui图形界面

异常

public static void main(String[] args) {
    test(1, 0);   //当b为0的时候，还能正常运行吗？
}

private static int test(int a, int b){
    return a/b;   //没有任何的判断而是直接做计算
}

结果会报错：在这里插入图片描述

(我在考试的时候要不直接复制这个报错的信息把，这样就不用记异常类型了，一会去试一下)

异常的类型

我们在之前其实已经接触过一些异常了，比如数组越界异常，空指针异常，算术异常等，他们其实都是异常类型，我们的每一个异常也是一个类，他们都继承自Exception类！异常类型本质依然类的对象，但是异常类型支持在程序运行出现问题时抛出（也就是上面出现的红色报错）也可以提前声明，告知使用者需要处理可能会出现的异常！

异常的第一种类型是运行时异常，如上述的列子，在编译阶段无法感知代码是否会出现问题，只有在运行的时候才知道会不会出错（正常情况下是不会出错的），这样的异常称为运行时异常，异常也是由类定义的，所有的运行时异常都继承自RuntimeException。

如：空指针异常

public static void main(String[] args) {
    Object object = null;
    object.toString();   //这种情况就会出现运行时异常
}

在这里插入图片描述

抛出异常

当别人调用我们的方法时，如果传入了错误的参数导致程序无法正常运行，这时我们就可以手动抛出一个异常来终止程序继续运行下去，同时告知上一级方法执行出现了问题：

public static int test(int a, int b) {
    if(b == 0)
        throw new RuntimeException("被除数不能为0");  //使用throw关键字来抛出异常
    return a / b;
}

异常的抛出同样需要创建一个异常对象出来，我们抛出异常实际上就是将这个异常对象抛出，异常对象携带了我们抛出异常时的一些信息，比如是因为什么原因导致的异常，在RuntimeException的构造方法中我们可以写入原因。

当出现异常时：在这里插入图片描述

程序会终止，并且会打印栈追踪信息，因为各位小伙伴才初学，还不知道什么是栈，我们这里就简单介绍一下，实际上方法之间的调用是有层级关系的，而当异常发生时，方法调用的每一层都会在栈追踪信息中打印出来，比如这里有两个at，实际上就是在告诉我们程序运行到哪个位置时出现的异常，位于最上面的就是发生异常的最核心位置，我们代码的第15行。

并且这里会打印出当前抛出的异常类型和我们刚刚自定义异常信息。

异常的处理

当程序没有按照我们理想的样子运行而出现异常时（默认会交给JVM来处理，JVM发现任何异常都会立即终止程序运行，并在控制台打印栈追踪信息）现在我们希望能够自己处理出现的问题，让程序继续运行下去，就需要对异常进行捕获，比如：

public static void main(String[] args) {
    try {    //使用try-catch语句进行异常捕获
        Object object = null;
        object.toString();
    } catch (NullPointerException e){   //因为异常本身也是一个对象，catch中实际上就是用一个局部变量去接收异常

    }
    System.out.println("程序继续正常运行！");
}

简单来说就是程序在遇到异常的时候会不知道怎么办，一般情况下会自动终止然而你作为伟大的程序员早就料到了这一切，并且要求程序在遇到这个问题的时候不用停止，按照你说的继续做下去

我们将可能出现问题的代码编写到try语句块中，只要是在这个范围内发生的异常，都可以被捕获，使用catch关键字对指定的异常进行捕获，这里我们捕获的是NullPointerException空指针异常

在这里插入图片描述

当代码可能出现多种类型的异常时，我们希望能够分不同情况处理不同类型的异常，就可以使用多重异常捕获：

try {
  //....
} catch (NullPointerException e) {
            
} catch (IndexOutOfBoundsException e){

} catch (RuntimeException e){
            
}

但是要注意一下顺序：

try {
  //....
} catch (RuntimeException e){  //父类型在前，会将子类的也捕获

} catch (NullPointerException e) {   //永远都不会被捕获

} catch (IndexOutOfBoundsException e){   //永远都不会被捕获

}

只不过这样写好像有点丑，我们也可以简写为：

try {
     //....
} catch (NullPointerException | IndexOutOfBoundsException e) {  //用|隔开每种类型即可
		
}

如果简写的话，那么发生这些异常的时候，都会采用统一的方式进行处理了。

最后，当我们希望，程序运行时，无论是否出现异常，都会在最后执行任务，可以交给finally语句块来处理：

try {
    //....
}catch (Exception e){
            
}finally {
  	System.out.println("lbwnb");   //无论是否出现异常，都会在最后执行
}
try语句块至少要配合catch或finally中的一个：

try {
    int a = 10;
    a /= 0;
} finally {  //不捕获异常，程序会终止，但在最后依然会执行下面的内容
    System.out.println("lbwnb"); }

Java I/O

I/O简而言之，就是输入输出，那么为什么会有I/O呢？其实I/O无时无刻都在我们的身边，比如读取硬盘上的文件，网络文件传输，鼠标键盘输入，也可以是接受单片机发回的数据，而能够支持这些操作的设备就是I/O设备。

文件字节流

要学习和使用IO，首先就要从最易于理解的读取文件开始说起。

首先介绍一下FileInputStream，我们可以通过它来获取文件的输入流

public static void main(String[] args) {
    try {   //注意，IO相关操作会有很多影响因素，有可能出现异常，所以需要明确进行处理
        FileInputStream inputStream = new FileInputStream("路径");
        //路径支持相对路径和绝对路径
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
}

在使用完成一个流之后，必须关闭这个流来完成对资源的释放，否则资源会被一直占用：

public static void main(String[] args) {
    FileInputStream inputStream = null;    //定义可以先放在try外部
    try {
        inputStream = new FileInputStream("路径");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        try {    //建议在finally中进行，因为关闭流是任何情况都必须要执行的！
            if(inputStream != null) inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

虽然这样的写法才是最保险的，但是显得过于繁琐了，尤其是finally中再次嵌套了一个try-catch块，因此在JDK1.7新增了try-with-resource语法，用于简化这样的写法（本质上还是和这样的操作一致，只是换了个写法）

public static void main(String[] args) {

    //注意，这种语法只支持实现了AutoCloseable接口的类！
    try(FileInputStream inputStream = new FileInputStream("路径")) {   //直接在try()中定义要在完成之后释放的资源

    } catch (IOException e) {   //这里变成IOException是因为调用close()可能会出现，而FileNotFoundException是继承自IOException的
        e.printStackTrace();
    }
    //无需再编写finally语句块，因为在最后自动帮我们调用了close()
}

之后为了方便，我们都使用此语法进行教学。

现在我们拿到了文件的输入流，那么怎么才能读取文件里面的内容呢？我们可以使用read方法：

public static void main(String[] args) {
    //test.txt里面的内容：a
    try(FileInputStream inputStream = new FileInputStream("test.txt")) {
        //使用read()方法进行字符读取
        System.out.println((char) inputStream.read());  //读取一个字节的数据（英文字母只占1字节，中文占2字节）
        System.out.println(inputStream.read());   //唯一一个字节的内容已经读完了，再次读取返回-1表示没有内容了
    }catch (IOException e){
        e.printStackTrace();
    }
}

使用read可以直接读取一个字节的数据，注意，流的内容是有限的，读取一个少一个。我们如果想一次性全部读取的话，可以直接使用一个while循环来完成：

public static void main(String[] args) {
    //test.txt：abcd
    try(FileInputStream inputStream = new FileInputStream("test.txt")) {
        int tmp;
        while ((tmp = inputStream.read()) != -1){   //通过while循环来一次性读完内容
            System.out.println((char)tmp);
        }
    }catch (IOException e){
        e.printStackTrace();
    }
}

使用available方法能查看当前可读的剩余字节数量（注意：并不一定真实的数据量就是这么多，尤其是在网络I/O操作时，这个方法只能进行一个预估也可以说是暂时能一次性可以读取的数量，当然在磁盘IO下，一般情况都是真实的数据量）

try(FileInputStream inputStream = new FileInputStream("test.txt")) {
    System.out.println(inputStream.available());  //查看剩余数量
}catch (IOException e){
    e.printStackTrace();
}

当然，一个一个读取效率太低了，那能否一次性全部读取呢？我们可以预置一个合适容量的byte[]数组来存放：

public static void main(String[] args) {
    //test.txt：abcd
    try(FileInputStream inputStream = new FileInputStream("test.txt")) {
        byte[] bytes = new byte[inputStream.available()];   //我们可以提前准备好合适容量的byte数组来存放
        System.out.println(inputStream.read(bytes));   //一次性读取全部内容（返回值是读取的字节数）
        System.out.println(new String(bytes));   //通过String(byte[])构造方法得到字符串
    }catch (IOException e){
        e.printStackTrace();
    }
}

也可以控制要读取数量：

System.out.println(inputStream.read(bytes, 1, 2));   //第二个参数是从给定数组

的哪个位置开始放入内容，第三个参数是读取流中的字节数通过skip()方法可以跳过指定数量的字节

public static void main(String[] args) {
    //test.txt：abcd
    try(FileInputStream inputStream = new FileInputStream("test.txt")) {
        System.out.println(inputStream.skip(1));
        System.out.println((char) inputStream.read());   //跳过了一个字节
    }catch (IOException e){
        e.printStackTrace();
    }
}

既然有输入流，那么文件输出流也是必不可少的

public static void main(String[] args) {
    //输出流也需要在最后调用close()方法，并且同样支持try-with-resource
    try(FileOutputStream outputStream = new FileOutputStream("output.txt")) {
        //注意：若此文件不存在，会直接创建这个文件！
    }catch (IOException e){
        e.printStackTrace();
    }
}

输出流没有read()操作而是write()操作，使用方法同输入流一样，只不过现在的方向变为我们向文件里写入内容

public static void main(String[] args) {
    try(FileOutputStream outputStream = new FileOutputStream("output.txt")) {
        outputStream.write('c');   //同read一样，可以直接写入内容
      	outputStream.write("lbwnb".getBytes());   //也可以直接写入byte[]
      	outputStream.write("lbwnb".getBytes(), 0, 1);  //同上输入流
      	outputStream.flush();  //建议在最后执行一次刷新操作（强制写入）来保证数据正确写入到硬盘文件中
    }catch (IOException e){
        e.printStackTrace();
    }
}

那么如果是我只想在文件尾部进行追加写入数据呢？我们可以调用另一个构造方法来实现

public static void main(String[] args) {
    try(FileOutputStream outputStream = new FileOutputStream("output.txt", true)) {  //true表示开启追加模式
        outputStream.write("lb".getBytes());   //现在只会进行追加写入，而不是直接替换原文件内容
        outputStream.flush();
    }catch (IOException e){
        e.printStackTrace();
    }
}

利用输入流和输出流，就可以轻松实现文件的拷贝了：

public static void main(String[] args) {
    try(FileOutputStream outputStream = new FileOutputStream("output.txt");
        FileInputStream inputStream = new FileInputStream("test.txt")) {   //可以写入多个
        byte[] bytes = new byte[10];    //使用长度为10的byte[]做传输媒介
        int tmp;   //存储本地读取字节数
        while ((tmp = inputStream.read(bytes)) != -1){   //直到读取完成为止
            outputStream.write(bytes, 0, tmp);    //写入对应长度的数据到输出流
        }
    }catch (IOException e){
        e.printStackTrace();
    }
}

对格式的疑惑请见: 在这里插入图片描述

🔥 真题实战：文件字符输入输出

在这里插入图片描述

这道题考查数据流的使用：

import java.io.*;

public class Main {
  public static void main(String[] args) {
    char[] charArray = {'a','b','c','d','e','f','g','h','i'};
    char c;
    try{
        // 创建数据输出流，写入文件
        DataOutputStream out = new DataOutputStream(
               new FileOutputStream("test.txt"));
        for(int i =0; i<charArray.length; i++){
           out.writeChar(charArray[i]);  // 写入字符
        }
        out.close();  // 关闭输出流
        
        // 创建数据输入流，从文件读取
        DataInputStream in = new DataInputStream(
               new FileInputStream("test.txt"));
        while(in.available() != 0){  // 检查是否还有数据
           c=in.readChar();          // 读取字符
           System.out.print(c+" ");
        }
        System.out.println();
        in.close();  // 关闭输入流
    }catch(IOException e){}
  }
}

解题思路： 这道题考查Java IO流的使用，特别是数据流对基本类型的读写操作。

知识点解析：

数据流：DataInputStream/DataOutputStream用于读写基本类型
文件流：FileInputStream/FileOutputStream处理文件
流的嵌套：DataInputStream包装FileInputStream
异常处理：IO操作必须处理IOException
资源管理：使用完流要及时关闭

算法步骤：

创建字符数组存储要写入的数据
创建DataOutputStream写入文件
循环将字符数组元素写入文件
关闭输出流
创建DataInputStream读取文件
循环读取字符并输出到控制台
关闭输入流

记忆技巧：

数据流：Data + 基础流，可以读写基本类型
available()：检查流中是否还有数据
流操作三步：打开 → 读写 → 关闭

文件操作常见考点：

字节流和字符流的区别和使用
数据流对基本类型的读写
文件的打开、读取、关闭操作
IOException异常处理

多线程

在了解多线程之前，让我们回顾一下操作系统中提到的进程概念：进程是程序执行的实体，每一个进程都是一个应用程序（比如我们运行QQ、浏览器、LOL、网易云音乐等软件），都有自己的内存空间，CPU一个核心同时只能处理一件事情，当出现多个进程需要同时运行时，CPU一般通过时间片轮转调度算法，来实现多个进程的同时运行。在这里插入图片描述

在早期的计算机中，进程是拥有资源和独立运行的最小单位，也是程序执行的最小单位。但是，如果我希望两个任务同时进行，就必须运行两个进程，由于每个进程都有一个自己的内存空间，进程之间的通信就变得非常麻烦（比如要共享某些数据）而且执行不同进程会产生上下文切换，非常耗时，那么能否实现在一个进程中就能够执行多个任务呢？

在这里插入图片描述

后来，线程横空出世，一个进程可以有多个线程，线程是程序执行中一个单一的顺序控制流程，现在线程才是程序执行流的最小单元，各个线程之间共享程序的内存空间（也就是所在进程的内存空间），上下文切换速度也高于进程。

在Java中，我们从开始，一直以来编写的都是单线程应用程序（运行main()方法的内容），也就是说只能同时执行一个任务（无论你是调用方法、还是进行计算，始终都是依次进行的，也就是同步的），而如果我们希望同时执行多个任务（两个方法同时在运行或者是两个计算同时在进行，也就是异步的），就需要用到Java多线程框架。实际上一个Java程序启动后，会创建很多线程，不仅仅只运行一个主线程：

public static void main(String[] args) {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    long[] ids = bean.getAllThreadIds();
    ThreadInfo[] infos = bean.getThreadInfo(ids);
    for (ThreadInfo info : infos) {
        System.out.println(info.getThreadName());
    }
}

线程的概念

线程就像是工厂里的工人，一个程序可以有多个工人同时工作，提高效率。

创建线程的方式

Java线程创建的四种方式：

// 方式1：继承Thread类
class MyThread extends Thread {
    private String threadName;
    
    public MyThread(String name) {
        this.threadName = name;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadName + ": " + i);
            try {
                Thread.sleep(1000);  // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 方式2：实现Runnable接口
class MyRunnable implements Runnable {
    private String threadName;
    
    public MyRunnable(String name) {
        this.threadName = name;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadName + ": " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 方式3：使用Callable接口（有返回值）
import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    private String threadName;
    
    public MyCallable(String name) {
        this.threadName = name;
    }
    
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadName + ": " + i);
            Thread.sleep(1000);
        }
        return threadName + "执行完成";
    }
}

// 方式4：使用Lambda表达式
Runnable task = () -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("Lambda线程: " + i);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};

线程使用示例：

public class ThreadExample {
    public static void main(String[] args) {
        // 方式1：继承Thread
        MyThread thread1 = new MyThread("线程1");
        thread1.start();
        
        // 方式2：实现Runnable
        MyRunnable runnable = new MyRunnable("线程2");
        Thread thread2 = new Thread(runnable);
        thread2.start();
        
        // 方式3：使用Callable
        MyCallable callable = new MyCallable("线程3");
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(callable);
        try {
            String result = future.get();  // 获取返回结果
            System.out.println("返回结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        executor.shutdown();
        
        // 方式4：Lambda表达式
        Thread thread4 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Lambda线程: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread4.start();
    }
}

线程的生命周期：

// 线程状态：
// NEW -> RUNNABLE -> BLOCKED/WAITING/TIMED_WAITING -> TERMINATED

public class ThreadLifeCycle {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行");
            try {
                Thread.sleep(2000);  // TIMED_WAITING状态
            } catch (InterruptedException e) {
                System.out.println("线程被中断");
                return;
            }
            System.out.println("线程执行完成");
        });
        
        System.out.println("创建后状态：" + thread.getState()); // NEW
        
        thread.start();
        System.out.println("启动后状态：" + thread.getState()); // RUNNABLE
        
        try {
            Thread.sleep(100);
            System.out.println("休眠中状态：" + thread.getState()); // TIMED_WAITING
            
            thread.join();  // 等待线程结束
            System.out.println("结束后状态：" + thread.getState()); // TERMINATED
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程同步：

// synchronized关键字
class Counter {
    private int count = 0;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void decrement() {
        synchronized(this) {
            count--;
        }
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// 使用示例
public class SyncExample {
    public static void main(String[] args) {
        Counter counter = new Counter();
        
        // 创建多个线程同时操作计数器
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();
                }
            }).start();
        }
        
        try {
            Thread.sleep(2000);  // 等待所有线程执行完成
            System.out.println("最终计数：" + counter.getCount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程的创建和启动

通过创建Thread对象来创建一个新的线程，Thread构造方法中需要传入一个Runnable接口的实现（其实就是编写要在另一个线程执行的内容逻辑）同时Runnable只有一个未实现方法，因此可以直接使用lambda表达式：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

创建好后，通过调用start()方法来运行此线程：

public static void main(String[] args) {
    Thread t = new Thread(() -> {    //直接编写逻辑
        System.out.println("我是另一个线程！");
    });
    t.start();   //调用此方法来开始执行此线程
}

我们的new Thread()在创建的时候，构造函数需要一个实现了实现了Runnable接口的类的对象，而这个类现在还没有出现，所以我们有两种办法，一是匿名内部类：在这里插入图片描述

使用后会马上出现实现了某个接口的类的对象(或者实现了某个抽象类的类的对象)

在这里使用的话效果如下：

Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        // 这里编写线程的逻辑
    }
});

或者，以下是使用Lambda表达式创建的Runnable对象：

Thread t = new Thread(() -> {
    // 这里编写线程的逻辑
});

在这里插入图片描述

一个双线程的例子：

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 50; i++) {
            System.out.println("我是一号线程："+i);
        }
    });
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 50; i++) {
            System.out.println("我是二号线程："+i);
        }
    });
    t1.start();
    t2.start();
}

我们可以看到打印实际上是在交替进行的，也证明了他们是在同时运行！

注意：我们发现还有一个run方法，也能执行线程里面定义的内容，但是run是直接在当前线程执行，并不是创建一个线程执行！在这里插入图片描述

实际上，线程和进程差不多，也会等待获取CPU资源，一旦获取到，就开始按顺序执行我们给定的程序，当需要等待外部IO操作（比如Scanner获取输入的文本），就会暂时处于休眠状态，等待通知，或是调用sleep()方法来让当前线程休眠一段时间

public static void main(String[] args) throws InterruptedException {
    System.out.println("l");
    Thread.sleep(1000);    //休眠时间，以毫秒为单位，1000ms = 1s
    System.out.println("b");
    Thread.sleep(1000);
    System.out.println("w");
    Thread.sleep(1000);
    System.out.println("nb!");
}

我们也可以使用stop()方法来强行终止此线程：

public static void main(String[] args) throws InterruptedException {
    Thread t = new Thread(() -> {
        Thread me = Thread.currentThread();   //获取当前线程对象
        for (int i = 0; i < 50; i++) {
            System.out.println("打印:"+i);
            if(i == 20) me.stop();  //此方法会直接终止此线程
        }
    });
    t.start();
}

线程的休眠和中断

我们前面提到，一个线程处于运行状态下，线程的下一个状态会出现以下情况：

当CPU给予的运行时间结束时，会从运行状态回到就绪（可运行）状态，等待下一次获得CPU资源。
当线程进入休眠 / 阻塞(如等待IO请求) / 手动调用wait()方法时，会使得线程处于等待状态，当等待状态结束后会回到就绪状态。
当线程出现异常或错误 / 被stop() 方法强行停止 / 所有代码执行结束时，会使得线程的运行终止。

线程的优先级

实际上，Java程序中的每个线程并不是平均分配CPU时间的，为了使得线程资源分配更加合理，Java采用的是抢占式调度方式，优先级越高的线程，优先使用CPU资源！我们希望CPU花费更多的时间去处理更重要的任务，而不太重要的任务，则可以先让出一部分资源。线程的优先级一般分为以下三种：

MIN_PRIORITY 最低优先级
MAX_PRIORITY 最高优先级
NOM_PRIORITY 常规优先级

public static void main(String[] args) {
    Thread t = new Thread(() -> {
        System.out.println("线程开始运行！");
    });
    t.start();
    t.setPriority(Thread.MIN_PRIORITY);  //通过使用setPriority方法来设定优先级
}

优先级越高的线程，获得CPU资源的概率会越大，并不是说一定优先级越高的线程越先执行！

线程的礼让和加入

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        System.out.println("线程1开始运行！");
        for (int i = 0; i < 50; i++) {
            if(i % 5 == 0) {
                System.out.println("让位！");
                Thread.yield();
            }
            System.out.println("1打印："+i);
        }
        System.out.println("线程1结束！");
    });
    Thread t2 = new Thread(() -> {
        System.out.println("线程2开始运行！");
        for (int i = 0; i < 50; i++) {
            System.out.println("2打印："+i);
        }
    });
    t1.start();
    t2.start();
}

观察结果，我们发现，在让位之后，尽可能多的在执行线程2的内容坏了，好像是我电脑太好，测试不出来，包括之前的哪个报错也没出来.....貌似是内存太大，顶着压力跑出来了...

当我们希望一个线程等待另一个线程执行完成后再继续进行，我们可以使用join()方法来实现线程的加入：

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        System.out.println("线程1开始运行！");
        for (int i = 0; i < 50; i++) {
            System.out.println("1打印："+i);
        }
        System.out.println("线程1结束！");
    });
    Thread t2 = new Thread(() -> {
        System.out.println("线程2开始运行！");
        for (int i = 0; i < 50; i++) {
            System.out.println("2打印："+i);
            if(i == 10){
                try {
                    System.out.println("线程1加入到此线程！");
                    t1.join();    //在i==10时，让线程1加入，先完成线程1的内容，在继续当前内容
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    t1.start();
    t2.start();
}

我们发现，线程1加入后，线程2等待线程1待执行的内容全部执行完成之后，再继续执行的线程2内容。注意，线程的加入只是等待另一个线程的完成，并不是将另一个线程和当前线程合并！

🔥 真题实战：给线程起个名题目来源

在这里插入图片描述

这道题考查线程的基本操作：

public class Main {    
   public static void main(String[] args) {
      Thread t = new SimpleThread("Testing_Thread");
      t.start();  // 启动线程
   }
} 

class SimpleThread extends Thread {  // 继承Thread类
   public SimpleThread(String str) {
      super(str);  // 调用父类构造方法设置线程名
   }
   
   public void run() {  // 重写run方法
      System.out.println("Running the " + getName() + ":");
      for (int i = 0; i < 5; i++) {
         System.out.println("---" + i + "---" + getName());
         try {
            sleep((int)(2 * 100));  // 线程休眠200毫秒
         }
         catch(InterruptedException e) { }  // 捕获中断异常
      }
   }
}

本题运行结果如下：

在这里插入图片描述

解题思路： 这道题考查Java多线程编程的基本用法，包括线程创建、命名、启动和休眠。

知识点解析：

线程创建：继承Thread类并重写run()方法
线程命名：通过super(str)调用父类构造方法
线程启动：调用start()方法而不是run()方法
线程休眠：sleep()方法让线程暂停执行
异常处理：InterruptedException必须处理

算法步骤：

创建SimpleThread类继承Thread
构造方法中调用super(str)设置线程名
重写run()方法定义线程执行逻辑
循环5次输出线程信息
每次输出后线程休眠200毫秒
main方法中创建线程并调用start()启动

记忆技巧：

创建线程：继承Thread → 重写run() → 调用start()
线程休眠：Thread.sleep(毫秒数)
获取线程名：getName()方法

多线程常见考点：

Thread类的继承和run()方法重写
线程的创建、启动和命名
sleep()方法和异常处理
线程同步和通信基础

线程锁和线程同步

在开始讲解线程同步之前，我们需要先了解一下多线程情况下Java的内存管理：在这里插入图片描述

线程之间的共享变量（比如之前悬念中的value变量）存储在主内存（main memory）中，每个线程都有一个私有的工作内存（本地内存），工作内存中存储了该线程以读/写共享变量的副本。它类似于我们在计算机组成原理中学习的多核心处理器高速缓存机制在这里插入图片描述

高速缓存通过保存内存中数据的副本来提供更加快速的数据访问，但是如果多个处理器的运算任务都涉及同一块内存区域，就可能导致各自的高速缓存数据不一致，在写回主内存时就会发生冲突，这就是引入高速缓存引发的新问题，称之为：缓存一致性。

实际上，Java的内存模型也是这样类似设计的，当我们同时去操作一个共享变量时，如果仅仅是读取还好，但是如果同时写入内容，就会出现问题！好比说一个银行，如果我和我的朋友同时在银行取我账户里面的钱，难道取1000还可能吐2000出来吗？我们需要一种更加安全的机制来维持秩序，保证数据的安全性！比如我们可以来看看下面这个问题：

    private static int value = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) value++;
            System.out.println("线程1完成");
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) value++;
            System.out.println("线程2完成");
        });
        t1.start();
        t2.start();
        Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
        System.out.println(value);
    }

在这里插入图片描述

实际上，当两个线程同时读取value的时候，可能会同时拿到同样的值，而进行自增操作之后，也是同样的值，再写回主内存后，本来应该进行2次自增操作，实际上只执行了一次！

通过synchronized关键字来创造一个线程锁，首先我们来认识一下synchronized代码块，它需要在括号中填入一个内容，必须是一个对象或是一个类，我们在value自增操作外套上同步代码块：

private static int value = 0;

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 10000; i++) {
            synchronized (Main.class){  //使用synchronized关键字创建同步代码块
                value++;
            }
        }
        System.out.println("线程1完成");
    });
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 10000; i++) {
            synchronized (Main.class){
                value++;
            }
        }
        System.out.println("线程2完成");
    });
    t1.start();
    t2.start();
    Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
    System.out.println(value);
}

我们发现，现在得到的结果就是我们想要的内容了，因为在同步代码块执行过程中，拿到了我们传入对象或类的锁（传入的如果是对象，就是对象锁，不同的对象代表不同的对象锁，如果是类，就是类锁，类锁只有一个，实际上类锁也是对象锁，是Class类实例，但是Class类实例同样的类无论怎么获取都是同一个），但是注意两个线程必须使用同一把锁！

当一个线程进入到同步代码块时，会获取到当前的锁，而这时如果其他使用同样的锁的同步代码块也想执行内容，就必须等待当前同步代码块的内容执行完毕，在执行完毕后会自动释放这把锁，而其他的线程才能拿到这把锁并开始执行同步代码块里面的内容（实际上synchronized是一种悲观锁，随时都认为有其他线程在对数据进行修改，后面在JUC篇视频教程中我们还会讲到乐观锁，如CAS算法）

死锁

其实死锁的概念在操作系统中也有提及，它是指两个线程相互持有对方需要的锁，但是又迟迟不释放，导致程序卡住：在这里插入图片描述

我们发现，线程A和线程B都需要对方的锁，但是又被对方牢牢把握，由于线程被无限期地阻塞，因此程序不可能正常终止。我们来看看以下这段代码会得到什么结果：

public static void main(String[] args) throws InterruptedException {
    Object o1 = new Object();
    Object o2 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (o1){
            try {
                Thread.sleep(1000);
                synchronized (o2){
                    System.out.println("线程1");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (o2){
            try {
                Thread.sleep(1000);
                synchronized (o1){
                    System.out.println("线程2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t1.start();
    t2.start();
}

因此，前面说不推荐使用 suspend()去挂起线程的原因，是因为suspend()在使线程暂停的同时，并不会去释放任何锁资源。其他线程都无法访问被它占用的锁。直到对应的线程执行resume()方法后，被挂起的线程才能继续，从而其它被阻塞在这个锁的线程才可以继续执行。但是，如果resume()操作出现在suspend()之前执行，那么线程将一直处于挂起状态，同时一直占用锁，这就产生了死锁。在这里插入图片描述

wait和notify方法

其实我们之前可能就发现了，Object类还有三个方法我们从来没有使用过，分别是wait()、notify()以及notifyAll()，他们其实是需要配合synchronized来使用的（实际上锁就是依附于对象存在的，每个对象都应该有针对于锁的一些操作，所以说就这样设计了）当然，只有在同步代码块中才能使用这些方法，正常情况下会报错，我们来看看他们的作用是什么

public static void main(String[] args) throws InterruptedException {
    Object o1 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (o1){
            try {
                System.out.println("开始等待");
                o1.wait();     //进入等待状态并释放锁
                System.out.println("等待结束！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (o1){
            System.out.println("开始唤醒！");
            o1.notify();     //唤醒处于等待状态的线程
          	for (int i = 0; i < 50; i++) {
               	System.out.println(i);   
            }
          	//唤醒后依然需要等待这里的锁释放之前等待的线程才能继续
        }
    });
    t1.start();
    Thread.sleep(1000);
    t2.start();
}

我们可以发现，对象的wait()方法会暂时使得此线程进入等待状态，同时会释放当前代码块持有的锁，这时其他线程可以获取到此对象的锁，当其他线程调用对象的notify()方法后，会唤醒刚才变成等待状态的线程（这时并没有立即释放锁）。注意，必须是在持有锁（同步代码块内部）的情况下使用，否则会抛出异常！

notifyAll其实和notify一样，也是用于唤醒，但是前者是唤醒所有调用wait()后处于等待的线程，而后者是看运气随机选择一个。

定时器

我们有时候会有这样的需求，我希望定时执行任务，比如3秒后执行，其实我们可以通过使用Thread.sleep()来实现：

public static void main(String[] args) {
    new TimerTask(() -> System.out.println("我是定时任务！"), 3000).start();   //创建并启动此定时任务
}

static class TimerTask{
    Runnable task;
    long time;

    public TimerTask(Runnable runnable, long time){
        this.task = runnable;
        this.time = time;
    }

    public void start(){
        new Thread(() -> {
            try {
                Thread.sleep(time);
                task.run();   //休眠后再运行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

GUI程序开发

果然不能休息，脑袋好沉重...但是为了赶快考完看mygo，拼了

AWT组件介绍

在Java正式推出的时候，它还包含一个用于基本GUI程序设计的类库，名字叫 Abstract Window Toolkit，简称AWT，抽象窗口工具包，我们可以直接使用Java为我们提供的工具包来进行桌面应用程序的开发。只不过这套工具包依附于操作系统提供的UI，具体样式会根据不同操作系统提供的界面元素进行展示。

实际上我们现代操作系统都是图形化界面，应用程序都是以一个窗口的形式展示出来的，我们可以直接使用鼠标点击窗口内的元素来使用应用程序，相比传统的命令行形式，可方便太多了，比如在Windows和MacOS这两种操作系统下：在这里插入图片描述

woc，原！

可以看到，不同的操作系统的窗口样式稍微有一些不一样，但是大致的使用方式是差不多的，我们接着来看一下如何使用Java编写简单的桌面图形化程序。

基本框架

既然我们要编写一个桌面程序，那么肯定是需要窗口来展示我们程序的内容的，所以说，我们可以使用AWT为我们提供的组件来创建窗口

public static void main(String[] args) {
    Frame frame = new Frame();   //Frame是窗体，我们只需要创建这样一个对象就可以了，这样就会直接创建一个新的窗口
    frame.setSize(500, 300);   //可以使用setSize方法设定窗体大小
    frame.setVisible(true);    //默认情况下窗体是不可见的，我们如果要展示出来，还需要设置窗体可见性
}

监听器

我们可以为窗口添加一系列的监听器，监听器会监听窗口中发生的一些事件，比如我们点击关闭窗口、移动鼠标、鼠标点击等，当发生对应的事件时，就会通知到对应的监听器进行处理，从而我们能够在发生对应事件时进行对应处理。在这里插入图片描述

比如我们现在希望点击关闭按钮关闭当前的窗口，但是我们发现默认情况下实际上是关不掉的，因为我们并没有对关闭事件进行处理，默认情况下对于这种点击时没有设定任何动作的，万一我们点了之后并不是要关闭窗口呢。要实现关闭窗口，我们可以使用addXXXListener来添加对应的事件监听器，比如窗口相关的操作那么就是WindowListener

这里我们可以给一个接口实现，或是使用对应的适配器（适配器模式是设计模式中的一种写法，因为接口中要实现的方法太多，但是实际上我们并不需要实现那么多，只需要实现对应的即可，所以说就可以使用适配器）我们只需要重写对应的方法，当发生对应事件时就会自动调用我们已经实现好的方法：

frame.addWindowListener(new WindowAdapter() {
    @Override
    public void windowClosing(WindowEvent e) {   //windowClosing方法对应的就是窗口关闭事件
        frame.dispose();    //当我们点击X号关闭窗口时，就会自动执行此方法了
        //使用dispose方法来关闭当前窗口
    }

    @Override
    public void windowClosed(WindowEvent e) {   //对应窗口已关闭事件
        System.out.println("窗口已关闭！");   //当窗口成功关闭后，会执行这里重写的内容
      	System.exit(0);    //窗口关闭后退出当前Java程序
    }
});

我们可以来看看效果，现在我们点击X号关闭窗口就可以成功执行了，并且窗口关闭后我们的Java程序就结束了。当然，监听器可以添加多个，并不是只能有一个。

这里总结一下窗口常用的事件：

public interface WindowListener extends EventListener {
    public void windowOpened(WindowEvent e);   //当窗口的可见性首次变成true时会被调用
    public void windowClosing(WindowEvent e);   //当以后企图关闭窗口（也就是点击X号）时被调用
    public void windowClosed(WindowEvent e);   //窗口被我们成功关闭之后被调用
    public void windowIconified(WindowEvent e);    //窗口最小化时被调用
    public void windowDeiconified(WindowEvent e);   //窗口从最小化状态变成普通状态时调用
    public void windowActivated(WindowEvent e);    //当窗口变成活跃状态时被调用
    public void windowDeactivated(WindowEvent e);   //当窗口变成不活跃时被调用
}

除了监听窗口相关的动作之外，我们也可以监听鼠标、键盘等操作的事件，比如键盘事件：

frame.addKeyListener(new KeyAdapter() {
    @Override
    public void keyTyped(KeyEvent e) {    //监听键盘输入事件，当我们在窗口中敲击键盘输入时会触发
        System.out.print(e.getKeyChar());   //可以通过KeyEvent对象来获取当前事件输入的对应字符
    }
});

常用组件

在开始学习组件之前，我们先将布局设定为null（因为默认情况下会采用BorderLayout作为布局）有关布局我们会在下一部分中进行介绍，这节课我们先介绍没有布局的情况下如何使用这些组件。

frame.setLayout(null);

首先我们来介绍一下最简单的组件，标签组件相当于一个普通的文本内容，我们可以将自己的标签添加到窗口中：

Label label = new Label("我是标签");   //添加标签只需要创建一个Label对象即可
label.setLocation(20, 50);   //注意，必须设定标签的位置和大小，否则无法展示出来
label.setSize(100, 20);
frame.add(label);    //使用add方法添加组件到窗口中

我们接着来认识一下下一个组件，这个组件的名字叫做按钮，实际上按钮也是我们经常会使用的一个组件：

Button button = new Button("点击充值");   //Button是按钮组件
button.setBounds(20, 50, 100, 50);
frame.add(button);

只不过，既然是按钮，那么肯定要添加一些点击动作才可以，比如点击按钮之后打印充值成功：

button.addActionListener(e -> System.out.println("充值成功"));  //addActionListener就是按钮点击监听器

只不过光有按钮似乎太单调了一点，我们接着来认识下一个组件：

TextField field = new TextField();   //TextField是文本框
field.setBounds(20, 50, 100, 25);
frame.add(field);

在这里插入图片描述

TextField field = new TextField();
field.setBounds(20, 50, 200, 25);
frame.add(field);

Button button = new Button("点击登录");
button.setBounds(20, 80, 100, 50);
//点击按钮直接获取文本框中的文本内容，只需要调用getText方法即可
button.addActionListener(e -> System.out.println("输入的用户名是："+field.getText()));
frame.add(button);

是不是感觉有内味了？当然，可能会有小伙伴觉得如果我们输入密码的话，不应该将展示的文字隐藏起来吗？我们可以这样：

field.setEchoChar('*');   //setEchoChar设定展示字符，无论我们输入的是什么，最终展示出来的都是我们指定的字符

但是肯定有小伙伴疑问，不是还有一个记住密码的勾选框吗？安排

Checkbox checkbox = new Checkbox("记住密码");
checkbox.setBounds(20, 50, 100, 30);   //这个大小并不是勾选框的大小，具体的勾选框大小要根据操作系统决定，跟Label一样，是展示的空间大小
frame.add(checkbox);

菜单栏

前面我们认识了各种各样的组件，我们接着来看菜单，实际上各位小伙伴会发现我们的程序上方一般都会有一排菜单在这里插入图片描述

而我们编写AWT程序也可以添加这样的菜单，只需要为窗口设定一个菜单栏即可：

MenuBar bar = new MenuBar();    //创建菜单栏 
Menu menu = new Menu("我是1号菜单");
menu.add(new MenuItem("测试1"));
menu.add(new MenuItem("测试2"));
bar.add(menu);
frame.setMenuBar(bar);    //为窗口设定刚刚定义好的菜单栏

在这里插入图片描述

MenuItem item = new MenuItem("测试1");
item.addActionListener(e -> System.out.println("一号选项被点击了！"));
menu.add(item);

Swing

我们来看看如何使用Swing编写桌面程序，首先还是最重要的窗口：

public static void main(String[] args) {
    JFrame frame = new JFrame("我是窗口");   //Swing中的窗口叫做JFrame，对应的就是AWT中的Frame
    //它实际上就是Frame的子类，所以说我们之前怎么用的，现在怎么用就行了
    frame.setSize(500, 300);
    frame.setVisible(true);
}

是不是感觉学会AWT之后再看Swing也太简单了？

当然，既然是AWT的扩展，那肯定是有更多的新增功能的，比如我们之前想要实现点击X号关闭Java程序，这里我们只需要使用一个方法就可以设定了，不需要我们自己去写监听器：

//我们可以直接为窗口设定关闭操作，JFrame已经为我们预设好了一些常用的操作了
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //EXIT_ON_CLOSE就是直接退出程序，默认是只隐藏

Swing为我们提供了所有原本AWT中的组件的升级版，他们的名字前面都加上了J，比如按钮组件：

public static void main(String[] args) {
    JFrame frame = new JFrame("我是窗口");
    frame.setLayout(null);
    JButton button = new JButton("Link Start");  //Button组件对应的就是JButton了
    button.setBounds(20, 50, 100, 50);
    frame.add(button);
    frame.setSize(500, 300);
    frame.setVisible(true);
}

同样的，如果我们要使用菜单，直接使用对应的类即可：

JFrame frame = new JFrame("我是窗口");
JMenuBar bar = new JMenuBar();    //JMenuBar对应的就是MenuBar
JMenu menu = new JMenu("我是菜单");
menu.add(new JMenuItem("选项1"));
menu.add(new JMenuItem("选项2"));
bar.add(menu);
frame.setJMenuBar(bar);
frame.setSize(500, 300);
frame.setVisible(true);

所以让我们总结swing的结构

Swing体系结构：

// Swing组件层次结构
Component              // 所有组件的基类
│
├── Container         // 容器类组件
│   │
│   ├── Window        // 窗口类
│   │   │
│   │   └── Frame   // 框架窗口
│   │       │
│   │       └── JFrame  // Swing框架窗口
│   │
│   └── JPanel        // Swing面板
│
└── JComponent        // Swing组件基类
    │
    ├── JLabel        // 标签
    ├── JButton       // 按钮
    ├── JTextField    // 文本框
    ├── JTextArea     // 文本区域
    ├── JCheckBox     // 复选框
    ├── JRadioButton  // 单选按钮
    └── JComboBox     // 下拉框

基本组件使用：

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

// 最简单的Swing程序
public class SimpleSwingExample {
    public static void main(String[] args) {
        // 主窗口
        JFrame frame = new JFrame("简单示例");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 200);
        frame.setLocationRelativeTo(null);  // 居中显示
        
        // 文本标签
        JLabel label = new JLabel("你好，Swing！", JLabel.CENTER);
        
        // 按钮
        JButton button = new JButton("点击我");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(frame, "按钮被点击了！");
            }
        });
        
        // 布局
        frame.setLayout(new BorderLayout());
        frame.add(label, BorderLayout.CENTER);
        frame.add(button, BorderLayout.SOUTH);
        
        frame.setVisible(true);
    }
}

常用组件属性设置：

// JFrame 窗口设置
JFrame frame = new JFrame("窗口标题");
frame.setSize(400, 300);                    // 设置大小
frame.setBounds(100, 100, 400, 300);        // 设置位置和大小
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  // 关闭操作
frame.setResizable(false);                  // 禁止调整大小
frame.setLocationRelativeTo(null);          // 居中显示
frame.setVisible(true);                     // 显示窗口

// JLabel 标签设置
JLabel label = new JLabel("文本内容");
label.setText("新文本");                    // 设置文本
label.setFont(new Font("宋体", Font.BOLD, 16)); // 设置字体
label.setForeground(Color.RED);             // 设置文本颜色
label.setHorizontalAlignment(JLabel.CENTER); // 水平对齐
label.setVerticalAlignment(JLabel.CENTER);   // 垂直对齐

// JButton 按钮设置
JButton button = new JButton("按钮文本");
button.setText("新按钮文本");              // 设置文本
button.setFont(new Font("宋体", Font.PLAIN, 14)); // 设置字体
button.setForeground(Color.WHITE);          // 文本颜色
button.setBackground(Color.BLUE);           // 背景颜色
button.setEnabled(false);                   // 禁用按钮
button.setFocusPainted(false);              // 去除焦点边框

// JTextField 文本框设置
JTextField textField = new JTextField();
textField.setText("默认文本");              // 设置默认文本
textField.setColumns(20);                   // 设置列数
textField.setEditable(false);               // 设置为只读
textField.setHorizontalAlignment(JTextField.CENTER); // 文本对齐

3.2 布局管理器

Java五大布局管理器：

// 1. FlowLayout - 流式布局（默认）
setLayout(new FlowLayout());
setLayout(new FlowLayout(FlowLayout.LEFT));    // 左对齐
setLayout(new FlowLayout(FlowLayout.CENTER));  // 居中对齐
setLayout(new FlowLayout(FlowLayout.RIGHT));   // 右对齐

// 2. BorderLayout - 边界布局
setLayout(new BorderLayout());
add(component, BorderLayout.NORTH);    // 上
add(component, BorderLayout.SOUTH);    // 下
add(component, BorderLayout.WEST);     // 左
add(component, BorderLayout.EAST);     // 右
add(component, BorderLayout.CENTER);   // 中

// 3. GridLayout - 网格布局
setLayout(new GridLayout(3, 2));       // 3行2列
setLayout(new GridLayout(3, 2, 5, 5)); // 带间距的网格

// 4. CardLayout - 卡片布局
CardLayout cardLayout = new CardLayout();
setLayout(cardLayout);
add(panel1, "card1");
add(panel2, "card2");
cardLayout.show(container, "card1");   // 显示指定卡片

// 5. 绝对定位 - 精确控制位置
setLayout(null);
component.setBounds(x, y, width, height);

布局管理器实例：

import javax.swing.*;
import java.awt.*;

public class LayoutExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("布局管理器示例");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(500, 400);
        
        // BorderLayout 主布局
        frame.setLayout(new BorderLayout());
        
        // 北部 - 工具栏
        JPanel northPanel = new JPanel(new FlowLayout());
        northPanel.add(new JButton("新建"));
        northPanel.add(new JButton("打开"));
        northPanel.add(new JButton("保存"));
        frame.add(northPanel, BorderLayout.NORTH);
        
        // 南部 - 状态栏
        JPanel southPanel = new JPanel(new BorderLayout());
        southPanel.add(new JLabel("就绪"), BorderLayout.WEST);
        southPanel.add(new JLabel("第1行，第1列"), BorderLayout.EAST);
        frame.add(southPanel, BorderLayout.SOUTH);
        
        // 西部 - 工具箱
        JPanel westPanel = new JPanel(new GridLayout(5, 1, 5, 5));
        westPanel.add(new JButton("工具1"));
        westPanel.add(new JButton("工具2"));
        westPanel.add(new JButton("工具3"));
        westPanel.add(new JButton("工具4"));
        westPanel.add(new JButton("工具5"));
        frame.add(westPanel, BorderLayout.WEST);
        
        // 东部 - 属性面板
        JPanel eastPanel = new JPanel();
        eastPanel.setLayout(null);  // 绝对定位
        
        JLabel label1 = new JLabel("属性：");
        label1.setBounds(10, 10, 60, 25);
        eastPanel.add(label1);
        
        JTextField field1 = new JTextField();
        field1.setBounds(10, 40, 100, 25);
        eastPanel.add(field1);
        
        JButton button1 = new JButton("应用");
        button1.setBounds(10, 70, 100, 25);
        eastPanel.add(button1);
        
        frame.add(eastPanel, BorderLayout.EAST);
        
        // 中央 - 主工作区
        JTextArea centerArea = new JTextArea("主工作区\n这里放置主要内容");
        centerArea.setFont(new Font("宋体", Font.PLAIN, 14));
        JScrollPane scrollPane = new JScrollPane(centerArea);
        frame.add(scrollPane, BorderLayout.CENTER);
        
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

布局嵌套使用：

// 复杂布局嵌套示例
JPanel mainPanel = new JPanel(new BorderLayout());

// 上部复合面板
JPanel topPanel = new JPanel(new FlowLayout());
JPanel leftTop = new JPanel(new GridLayout(1, 3));
leftTop.add(new JButton("新建"));
leftTop.add(new JButton("打开"));
leftTop.add(new JButton("保存"));

JPanel rightTop = new JPanel(new FlowLayout(FlowLayout.RIGHT));
rightTop.add(new JLabel("用户：张三"));
rightTop.add(new JButton("退出"));

topPanel.add(leftTop);
topPanel.add(rightTop);
mainPanel.add(topPanel, BorderLayout.NORTH);

// 中部左右分割
JPanel centerPanel = new JPanel(new BorderLayout());
JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
splitPane.setLeftComponent(new JScrollPane(new JTree()));
splitPane.setRightComponent(new JScrollPane(new JTable()));
splitPane.setDividerLocation(200);
centerPanel.add(splitPane, BorderLayout.CENTER);
mainPanel.add(centerPanel, BorderLayout.CENTER);

🔥 真题实战：QQ登录界面

在这里插入图片描述

这是一道综合性的GUI编程题：

题目要求： 创建一个模拟QQ登录界面的程序

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

public class Main extends JFrame {  // 继承JFrame
    private JTextField username;
    private JPasswordField password;
    private JLabel jl3;
    private JLabel jl4;
    private JButton bu1;
    private JButton bu2;
    private JButton bu3;
    private JCheckBox jc1;
    private JCheckBox jc2;
    private JComboBox<String> jcb;

    public Main() {
        this.setTitle("QQ2025正式版");     // 设置窗口标题
        init();
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  // 关闭操作
        this.setLayout(null);             // 使用绝对定位
        this.setBounds(0, 0, 355, 265);   // 设置窗口大小和位置
        this.setResizable(false);         // 禁止调整大小
        this.setLocationRelativeTo(null); // 居中显示
        this.setVisible(true);            // 显示窗口
    }

    public void init() {
        Container con = this.getContentPane();  // 获取内容面板

        // 创建用户名输入框
        username = new JTextField();
        username.setBounds(50, 50, 150, 20);

        jl3 = new JLabel("注册账号");
        jl3.setBounds(210, 50, 70, 20);

        // 创建密码输入框
        password = new JPasswordField();
        password.setBounds(50, 80, 150, 20);

        jl4 = new JLabel("找回密码");
        jl4.setBounds(210, 80, 70, 20);

        // 创建复选框
        jc1 = new JCheckBox("记住密码");
        jc1.setBounds(125, 135, 80, 15);

        jc2 = new JCheckBox("自动登录");
        jc2.setBounds(215, 135, 80, 15);

        // 创建下拉框
        jcb = new JComboBox<>();
        jcb.addItem("在线");
        jcb.addItem("隐身");
        jcb.addItem("离开");
        jcb.setBounds(40, 135, 55, 20);

        // 创建按钮并添加事件监听器
        bu1 = new JButton("登录");
        bu1.setBounds(250, 200, 65, 20);
        bu1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String str = e.getActionCommand();
                if ("登录".equals(str)) {
                    String getName = username.getText();
                    JOptionPane.showConfirmDialog(null, "您输入的用户名是 " + getName);
                }
            }
        });

        bu2 = new JButton("多账号");
        bu2.setBounds(25, 200, 75, 20);

        bu3 = new JButton("设置");
        bu3.setBounds(140, 200, 65, 20);

        // 将所有组件添加到容器中
        con.add(username);
        con.add(password);
        con.add(jl3);
        con.add(jl4);
        con.add(jc1);
        con.add(jc2);
        con.add(jcb);
        con.add(bu1);
        con.add(bu2);
        con.add(bu3);
    }

    public static void main(String[] args) {
        new Main();
    }
}

执行结果: 在这里插入图片描述

真不是我夸，这题库太妙了，这个gui功能简直点睛之笔

解题思路： 这道题要求创建一个完整的GUI登录界面，涉及多种Swing组件和事件处理。

知识点解析：

继承：extends JFrame 表示Main类继承JFrame
组件创建：new JTextField() 创建文本框组件
绝对定位：setBounds(x, y, width, height) 精确设置位置
事件处理：addActionListener() 添加按钮点击事件
匿名内部类：直接在参数中定义ActionListener
容器管理：通过getContentPane()获取内容面板添加组件

算法步骤：

继承JFrame创建主窗口类
在构造方法中初始化窗口属性
init()方法中创建各种GUI组件
设置每个组件的位置和大小
为按钮添加事件监听器
将所有组件添加到容器中

记忆技巧：

GUI编程三步：创建组件 → 设置属性 → 添加到容器
setBounds参数：x坐标、y坐标、宽度、高度
事件处理：组件.add事件监听器(new 监听器类())

Swing GUI常见考点：

JFrame、JPanel、JButton等组件的使用
布局管理器（绝对定位、流式布局等）
事件监听器和事件处理
组件属性设置和样式控制

结语：

差不多也就这些内容（其实真不少）

题库平台最后还是拿出来夸一下：java.code2ji.cn

全国计算机java二级考试经验分享

Java 基础语法笔记

1. Java 基本概念

2. Java 程序结构

说明：

3. 基本数据类型

4. 变量声明与赋值

声明和初始化变量：

常见操作：

5. 控制结构

条件语句

循环语句

for 循环：

while 循环：

do-while 循环：

6. 数组

一维数组

二维数组

🔥 真题实战：5×5上三角矩阵 题目来源

7. 方法（函数）

方法声明和调用：

带参数的方法：

8. 面向对象

类与对象

继承与多态

9. 常见类库

String 类

ArrayList（动态数组）

Scanner（输入）

异常

异常的类型

抛出异常

异常的处理

Java I/O

文件字节流

🔥 真题实战：文件字符输入输出

多线程

创建线程的方式

线程的创建和启动

线程的休眠和中断

线程的优先级

线程的礼让和加入

🔥 真题实战：给线程起个名 题目来源

线程锁和线程同步

死锁

wait和notify方法

定时器

GUI程序开发

AWT组件介绍

基本框架

监听器

常用组件

菜单栏

Swing

3.2 布局管理器

🔥 真题实战：QQ登录界面

结语：

`for` 循环：

`while` 循环：

`do-while` 循环：

🔥 真题实战：5×5上三角矩阵题目来源

`String` 类

`ArrayList`（动态数组）

`Scanner`（输入）

🔥 真题实战：给线程起个名题目来源