在后端开发领域，Java 凭借跨平台、强类型、面向对象、生态完善四大优势，稳居编程语言榜首。无论是 Spring Boot 微服务、大数据处理、Android 开发，还是企业级系统，Java 都是首选语言。本文将用可直接运行的实战代码，带你打通 Java 从基础到进阶的核心知识点，覆盖基础语法、多线程、文件 / IO 操作、注解、正则表达式五大高频场景，帮你快速建立完整的 Java 知识体系。

一、Java 入门：环境与基础语法

学习 Java 的第一步，是理解它的编译与运行机制。Java 源码（.java）经编译器编译为字节码（.class），再由 JVM 解释执行，实现 “一次编写，到处运行”。

1. 第一个 Java 程序

public class HelloJava {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
        System.out.println("欢迎进入 Java 实战世界");
    }
}

执行流程：

1. 编译：javac HelloJava.java → 生成 HelloJava.class
2. 运行：java HelloJava → JVM 加载并执行

核心要点：

• public class 类名必须与文件名一致
• main 方法是程序入口，格式固定
• System.out.println 用于控制台输出

2. 变量、数据类型与运算符

Java 是强类型语言，变量必须先声明类型再使用。

public class BaseDemo {
    public static void main(String[] args) {
        // 基本数据类型
        int age = 20;
        double score = 95.5;
        boolean isPass = true;
        String name = "Java学习者";

        // 运算
        int result = age + 10;
        System.out.println("姓名：" + name);
        System.out.println("年龄+10：" + result);
    }
}

Java 提供 8 种基本类型：byte、short、int、long、float、double、char、boolean，配合包装类（Integer、Double）实现对象化操作。

二、Java 多线程：高并发核心能力

和 Python 的 threading 类似，Java 内置强大的多线程支持，且无 GIL 限制，能真正利用多核 CPU，适合高并发场景。Java 提供三种创建线程的方式：

1. 继承 Thread 类

class MyThread extends Thread {
    private String name;
    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " 运行：" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(name + " 执行完毕");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("线程1");
        MyThread t2 = new MyThread("线程2");
        t1.start();
        t2.start();
        System.out.println("主线程继续执行");
    }
}

2. 实现 Runnable 接口（推荐）

class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
            System.out.println("任务执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
        System.out.println("开始等待...");
    }
}

3. 线程池（企业开发标准用法）

实际项目禁止手动创建线程，必须用线程池复用资源：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolDemo {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            pool.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务");
            });
        }
        pool.shutdown();
    }
}

Java 多线程优势：

• 无 GIL，多核 CPU 可真正并行
• 内置 synchronized、Lock、ThreadLocal 等并发工具
• 线程池、Future、CompletableFuture 完善异步方案

三、Java IO 与文件操作：数据读写核心

IO 是后端必备技能，Java 提供字节流、字符流、缓冲流、NIO多种方案，支持文件读写、网络传输、对象序列化等。

1. 文件写入与读取

import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;

public class FileIODemo {
    public static void main(String[] args) {
        // 写入文件
        try (FileWriter writer = new FileWriter("test.txt")) {
            writer.write("Hello Java IO\n");
            writer.write("文件操作实战");
            System.out.println("写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 读取文件
        try (FileReader reader = new FileReader("test.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 缓冲流（高效读写）

import java.io.BufferedReader;
import java.io.FileReader;

public class BufferDemo {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println("行内容：" + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO 核心分类：

• 字节流：InputStream/OutputStream → 图片、视频
• 字符流：Reader/Writer → 文本文件
• 缓冲流：减少磁盘 IO，大幅提升效率

四、Java 注解与自定义装饰器逻辑

Java 注解（Annotation）相当于代码标签，可在编译、运行时生效，实现配置、校验、增强等功能，类似 Python 装饰器，但更强大。

1. 内置注解

@Override
public String toString() {
    return "自定义对象";
}

@Deprecated
public void oldMethod() {
    // 废弃方法
}

@SuppressWarnings("unchecked")
public void test() {
    // 忽略警告
}

2. 自定义注解 + 反射实现 “执行 N 次触发”

模拟 Python 装饰器 “三进一” 逻辑，用注解 + 反射实现：

import java.lang.annotation.*;

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface ExecuteAfterN {
    int value();
}

class Task {
    private static int count = 0;

    @ExecuteAfterN(3)
    public void doTask() {
        count++;
        System.out.println("执行任务 a");
        // 反射判断是否触发
        try {
            ExecuteAfterN anno = this.getClass().getMethod("doTask").getAnnotation(ExecuteAfterN.class);
            if (count % anno.value() == 0) {
                trigger();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void trigger() {
        System.out.println("触发执行 b");
    }
}

public class AnnotationDemo {
    public static void main(String[] args) {
        Task task = new Task();
        for (int i = 0; i < 6; i++) {
            task.doTask();
        }
    }
}

运行结果：每执行 3 次 doTask，自动触发 trigger，完全实现 “三进一” 逻辑。

五、Java 正则表达式：字符串匹配神器

和 Python 正则一样，Java 内置 java.util.regex 包，支持复杂规则匹配，常用于数据校验、格式提取、日志解析。

实战：筛选符合规则的字符串

匹配规则：

1. 字母 + 数字，可含 -，长度 2-8
2. 纯数字，长度 4-7

import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
import java.util.List;

public class RegexDemo {
    public static List<String> process(String str) {
        List<String> result = new ArrayList<>();
        String[] parts = str.split(" ");

        String reg1 = "^(?=.*[a-zA-Z])(?=.*\\d)[a-zA-Z\\d-]{2,8}$";
        String reg2 = "^\\d{4,7}$";

        for (String part : parts) {
            if (Pattern.matches(reg1, part) || Pattern.matches(reg2, part)) {
                result.add(part);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        String[] arr = {
            "Aceite p04476",
            "sdighsg",
            "s4967xl",
            "v0-4985",
            "123",
            "1234568956",
            "45825"
        };

        List<String> finalList = new ArrayList<>();
        for (String s : arr) {
            finalList.addAll(process(s));
        }
        System.out.println(finalList);
    }
}

输出：[p04476, s4967xl, v0-4985, 45825]

六、Java 集合框架：存储数据的核心

Java 集合是开发必用工具，替代数组，支持动态扩容、高效查找：

• List：有序可重复 → ArrayList、LinkedList
• Set：无序不可重复 → HashSet、TreeSet
• Map：键值对 → HashMap、TreeMap

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CollectionDemo {
    public static void main(String[] args) {
        // List
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Spring");
        list.add("MySQL");
        System.out.println(list);

        // Map
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 20);
        map.put("李四", 25);
        System.out.println(map.get("张三"));
    }
}

七、Java 面向对象：封装、继承、多态

Java 是纯面向对象语言，一切皆对象：

// 父类
class Person {
    String name;
    public void say() {
        System.out.println("我是人");
    }
}

// 子类
class Student extends Person {
    @Override
    public void say() {
        System.out.println("我是学生：" + name);
    }
}

public class OopDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "小明";
        s.say();
    }
}

三大特性：

• 封装：隐藏内部实现，暴露接口
• 继承：代码复用
• 多态：父类引用指向子类对象

八、Java 异常处理：保证程序稳定运行

Java 强制异常处理，避免程序崩溃：

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int a = 1 / 0;
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } finally {
            System.out.println("最终一定执行");
        }
    }
}

• try：监控代码
• catch：捕获异常
• finally：释放资源

九、Java vs Python：核心区别

很多同学会对比 Java 与 Python，这里做清晰总结：

特性	Java	Python
执行效率	高，编译型	较低，解释型
多线程	无 GIL，真正并行	有 GIL，适合 IO
语法	严谨，代码量大	简洁，易上手
应用	后端、高并发、大数据	脚本、AI、数据分析
企业需求	极多，岗位最多	多，偏向自动化

简单说：

• 做高并发后端、微服务、大数据 → 选 Java
• 做自动化、爬虫、AI、快速脚本 → 选 Python

十、总结：Java 学习路线

本文覆盖 Java 最核心、最实用的知识点：

1. 基础语法与运行机制
2. 多线程（Thread、Runnable、线程池）
3. IO 文件操作
4. 注解 + 反射（模拟装饰器）
5. 正则表达式
6. 集合框架
7. 面向对象
8. 异常处理

掌握这些内容，你已经具备Java 初级开发工程师的核心能力，可以直接学习 Spring Boot、Spring Cloud、MySQL 等企业级技术栈。

Java 生态庞大，但基础永远是根。把本文代码全部手动敲一遍，理解每一行的作用，你会发现 Java 并没有想象中难。坚持练习，从简单程序到完整项目，你也能成为优秀的 Java 工程师。