java编程菜鸟教程

官网:www.xservx.com|备案号:蜀ICP备2026035467号-3|专注Java零基础学习路径

一、java编程菜鸟教程:从零开启编程之旅

欢迎来到java编程菜鸟教程——这里不是高深理论的堆砌场,而是专为编程新手设计的Java学习起点。本教程以零基础可理解为第一原则,摒弃“你该懂这个”的傲慢姿态,用生活化类比+可运行代码+常见错误解析,带您逐步跨越编程门槛。

为何选择Java作为入门语言?理由如下:

本教程内容覆盖:Java开发环境搭建 → 核心语法(变量、运算符、流程控制)→ 面向对象三大特性(封装、继承、多态)→ 常用类库(String、Math、Arrays、Date)→ 集合框架(List、Set、Map)→ 异常处理 → 多线程编程 → IO流 → 网络编程基础 → JDBC数据库连接 → Web开发入门(Servlet+JSP)→ Spring框架初探 → 开发工具推荐 → 面试高频考点。全链条打通,拒绝碎片化学习。

特别提醒:编程是实践性极强的技能!请务必做到:
① 每学一个概念,立即动手写代码验证;
② 代码报错时,先独立调试(看报错行号、理解报错信息),再查资料;
③ 建立个人代码笔记库(推荐使用Typora+Markdown),记录易错点与优化思路。

💡 菜鸟常见误区

“看懂了=会了”——这是最大陷阱!理解原理和能独立写出可运行代码是两回事。建议:每节学完后,不看原文,独立重写示例代码,若能完成,才算真正掌握。

二、环境搭建:第一步决定能否走得稳

很多初学者卡在环境配置环节,反复重装系统。本节提供经过实测的稳定方案,确保99%成功率。

2.1 安装JDK(Java Development Kit)

JDK是Java开发的核心工具包,包含编译器(javac)、运行环境(JRE)、标准类库。

推荐版本:JDK 17(长期支持版,企业主流选择)
下载地址:Eclipse Temurin 17(开源、稳定、无广告)

安装步骤(以Windows为例):

  1. 下载.msi安装包,双击运行;
  2. 安装路径建议:C:\Program Files\Eclipse Adoptium\jdk-17.x-hotspot(避免空格/中文路径);
  3. 安装时勾选“Set JAVA_HOME variable”自动配置环境变量;
  4. 打开命令提示符,输入:java -version 和 javac -version,均显示版本号即成功。

⚠️ 环境配置失败排查

  • 命令行显示“不是内部或外部命令”:未配置PATH变量;
  • 运行代码时报错“找不到或无法加载主类”:检查类名与文件名是否完全一致(大小写敏感!);
  • IDEA提示“JDK不存在”:在File → Project Structure → SDKs中手动指定JDK路径。

2.2 选择开发工具(IDE)

推荐三款主流工具,按新手友好度排序:

  1. IntelliJ IDEA Community Edition(免费版)
    优势:智能提示强、自动补全准、错误提示及时;
    下载:https://www.jetbrains.com/idea/download/
    注意:安装时选择Community(免费),非Ultimate(付费)。
  2. Eclipse IDE
    老牌工具,插件丰富;下载:https://www.eclipse.org/downloads/
    配置较繁琐,适合后续进阶使用。
  3. VS Code + Java Extension Pack
    轻量级编辑器,启动快;需手动配置JDK路径,适合熟悉命令行者。

2.3 编写第一个程序:Hello World

打开IDEA,创建新项目:File → New → Project → Java → 项目名:HelloJava → Finish。

右键src → New → Java Class → 名称:HelloWorld

输入以下代码并保存:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("欢迎来到java编程菜鸟教程!");
        System.out.println("我是第" + 1 + "个Hello World!");
    }
}

点击绿色▶️运行按钮,或右键 → Run 'HelloWorld.main()',控制台输出:

欢迎来到java编程菜鸟教程!
我是第1个Hello World!

关键概念解析:

🔍 思考题

将System.out.println("Hello");改为System.out.print("Hello");,运行结果有何不同?
答案:println自动换行,print不换行。

三、核心语法:构建编程思维基石

3.1 数据类型与变量

Java是强类型语言——变量类型在声明时确定,不可随意改变。

数据类型 说明 占字节数 示例
byte 1字节整数 1 byte b = 127;
short 2字节整数 2 short s = 32767;
int 4字节整数(最常用) 4 int age = 25;
long 8字节整数 8 long money = 999999999999L;
float 4字节单精度浮点 4 float price = 9.99f;
double 8字节双精度浮点(最常用) 8 double pi = 3.1415926;
char 字符(2字节Unicode) 2 char gender = '男';
boolean 布尔值(true/false) 1位 boolean isPass = true;
String 字符串(引用类型) 变长 String name = "张三";

变量命名规范:

3.2 运算符与表达式

算术运算符:+ - * / % ++ --
注意:/整数除法取整(7 / 2 = 3),%取余(7 % 2 = 1)。

关系运算符:== != > < >= <=
注意:==比较值(基本类型)或引用(地址),equals()比较内容(字符串)。

逻辑运算符:&& || !
短路特性:&&左侧为false时不再计算右侧;||左侧为true时不再计算右侧。

赋值运算符:= += -= *= /= %=
示例:count += 5;等价于count = count + 5;

3.3 流程控制

if-else结构:

int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

switch语句(JDK 7+支持字符串):

String day = "星期三";
switch (day) {
    case "星期一":
        System.out.println("周一");
        break;
    case "星期三":
        System.out.println("周三");
        break;
    default:
        System.out.println("其他");
}

循环结构:

示例:打印9×9乘法表:

for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + "×" + i + "=" + (i*j) + "\t");
    }
    System.out.println();
}

输出:

1×1=1
1×2=2	2×2=4
1×3=3	2×3=6	3×3=9
...(省略)

💡 调试技巧

使用IDEA断点调试:
① 在代码行左侧点击添加红点(断点);
② 点击🐞运行 → 程序暂停在断点处;
③ 查看变量值、单步执行(F8)、查看调用栈(F7)。

四、面向对象编程:从“写代码”到“建模型”

面向对象(OOP)是Java的灵魂。核心思想:把现实世界抽象为对象,对象拥有属性和行为。

4.1 类与对象

类(Class):模板,定义一类事物的共性(属性+方法);
对象(Object):具体实例,由类创建。

示例:学生管理系统

// 学生类
public class Student {
    // 属性(成员变量)
    String name;
    int age;
    String studentId;
    // 方法(行为)
    public void study(String course) {
        System.out.println(name + "正在学习:" + course);
    }
    public void introduce() {
        System.out.println("大家好,我是" + name + ",今年" + age + "岁,学号" + studentId);
    }
}
// 测试类
public class TestStudent {
    public static void main(String[] args) {
        // 创建对象:new 类名()
        Student s1 = new Student();
        s1.name = "李明";
        s1.age = 18;
        s1.studentId = "2025001";
        s1.introduce(); // 输出:大家好,我是李明,今年18岁,学号2025001
        s1.study("Java编程"); // 输出:李明正在学习:Java编程
    }
}

4.2 三大特性

① 封装(Encapsulation):
将属性私有化(private),通过公有方法(getter/setter)访问,保护数据安全。

public class Student {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            System.out.println("年龄不合法!");
        }
    }
}

② 继承(Inheritance):
子类复用父类代码,扩展新功能(extends)。

// 父类
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
// 子类
public class Dog extends Animal {
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
    // 新增方法
    public void bark() {
        System.out.println("汪汪!");
    }
}
// 测试
public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();   // 输出:狗啃骨头(重写后的方法)
        d.bark();  // 输出:汪汪!
    }
}

③ 多态(Polymorphism):
同一操作作用于不同对象,产生不同效果。核心:父类引用指向子类对象。

Animal a1 = new Dog(); // 父类引用指向子类对象
Animal a2 = new Cat();
a1.eat(); // 调用的是Dog的eat()方法
a2.eat(); // 调用的是Cat的eat()方法

前提条件:

🔍 多态的价值

降低代码耦合度,提高扩展性。例如:
List<Animal> animals = new ArrayList<>();
可同时存Dog、Cat对象,统一调用eat()方法,无需判断类型。

五、集合框架:高效存储与操作数据

数组长度固定、类型单一,Java集合框架提供动态、灵活的数据结构。

5.1 Collection体系

List(有序、可重复):

Set(无序、不可重复):

5.2 Map(键值对集合)

常用实现:

5.3 实战:学生信息管理(集合版)

import java.util.*;
public class StudentManager {
    public static void main(String[] args) {
        // 使用List存储学生对象
        List<Student> students = new ArrayList<>();
        // 添加学生
        students.add(new Student("张三", 19, "2025001"));
        students.add(new Student("李四", 20, "2025002"));
        students.add(new Student("王五", 18, "2025003"));
        // 遍历输出
        for (Student s : students) {
            s.introduce();
        }
        // 查找:找出年龄最大的学生
        Student maxAgeStudent = students.get(0);
        for (Student s : students) {
            if (s.getAge() > maxAgeStudent.getAge()) {
                maxAgeStudent = s;
            }
        }
        System.out.println("年龄最大的是:" + maxAgeStudent.getName());
        // 使用Map:学号→学生对象
        Map<String, Student> map = new HashMap<>();
        for (Student s : students) {
            map.put(s.getStudentId(), s);
        }
        System.out.println("学号2025002的学生是:" + map.get("2025002").getName());
    }
}

💡 集合选择指南

  • 需要有序且可重复 → ArrayList(常用)或 LinkedList(频繁增删);
  • 需要去重 → HashSet;
  • 需要键值对 → HashMap;
  • 需要排序 → TreeMap或TreeSet。

六、多线程编程:提升程序并发性能

单线程程序像单车道公路,多线程像多车道,可同时处理多个任务。

6.1 创建线程的两种方式

① 继承Thread类:

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程A:" + i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程(调用run方法)
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程:" + i);
        }
    }
}

② 实现Runnable接口(推荐):

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程B:" + i);
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        Thread t2 = new Thread(new MyRunnable());
        t2.start();
    }
}

为什么推荐Runnable?:
① 避免单继承局限;
② 更适合资源共享(多个线程共享同一Runnable实例)。

6.2 线程同步:解决并发安全问题

问题场景:多个线程同时操作同一资源(如售票),导致数据错乱。

public class TicketSeller implements Runnable {
    private int tickets = 10;
    @Override
    public void run() {
        while (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "张票");
            tickets--;
        }
    }
}
public class TestTicket {
    public static void main(String[] args) {
        TicketSeller seller = new TicketSeller();
        new Thread(seller, "窗口1").start();
        new Thread(seller, "窗口2").start();
        new Thread(seller, "窗口3").start();
    }
}

可能输出:窗口1卖出第10张票 → 窗口2卖出第10张票(重复!)

解决方案:同步代码块

while (tickets > 0) {
    synchronized (this) { // 同步监视器:this(当前对象)
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "张票");
            tickets--;
        }
    }
}

6.3 线程通信:等待/通知机制

经典案例:生产者-消费者

public class Resource {
    private int data;
    private boolean hasData = false;
    public synchronized void produce(int value) throws InterruptedException {
        while (hasData) {
            wait(); // 等待消费者消费
        }
        data = value;
        hasData = true;
        System.out.println("生产:" + data);
        notify(); // 通知消费者
    }
    public synchronized int consume() throws InterruptedException {
        while (!hasData) {
            wait(); // 等待生产者生产
        }
        hasData = false;
        System.out.println("消费:" + data);
        notify(); // 通知生产者
        return data;
    }
}

🔍 线程生命周期

NEW → RUNNABLE → BLOCKED → WAITING → TIMED_WAITING → TERMINATED
重点掌握:start()启动线程;sleep()休眠;join()等待其他线程执行完毕。

七、IO流:文件与数据的搬运工

IO(Input/Output)用于处理数据的输入输出,如读写文件、网络传输。

7.1 字节流 vs 字符流

类型 基类 适用场景 示例
字节流 InputStream、OutputStream 二进制数据(图片、音频、视频) FileInputStream
字符流 Reader、Writer 文本数据(自动处理编码) FileReader

7.2 文件读写实战

写入文本文件:

import java.io.*;
public class FileWriterDemo {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("hello.txt")) {
            fw.write("欢迎来到java编程菜鸟教程!\n");
            fw.write("IO流是必经之路!");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("写入完成!");
    }
}

读取文本文件:

import java.io.*;
public class FileReaderDemo {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("hello.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

复制图片文件(字节流):

try (FileInputStream fis = new FileInputStream("input.jpg");
     FileOutputStream fos = new FileOutputStream("output.jpg")) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, len);
    }
}

💡 NIO(New IO)简介

JDK 1.4引入的非阻塞IO,性能更高,适用于高并发场景(如Web服务器)。核心类:FileChannel、ByteBuffer。本教程暂不展开,后续进阶学习。

八、网络编程:让程序“联网说话”

网络编程核心是TCP/IP协议,Java提供java.net包简化开发。

8.1 基于TCP的Socket通信

服务器端(Server):监听端口,等待客户端连接

import java.io.*;
import java.net.*;
public class TcpServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8888)) {
            System.out.println("服务器启动,等待客户端连接...");
            Socket socket = serverSocket.accept(); // 阻塞等待
            System.out.println("客户端已连接:" + socket.getInetAddress());
            // 接收数据
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String msg = br.readLine();
            System.out.println("收到消息:" + msg);
            // 发送响应
            PrintWriter pw = new PrintWriter(socket.getOutputStream(), true);
            pw.println("服务器已收到:" + msg);
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端(Client):连接服务器

import java.io.*;
import java.net.*;
public class TcpClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("127.0.0.1", 8888)) {
            // 发送数据
            PrintWriter pw = new PrintWriter(socket.getOutputStream(), true);
            pw.println("你好,服务器!");
            // 接收响应
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String response = br.readLine();
            System.out.println("服务器回复:" + response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8.2 基于UDP的简单通信

无连接、不可靠,但开销小,适用于实时性要求高(如视频通话)。

// 服务器端
DatagramSocket socket = new DatagramSocket(9999);
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet); // 接收数据
String msg = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到UDP消息:" + msg);
// 客户端
DatagramSocket socket = new DatagramSocket();
String msg = "UDP测试";
byte[] data = msg.getBytes();
InetAddress address = InetAddress.getByName("127.0.0.1");
DatagramPacket packet = new DatagramPacket(data, data.length, address, 9999);
socket.send(packet); // 发送数据
socket.close();

🔍 HTTP协议基础

Java中通过HttpURLConnection或第三方库(OkHttp、Apache HttpClient)发起HTTP请求,实现与Web服务器交互(如调用API)。本节仅作概念铺垫,后续Web开发深入。

九、JDBC:连接数据库的桥梁

JDBC(Java Database Connectivity)是Java访问数据库的标准API。

9.1 连接MySQL数据库

步骤:

  1. 下载MySQL JDBC驱动:mysql-connector-java;
  2. 将.jar包添加到项目依赖(IDEA:右键项目 → Add as Library);
  3. 编写连接代码。
import java.sql.*;
public class JdbcDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb?useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            System.out.println("数据库连接成功!");
            // 执行查询
            String sql = "SELECT id, name, age FROM student";
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(sql);
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println(id + " - " + name + " (" + age + ")");
            }
            // 执行插入
            String insertSql = "INSERT INTO student (name, age) VALUES (?, ?)";
            PreparedStatement pstmt = conn.prepareStatement(insertSql);
            pstmt.setString(1, "赵六");
            pstmt.setInt(2, 22);
            int rows = pstmt.executeUpdate();
            System.out.println("插入成功,影响行数:" + rows);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

9.2 防止SQL注入:PreparedStatement

使用PreparedStatement代替Statement,参数用?占位,自动转义特殊字符,杜绝SQL注入风险。

💡 连接池(Druid)简介

频繁创建/关闭数据库连接耗性能。连接池(如Druid)预创建连接,复用连接,大幅提升效率。后续项目实战中详解。

十、Web基础:从后端到前端的入门

JavaWeb开发核心三件套:Servlet + JSP + Tomcat。

10.1 Servlet:处理请求的核心组件

编写Servlet:

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;
import java.io.*;
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("<html><body>");
        out.println("<h1>欢迎来到Java Web世界!</h1>");
        out.println("<p>请求路径:" + request.getRequestURI() + "</p>");
        out.println("</body></html>");
    }
}

配置Tomcat服务器:

  1. 下载Apache Tomcat:https://tomcat.apache.org/download-90.cgi;
  2. 在IDEA中配置Server(Run → Edit Configurations → + → Tomcat Server);
  3. 部署项目(Deployment选项卡添加Artifact);
  4. 启动Tomcat,访问:http://localhost:8080/your-app/hello。

10.2 JSP:动态网页模板

JSP(Java Server Pages)可在HTML中嵌入Java代码。

index.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>JSP示例</title></head>
<body>
<h2>当前时间:<%= new java.util.Date() %></h2>
<%
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
%>
<p>1到10的和:<%= sum %></p>
</body>
</html>

🔍 MVC模式

JavaWeb开发经典模式:
Model(数据模型,如JavaBean) + View(视图,JSP) + Controller(控制器,Servlet)
分工明确,便于维护。

十一、Spring框架:企业级开发基石

Spring是Java生态的绝对核心,简化企业级应用开发。

11.1 核心概念

11.2 快速入门:Hello Spring

① 添加依赖(Maven)

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.39</version>
</dependency>

② 定义Bean

import org.springframework.stereotype.Component;
@Component("userService")
public class UserService {
    public void sayHello() {
        System.out.println("Hello from Spring!");
    }
}

③ 配置类 + 启动容器

import org.springframework.context.annotation.*;
import org.springframework.context.*;
@Configuration
@ComponentScan("com.example")
public class AppConfig {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        userService.sayHello(); // 输出:Hello from Spring!
        context.close();
    }
}

💡 Spring Boot简介

Spring Boot是Spring的快速开发框架,约定大于配置,内嵌Tomcat,一键启动,是当前主流选择。后续专项教程详解。

十二、开发工具进阶:提升效率的利器

12.1 Maven:项目构建与依赖管理

核心功能:

典型pom.xml片段

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.39</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
</dependencies>

12.2 Git:版本控制必备

核心命令

git init           # 初始化仓库
git add .          # 添加所有文件到暂存区
git commit -m "初始化项目"  # 提交到本地仓库
git remote add origin https://github.com/username/repo.git
git push -u origin master  # 推送到远程仓库

🔍 高效开发习惯

  • 提交信息写清楚(git commit -m "修复登录页面空指针异常");
  • 频繁提交(小步快跑);
  • 善用分支(git branch feature/login)。

十三、高频面试题:检验学习成果

整理Java面试常考知识点,助您从容应对技术面。

13.1 基础题

  1. ==和equals()的区别?
    → ==比较值(基本类型)或引用地址(对象);equals()默认比较地址,但String等类重写了该方法,比较内容。
  2. final、finally、finalize的区别?
    → final:修饰类(不可继承)、方法(不可重写)、变量(常量);finally:异常处理中的finally块;finalize:对象被回收前调用的方法(已过时)。
  3. 重载(Overload)和重写(Override)的区别?
    → 重载:同一类中方法名相同、参数列表不同;重写:子类重写父类方法,返回值、异常不能更严格。

13.2 进阶题

  1. HashMap的底层原理?
    → JDK 1.7:数组+链表;JDK 1.8:数组+链表+红黑树(链表长度>8且数组长度≥64时转红黑树)。
  2. 线程池的核心参数?
    → corePoolSize、maximumPoolSize、keepAliveTime、workQueue、ThreadFactory、RejectedExecutionHandler。
  3. Spring事务传播机制有哪些?
    → REQUIRED(默认)、REQUIRES_NEW、SUPPORTS、NOT_SUPPORTED等7种。

💡 面试建议

  • 先说结论,再展开;
  • 结合项目经验举例;
  • 不懂的题诚恳承认,避免胡编乱造。

十四、学习资源推荐:延伸你的学习半径

14.1 官方资源

14.2 社区与平台

14.3 书籍推荐

《Java编程思想》

经典理论书,适合建立系统知识框架。阅读建议:先通读,再精读面向对象章节。

《Effective Java》

第3版,每条建议配代码示例。建议:边学边练,每章做笔记。

《Spring Boot实战》

快速上手企业级开发,配套代码仓库丰富。

《深入理解Java虚拟机》

进阶必读,详解JVM内存模型、垃圾回收机制。

💡 学习路径建议

基础语法 → 面向对象 → 集合/IO/多线程 → Web基础 → Spring框架 → 项目实战
切忌盲目追求“学完所有再做项目”,应在学习中穿插小项目(如学完集合就写学生管理系统)。