Java编程入门到精通：精选学习资料与实战技巧全解析

引言

Java作为一门历史悠久且应用广泛的编程语言，至今仍在企业级开发、安卓应用、大数据处理等领域占据重要地位。对于初学者而言，Java的入门门槛相对较低，但要达到精通水平，需要系统性的学习路径、优质的学习资料以及大量的实战练习。本文将从Java的基础知识、进阶概念、精选学习资料、实战技巧以及常见问题解决等方面进行全面解析，帮助读者从入门到精通，逐步提升编程能力。

第一部分：Java基础入门

1.1 Java语言简介

Java是一种面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年发布。其核心特点包括：

跨平台性：通过Java虚拟机（JVM）实现“一次编写，到处运行”。
面向对象：支持封装、继承、多态等特性。
健壮性：自动内存管理（垃圾回收机制）和异常处理机制。
安全性：提供安全机制，防止恶意代码破坏系统。

1.2 开发环境搭建

要开始Java编程，首先需要安装以下工具：

JDK（Java Development Kit）：推荐使用JDK 11或JDK 17（长期支持版本）。
IDE（集成开发环境）：推荐使用IntelliJ IDEA（社区版免费）或Eclipse。
构建工具：Maven或Gradle（用于项目依赖管理）。

安装步骤示例（以Windows系统为例）：

访问Oracle官网或Adoptium下载JDK安装包。
运行安装程序，设置安装路径（如C:\Program Files\Java\jdk-17）。
配置环境变量：
- 新建系统变量JAVA_HOME，值为JDK安装路径。
- 在Path变量中添加%JAVA_HOME%\bin。
验证安装：打开命令提示符，输入java -version和javac -version，查看版本信息。

1.3 Java基础语法

Java语法与C/C++类似，但更简洁。以下是核心语法点：

变量与数据类型

Java有8种基本数据类型：

整型：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean

示例代码：

public class HelloWorld {
    public static void main(String[] args) {
        int age = 25; // 整型变量
        double salary = 5000.5; // 浮点型变量
        char grade = 'A'; // 字符型变量
        boolean isStudent = true; // 布尔型变量
        
        System.out.println("年龄: " + age);
        System.out.println("薪资: " + salary);
        System.out.println("等级: " + grade);
        System.out.println("是否为学生: " + isStudent);
    }
}

控制流语句

条件语句：if-else、switch
循环语句：for、while、do-while

示例代码：

public class ControlFlow {
    public static void main(String[] args) {
        int score = 85;
        
        // if-else 示例
        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else {
            System.out.println("需努力");
        }
        
        // for 循环示例
        for (int i = 1; i <= 5; i++) {
            System.out.println("当前计数: " + i);
        }
        
        // switch 示例
        int dayOfWeek = 3;
        switch (dayOfWeek) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("其他");
        }
    }
}

方法（函数）

Java中的方法用于封装可重用的代码块。

示例代码：

public class MethodExample {
    // 定义一个方法：计算两个整数的和
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        int result = add(10, 20);
        System.out.println("10 + 20 = " + result);
    }
}

1.4 面向对象编程（OOP）基础

Java是面向对象的语言，核心概念包括类、对象、封装、继承和多态。

类与对象

类：对象的蓝图，定义对象的属性和方法。
对象：类的实例。

示例代码：

// 定义一个Person类
class Person {
    // 属性（成员变量）
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 方法
    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁。");
    }
    
    // Getter和Setter方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

public class ObjectExample {
    public static void main(String[] args) {
        // 创建Person对象
        Person person = new Person("张三", 25);
        person.introduce();
        
        // 修改属性
        person.setAge(26);
        System.out.println("修改后的年龄: " + person.getAge());
    }
}

封装

封装是将对象的属性和方法隐藏起来，只通过公共接口访问。使用private修饰符实现。

继承

继承允许子类继承父类的属性和方法，使用extends关键字。

示例代码：

// 父类
class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

// 子类
class Dog extends Animal {
    public void bark() {
        System.out.println("狗在叫");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自父类的方法
        dog.bark(); // 子类自己的方法
    }
}

多态

多态允许父类引用指向子类对象，实现方法的重写和重载。

示例代码：

// 父类
class Shape {
    public void draw() {
        System.out.println("绘制一个形状");
    }
}

// 子类
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制一个圆形");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制一个矩形");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        
        shape1.draw(); // 输出：绘制一个圆形
        shape2.draw(); // 输出：绘制一个矩形
    }
}

第二部分：Java进阶知识

2.1 集合框架

Java集合框架提供了多种数据结构，如列表、集合、映射等。

List（列表）

ArrayList：基于动态数组，查询快，增删慢。
LinkedList：基于双向链表，增删快，查询慢。

示例代码：

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

public class ListExample {
    public static void main(String[] args) {
        // ArrayList 示例
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Java");
        arrayList.add("Python");
        arrayList.add("C++");
        System.out.println("ArrayList: " + arrayList);
        
        // LinkedList 示例
        List<String> linkedList = new LinkedList<>();
        linkedList.add("Apple");
        linkedList.add("Banana");
        linkedList.add("Cherry");
        System.out.println("LinkedList: " + linkedList);
    }
}

Set（集合）

HashSet：基于哈希表，元素无序，不允许重复。
TreeSet：基于红黑树，元素有序，不允许重复。

示例代码：

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        // HashSet 示例
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Java");
        hashSet.add("Python");
        hashSet.add("Java"); // 重复元素不会被添加
        System.out.println("HashSet: " + hashSet);
        
        // TreeSet 示例
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(1);
        treeSet.add(3);
        System.out.println("TreeSet: " + treeSet); // 输出有序集合 [1, 3, 5]
    }
}

Map（映射）

HashMap：基于哈希表，键值对存储，键无序。
TreeMap：基于红黑树，键有序。

示例代码：

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapExample {
    public static void main(String[] args) {
        // HashMap 示例
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Java", 100);
        hashMap.put("Python", 80);
        hashMap.put("C++", 90);
        System.out.println("HashMap: " + hashMap);
        
        // TreeMap 示例
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Java", 100);
        treeMap.put("Python", 80);
        treeMap.put("C++", 90);
        System.out.println("TreeMap: " + treeMap); // 按键排序
    }
}

2.2 异常处理

Java通过try-catch块处理异常，确保程序健壮性。

示例代码：

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // 数组越界异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组索引越界: " + e.getMessage());
        } finally {
            System.out.println("无论是否发生异常，都会执行finally块");
        }
        
        // 自定义异常
        try {
            int age = -5;
            if (age < 0) {
                throw new IllegalArgumentException("年龄不能为负数");
            }
        } catch (IllegalArgumentException e) {
            System.out.println("自定义异常: " + e.getMessage());
        }
    }
}

2.3 输入输出（I/O）流

Java I/O流用于处理文件读写和网络通信。

字节流

InputStream和OutputStream：用于处理字节数据。

示例代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
            System.out.println("文件复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

Reader和Writer：用于处理字符数据，支持编码转换。

示例代码：

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

public class CharStreamExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt");
             FileWriter fw = new FileWriter("output.txt")) {
            
            int data;
            while ((data = fr.read()) != -1) {
                fw.write(data);
            }
            System.out.println("字符文件复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.4 多线程编程

Java通过Thread类和Runnable接口实现多线程。

创建线程

示例代码：

// 方式1：继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
        }
    }
}

// 方式2：实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        // 使用Thread类
        MyThread thread1 = new MyThread();
        thread1.start();
        
        // 使用Runnable接口
        MyRunnable runnable = new MyRunnable();
        Thread thread2 = new Thread(runnable);
        thread2.start();
    }
}

线程同步

使用synchronized关键字或Lock接口实现线程安全。

示例代码：

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

public class SynchronizationExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        System.out.println("最终计数: " + counter.getCount()); // 输出2000
    }
}

2.5 Java 8+ 新特性

Java 8引入了函数式编程和流式API，极大提升了开发效率。

Lambda表达式

示例代码：

import java.util.Arrays;
import java.util.List;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        // 使用Lambda表达式遍历列表
        names.forEach(name -> System.out.println(name));
        
        // 使用方法引用
        names.forEach(System.out::println);
    }
}

Stream API

示例代码：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // 过滤偶数并收集到新列表
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        
        System.out.println("偶数: " + evenNumbers);
        
        // 计算平方和
        int sumOfSquares = numbers.stream()
                .map(n -> n * n)
                .reduce(0, Integer::sum);
        
        System.out.println("平方和: " + sumOfSquares);
    }
}

Optional类

示例代码：

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String name = "Alice";
        Optional<String> optionalName = Optional.ofNullable(name);
        
        // 如果值存在，执行操作
        optionalName.ifPresent(n -> System.out.println("名字: " + n));
        
        // 获取值或默认值
        String result = optionalName.orElse("Unknown");
        System.out.println("结果: " + result);
    }
}

第三部分：精选学习资料

3.1 官方文档与教程

Oracle Java官方文档：最权威的Java参考资料，涵盖语言规范、API文档等。
- 网址：https://docs.oracle.com/javase/8/docs/
Java Tutorials（Oracle）：官方教程，适合初学者。
- 网址：https://docs.oracle.com/javase/tutorial/
Java 17官方文档：最新版本特性。
- 网址：https://docs.oracle.com/en/java/javase/17/

3.2 经典书籍推荐

《Java核心技术卷I：基础知识》（Cay S. Horstmann著）：适合初学者，内容全面。
《Effective Java》（Joshua Bloch著）：深入讲解Java最佳实践，适合进阶。
《Java并发编程实战》（Brian Goetz等著）：多线程编程经典。
《深入理解Java虚拟机》（周志明著）：JVM原理与调优。

3.3 在线课程与平台

Coursera：提供多门Java课程，如“Java Programming and Software Engineering Fundamentals”。
Udemy：实战项目课程，如“Java Programming Masterclass”。
Bilibili：中文免费教程，如“尚硅谷Java零基础教程”。
慕课网：国内优质Java课程，如“Java从入门到精通”。

3.4 开源项目与社区

GitHub：搜索Java开源项目，如Spring Boot、Apache Commons等。
Stack Overflow：解决编程问题的社区。
Java官方论坛：Oracle社区论坛。
Reddit的r/java：讨论Java相关话题。

3.5 开发工具与IDE

IntelliJ IDEA：功能强大，社区版免费，适合所有开发者。
Eclipse：开源免费，插件丰富。
VS Code：轻量级，通过插件支持Java开发。
Maven/Gradle：构建工具，管理项目依赖。

第四部分：实战技巧与项目实践

4.1 从简单项目开始

项目1：控制台计算器

功能：实现加、减、乘、除运算。 代码示例：

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("请输入第一个数字:");
        double num1 = scanner.nextDouble();
        
        System.out.println("请输入运算符 (+, -, *, /):");
        char operator = scanner.next().charAt(0);
        
        System.out.println("请输入第二个数字:");
        double num2 = scanner.nextDouble();
        
        double result = 0;
        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("错误：除数不能为零");
                    return;
                }
                break;
            default:
                System.out.println("错误：无效的运算符");
                return;
        }
        
        System.out.println("结果: " + result);
        scanner.close();
    }
}

项目2：学生管理系统

功能：实现学生信息的增删改查。 代码示例：

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

class Student {
    private String id;
    private String name;
    private int age;
    
    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    // Getter和Setter方法
    public String getId() { return id; }
    public String getName() { return name; }
    public int getAge() { return age; }
    
    @Override
    public String toString() {
        return "ID: " + id + ", 姓名: " + name + ", 年龄: " + age;
    }
}

public class StudentManagementSystem {
    private static List<Student> students = new ArrayList<>();
    private static Scanner scanner = new Scanner(System.in);
    
    public static void main(String[] args) {
        while (true) {
            System.out.println("\n=== 学生管理系统 ===");
            System.out.println("1. 添加学生");
            System.out.println("2. 删除学生");
            System.out.println("3. 修改学生");
            System.out.println("4. 查询学生");
            System.out.println("5. 显示所有学生");
            System.out.println("6. 退出");
            System.out.print("请选择操作: ");
            
            int choice = scanner.nextInt();
            scanner.nextLine(); // 消耗换行符
            
            switch (choice) {
                case 1:
                    addStudent();
                    break;
                case 2:
                    deleteStudent();
                    break;
                case 3:
                    updateStudent();
                    break;
                case 4:
                    queryStudent();
                    break;
                case 5:
                    displayAllStudents();
                    break;
                case 6:
                    System.out.println("系统已退出");
                    scanner.close();
                    return;
                default:
                    System.out.println("无效选择，请重新输入");
            }
        }
    }
    
    private static void addStudent() {
        System.out.print("请输入学生ID: ");
        String id = scanner.nextLine();
        System.out.print("请输入学生姓名: ");
        String name = scanner.nextLine();
        System.out.print("请输入学生年龄: ");
        int age = scanner.nextInt();
        scanner.nextLine();
        
        students.add(new Student(id, name, age));
        System.out.println("学生添加成功");
    }
    
    private static void deleteStudent() {
        System.out.print("请输入要删除的学生ID: ");
        String id = scanner.nextLine();
        
        boolean found = false;
        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).getId().equals(id)) {
                students.remove(i);
                found = true;
                System.out.println("学生删除成功");
                break;
            }
        }
        
        if (!found) {
            System.out.println("未找到该学生");
        }
    }
    
    private static void updateStudent() {
        System.out.print("请输入要修改的学生ID: ");
        String id = scanner.nextLine();
        
        boolean found = false;
        for (Student student : students) {
            if (student.getId().equals(id)) {
                System.out.print("请输入新姓名: ");
                String newName = scanner.nextLine();
                System.out.print("请输入新年龄: ");
                int newAge = scanner.nextInt();
                scanner.nextLine();
                
                // 由于Student类没有setter方法，这里需要重新创建对象
                // 实际开发中应添加setter方法
                students.remove(student);
                students.add(new Student(id, newName, newAge));
                
                found = true;
                System.out.println("学生信息更新成功");
                break;
            }
        }
        
        if (!found) {
            System.out.println("未找到该学生");
        }
    }
    
    private static void queryStudent() {
        System.out.print("请输入要查询的学生ID: ");
        String id = scanner.nextLine();
        
        boolean found = false;
        for (Student student : students) {
            if (student.getId().equals(id)) {
                System.out.println(student);
                found = true;
                break;
            }
        }
        
        if (!found) {
            System.out.println("未找到该学生");
        }
    }
    
    private static void displayAllStudents() {
        if (students.isEmpty()) {
            System.out.println("没有学生记录");
        } else {
            System.out.println("\n所有学生信息:");
            for (Student student : students) {
                System.out.println(student);
            }
        }
    }
}

4.2 进阶项目：Web应用开发

使用Spring Boot构建简单博客系统

步骤：

创建项目：使用Spring Initializr（https://start.spring.io/）生成项目，选择依赖：Spring Web、Spring Data JPA、H2 Database。
实体类：定义博客文章实体。 “`java import javax.persistence.*;

@Entity @Table(name = “articles”) public class Article {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;

   @Column(nullable = false)
   private String title;

   @Column(columnDefinition = "TEXT")
   private String content;

   private String author;

   // 构造方法、Getter和Setter省略

}

3. **Repository接口**：继承`JpaRepository`。
   ```java
   import org.springframework.data.jpa.repository.JpaRepository;
   
   public interface ArticleRepository extends JpaRepository<Article, Long> {
   }

Controller：处理HTTP请求。 “`java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController @RequestMapping(”/api/articles”) public class ArticleController {

   @Autowired
   private ArticleRepository articleRepository;

   @GetMapping
   public List<Article> getAllArticles() {
       return articleRepository.findAll();
   }

   @PostMapping
   public Article createArticle(@RequestBody Article article) {
       return articleRepository.save(article);
   }

   @GetMapping("/{id}")
   public Article getArticleById(@PathVariable Long id) {
       return articleRepository.findById(id).orElse(null);
   }

   @PutMapping("/{id}")
   public Article updateArticle(@PathVariable Long id, @RequestBody Article articleDetails) {
       return articleRepository.findById(id).map(article -> {
           article.setTitle(articleDetails.getTitle());
           article.setContent(articleDetails.getContent());
           article.setAuthor(articleDetails.getAuthor());
           return articleRepository.save(article);
       }).orElse(null);
   }

   @DeleteMapping("/{id}")
   public void deleteArticle(@PathVariable Long id) {
       articleRepository.deleteById(id);
   }

} “`

运行与测试：启动应用，使用Postman或浏览器测试API。

4.3 调试与优化技巧

使用IDE调试：设置断点，单步执行，查看变量值。
日志记录：使用SLF4J和Logback记录日志。
性能分析：使用JProfiler或VisualVM分析性能瓶颈。
代码优化：避免不必要的对象创建，使用缓存，优化算法。

第五部分：常见问题与解决方案

5.1 环境配置问题

问题：java: command not found。
- 解决方案：检查环境变量JAVA_HOME和Path是否配置正确。
问题：JDK版本不兼容。
- 解决方案：统一使用JDK 11或17，避免混合使用不同版本。

5.2 编译与运行错误

问题：NoClassDefFoundError。
- 解决方案：检查类路径（Classpath）是否包含所需JAR包。
问题：NullPointerException。
- 解决方案：使用Optional类或空值检查避免空指针异常。

5.3 性能问题

问题：内存泄漏。
- 解决方案：使用WeakReference，及时释放资源，避免静态集合持有对象。
问题：线程死锁。
- 解决方案：避免嵌套锁，使用tryLock超时机制，或使用java.util.concurrent包中的高级并发工具。

5.4 代码规范与最佳实践

命名规范：类名使用大驼峰（PascalCase），变量名使用小驼峰（camelCase）。
注释规范：使用Javadoc注释公共方法和类。
代码复用：遵循DRY（Don’t Repeat Yourself）原则，使用设计模式（如单例、工厂、观察者模式）。

第六部分：持续学习与进阶路径

6.1 深入学习方向

JVM原理：学习内存模型、垃圾回收算法、字节码。
并发编程：深入研究java.util.concurrent包，掌握线程池、锁、原子类。
设计模式：掌握23种设计模式，并在项目中应用。
微服务架构：学习Spring Cloud、Dubbo等微服务框架。
大数据与Java：学习Hadoop、Spark等大数据框架的Java API。

6.2 参与开源项目

贡献代码：在GitHub上寻找感兴趣的Java项目，提交Pull Request。
阅读源码：阅读Spring、Netty、Guava等优秀开源项目的源码。
参加技术社区：参与Java用户组（JUG）活动，参加技术大会（如JavaOne）。

6.3 考取认证

Oracle Certified Professional, Java SE Programmer：Oracle官方认证，证明Java编程能力。
Spring Professional Certification：Spring框架认证，适合企业级开发。

结语

Java编程的学习是一个循序渐进的过程，从基础语法到高级特性，再到实战项目，每一步都需要扎实的理论知识和大量的实践。通过本文提供的精选学习资料和实战技巧，相信读者能够系统性地提升Java编程能力，最终达到精通水平。记住，编程之路没有捷径，唯有持续学习、不断实践，才能在技术的海洋中乘风破浪。

附录：常用资源链接

Oracle Java官方文档：https://docs.oracle.com/javase/8/docs/
Java Tutorials：https://docs.oracle.com/javase/tutorial/
GitHub Java开源项目：https://github.com/topics/java
Stack Overflow：https://stackoverflow.com/questions/tagged/java
Spring Boot官方文档：https://spring.io/projects/spring-boot

希望这篇文章能为你的Java学习之旅提供有价值的指导！