计算机二级Java基础语法速成笔记（含多线程与GUI，22张实机截图）
计算机二级Java基础语法速成笔记（含多线程与GUI，22张实机截图）
先把考试信息摆上（2026年9月考期）
写在最前面，省得你再去翻公告：
| 项目 | 内容 |
|---|---|
| 考试日期 | 2026年9月19日 — 9月21日（北京、山东、吉林、海南、云南等部分省份只考 19—20 两天） |
| 报名网址 | ncre-bm.neea.edu.cn |
| 报名截止 | 各省不同，最早 6月25日开始，最晚 9月4日截止 |
| 考试时长 | 二级各科统一 120 分钟 |
| 二级科目数 | 11 个（C、Java、C++、Python、Web、MS Office、WPS Office、Access、MySQL、openGauss、CAD） |
| 及格线 | 60 分；90 分以上为「优秀」 |
前五行来自中国教育考试网 2026年9月考期公告（ncre.neea.edu.cn），
及格线一行是历年通行标准，官方公告页未单列。具体报名时间以你所在省考试院公告为准，
各省差异很大。
这是我备考二级 Java 时整理的一份基础语法笔记，从最基本的数据类型一路写到多线程和
AWT/Swing 图形界面。每个知识点后面基本都跟着一段能直接跑的代码，截图是本机实际运行的结果。
内容顺序按考纲铺开：基本概念 → 程序结构 → 数据类型 → 变量 → 控制结构 → 数组 →
方法 → 面向对象 → 常用类库 → 异常 → I/O → 多线程 → GUI。想查哪块直接跳。
抱歉，怎么想都很完蛋
17/9
昨天发现任务太艰巨，直接放弃抵抗去看mygo了，但是和叶子打赌今天能把java课程看完，所以挣扎一下(这是我最后的波纹了)
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
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(); //这种情况就会出现运行时异常
}
本文真题截图均来自 Java二级在线（java.code2ji.cn），题目可在该站直接在线作答与判分。
抛出异常
当别人调用我们的方法时，如果传入了错误的参数导致程序无法正常运行，这时我们就可以手动抛出一个异常来终止程序继续运行下去，同时告知上一级方法执行出现了问题：
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();
}
}
对格式的疑惑请见:
多线程
在了解多线程之前，让我们回顾一下操作系统中提到的进程概念：
进程是程序执行的实体，每一个进程都是一个应用程序（比如我们运行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());
}
}
线程的创建和启动
通过创建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内容。注意，线程的加入只是等待另一个线程的完成，并不是将另一个线程和当前线程合并！
线程锁和线程同步
在开始讲解线程同步之前，我们需要先了解一下多线程情况下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()后处于等待的线程，而后者是看运气随机选择一个。
ThreadLocal的使用
既然每个线程都有一个自己的工作内存，那么能否只在自己的工作内存中创建变量仅供线程自己使用呢？
我们可以使用ThreadLocal类，来创建工作内存中的变量，它将我们的变量值存储在内部（只能存储一个变量），不同的线程访问到ThreadLocal对象时，都只能获取到当前线程所属的变量。
public static void main(String[] args) throws InterruptedException {
ThreadLocal<String> local = new ThreadLocal<>(); //注意这是一个泛型类，存储类型为我们要存放的变量类型
Thread t1 = new Thread(() -> {
local.set("lbwnb"); //将变量的值给予ThreadLocal
System.out.println("变量值已设定！");
System.out.println(local.get()); //尝试获取ThreadLocal中存放的变量
});
Thread t2 = new Thread(() -> {
System.out.println(local.get()); //尝试获取ThreadLocal中存放的变量
});
t1.start();
Thread.sleep(3000); //间隔三秒
t2.start();
}
上面的例子中，我们开启两个线程分别去访问ThreadLocal对象，我们发现，第一个线程存放的内容，第一个线程可以获取，但是第二个线程无法获取，我们再来看看第一个线程存入后，第二个线程也存放，是否会覆盖第一个线程存放的内容?
我们发现，即使线程2重新设定了值，也没有影响到线程1存放的值，所以说，不同线程向ThreadLocal存放数据，只会存放在线程自己的工作空间中，而不会直接存放到主内存中，因此各个线程直接存放的内容互不干扰。
定时器
我们有时候会有这样的需求，我希望定时执行任务，比如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);
浙公网安备 33010602011771号