《Java 学习阶段总结：从面向对象到 Java 够用线，准备进入 Spring Boot》

前言

这是我重新学习 Java 后的第四篇学习记录。

前三篇主要记录了我重新捡起 Java 的过程。

第一篇，我记录了为什么重新开始学习 Java，以及接下来准备走的技术路线。

第二篇，主要重新学习了 Java 基础语法、方法、参数、返回值等内容，也开始改变自己的学习方式，从以前的“看懂代码”逐渐转向“自己尝试写代码”。

第三篇，则正式进入了 Java 面向对象部分，学习了：

类
对象
new
构造方法
this
private
getter / setter
封装

继续学习之后，我开始接触 Java 中更加重要的一部分：

继承
super
方法重写
多态
ArrayList
异常处理

到这里，我认为自己已经重新捡起了进入 Spring Boot 所需要的 Java 基础。

所以这一篇，我想把这一阶段做一个总结。

也意味着：

Java 基础“够用线”暂时告一段落。

接下来，我不会继续为了“学完所有 Java 知识”而停留在基础阶段，而是准备正式进入 Spring Boot 和真实后端项目。

一、为什么要给 Java 划一条“够用线”

重新学习 Java 的过程中，我慢慢意识到一个问题：

Java 本身的知识非常多。

如果一直按照：

“这个还没学，所以不能继续。”

的方式学习，很容易一直停留在 Java 基础阶段。

例如还有很多知识可以继续学习：

HashMap
Set
泛型
IO
多线程
反射
JVM
网络编程
设计模式
并发编程

这些内容以后当然都会有价值。

但是对于我现在的目标来说，并不需要把这些内容全部学完以后，才开始 Spring Boot。

我现在更希望采用：

先达到能够支撑实际开发的程度，然后在项目中继续补知识。

所以我给自己划了一条 Java “够用线”。

目标不是：

Java 全部学完。

而是：

能够看懂 Spring Boot 项目中的常见 Java 代码，并能够自己修改、补充和实现基本功能。

达到这个程度，就应该进入项目。

二、继承：开始理解类之间的关系

在面向对象之后，我继续学习了继承。

例如：

public class Student extends Person {

}

这里：

extends

表示 Student 继承 Person。

如果 Person 中存在：

public void eat(){

    System.out.println("吃饭");

}

那么 Student 继承 Person 后，就可以直接使用这个方法。

例如：

Student student = new Student();

student.eat();

即使 Student 自己没有定义 eat()，也可以调用。

通过练习，我开始理解：

继承的作用，是让子类可以复用父类已有的属性和方法，并在此基础上增加自己的内容。

例如：

Person
  ↓
Student

Person 可以表示所有人的共同特征。

Student 则可以在 Person 的基础上增加学生自己的内容。

三、super：子类如何调用父类

学习继承之后，我继续接触了 super。

例如：

public class Person {

    String name;

    public Person(String name){

        this.name = name;

    }

}

Student：

public class Student extends Person {

    int score;

    public Student(String name, int score){

        super(name);

        this.score = score;

    }

}

这里：

super(name);

调用的是父类的构造方法：

Person(String name)

而父类构造方法中又完成：

this.name = name;

所以我现在对它的理解是：

super(name) 不是简单地等于 this.name = name，而是调用父类构造方法，把初始化工作交给父类完成。

如果父类只有带参数的构造方法，那么子类构造方法中也需要正确调用父类构造方法。

通过这个练习，我开始更加理解父类和子类之间的关系。

四、方法重写：子类可以重新实现父类的方法

继承之后，我继续学习了方法重写。

例如 Person：

public class Person {

    public void show(){

        System.out.println("我是Person");

    }

}

Student：

public class Student extends Person {

    @Override
    public void show(){

        System.out.println("我是Student");

    }

}

这里 Student 重新实现了父类的 show()。

当创建 Student 对象并调用：

student.show();

执行的是 Student 中重写后的方法。

这让我理解了：

继承解决代码复用，重写允许子类根据自己的特点重新实现父类的方法。

五、多态：开始理解“同一个接口，不同实现”

继续学习之后，我接触到了多态。

最典型的代码：

Person person = new Student();

person.show();

这里左边是：

Person

右边真正创建出来的对象是：

Student

虽然变量类型是 Person，但是实际对象是 Student。

由于 Student 重写了 show()，所以调用：

person.show();

最终执行的是 Student 的 show()。

我现在对多态的核心理解是：

父类引用指向子类对象，同一个方法调用，根据实际对象不同执行不同的重写方法。

例如以后如果有：

Person p1 = new Student();

Person p2 = new Teacher();

Person p3 = new Worker();

它们都可以通过 Person 类型进行统一处理，而具体执行什么行为，由实际对象决定。

虽然现在还没有深入研究多态背后的底层实现，但我认为已经掌握了进入后端开发所需要的核心概念。

六、ArrayList：开始接触集合

之后继续学习 Java 集合中的 ArrayList。

之前学习数组的时候：

String[] array = new String[3];

数组长度创建之后基本固定。

而 ArrayList 可以更加方便地保存一组对象。

例如：

ArrayList<String> list = new ArrayList<>();

添加数据：

list.add("Java");

list.add("MySQL");

list.add("Spring Boot");

获取数据：

list.get(0);

删除数据：

list.remove(1);

获取集合大小：

list.size();

遍历：

for(int i = 0; i < list.size(); i++){

    System.out.println(list.get(i));

}

这一阶段我也再次遇到了下标的问题。

例如：

list.get(i)

这里的 i 才是当前遍历到的位置。

如果直接：

System.out.println(i);

打印出来的只是下标，而不是集合中的数据。

通过 ArrayList，我开始把之前学习的：

循环
下标
对象
类型

组合到了一起。

七、异常处理：程序出错以后怎么办

之后开始学习异常处理。

最简单的例子：

int a = 10;

int b = 0;

try{

    int result = a / b;

}catch(ArithmeticException e){

    System.out.println("发生异常");

}

如果直接执行：

10 / 0

程序会产生算术异常。

使用 try-catch 后，可以对异常进行处理。

我现在对三个关键部分的理解是：

try
↓
放可能出现异常的代码

catch
↓
捕获并处理异常

finally
↓
无论是否发生异常，最终都执行

例如：

try{

    int result = a / b;

}catch(ArithmeticException e){

    System.out.println("发生异常");

}finally{

    System.out.println("程序结束");

}

目前我没有继续深入学习 throw、throws 等更加细的异常知识。

原因也很简单：

现在先掌握 Spring Boot 开发需要的程度。

后面在真实项目中遇到，再继续补充。

八、第一次把这些知识真正串起来

单独学习这些知识的时候，每一个概念看起来都比较独立。

但是在综合练习中，我开始把它们放到了一起。

例如：

Person person = new Student("江江", 100);

这里同时使用了：

类
对象
构造方法
继承
super
多态

Student：

public class Student extends Person {

    int score;

    public Student(String name, int score){

        super(name);

        this.score = score;

    }

    @Override
    public void show(){

        System.out.println(this.name);

        System.out.println(this.score);

    }

}

然后再创建：

ArrayList<Person> list = new ArrayList<>();

将 Student 对象加入集合：

list.add(person);

遍历：

for(int i = 0; i < list.size(); i++){

    list.get(i).show();

}

最后再使用：

try{

    int result = 100 / 0;

}catch(ArithmeticException e){

    System.out.println("发生异常");

}

这样就把这一阶段学习的主要知识串联起来了。

九、综合练习过程中，我又发现了一些问题

这一阶段让我印象比较深的，不是某个知识点本身，而是自己写代码时暴露出来的问题。

例如一开始写构造方法的时候，我曾经写成：

public void Student(...)

后来才发现：

构造方法没有返回值类型，不能写 void。

正确形式应该是：

public Student(...)

还有：

super(name) 应该放在子类构造方法中，而不是放到普通方法里面。

另外在使用：

ArrayList<Person>

时，集合里面需要保存的是 Person 类型对象，而不是直接添加一个 String。

遍历集合时，如果写：

System.out.println(i);

得到的是下标，而不是对象本身。

这些错误其实都不复杂。

但它们让我越来越清楚：

真正的编程能力，不是把知识点背下来，而是面对代码时能够判断自己哪里写错了。

十、现在我对 Java “够用线”的理解

经过这一阶段重新学习，我现在认为自己已经重新建立了进入 Spring Boot 所需要的 Java 基础。

目前已经掌握并实际练习过：

Java 基础

变量
数据类型
运算符
if / else
for
while
数组
String
Scanner
boolean
&&
||

方法

方法定义
参数
返回值
void
return
static

面向对象

class
object
new
构造方法
this
private
getter / setter
封装

面向对象进阶

继承
super
方法重写
@Override
多态

集合

ArrayList
add
get
remove
size
遍历

异常

try
catch
finally
ArithmeticException

并且已经通过一次综合练习，将这些知识进行了组合。

所以现在我不准备继续在 Java 基础阶段无限停留。

十一、这次我对“学会”的标准也发生了变化

以前学习技术的时候，我很容易给自己设置一个标准：

“必须完全学会。”

但实际上，“完全学会 Java”本身就是一个非常大的目标。

对于现在的我来说，更现实的标准是：

第一层：看得懂

看到常见 Java 代码时，我能够理解它在做什么。

第二层：改得动

别人或者 AI 写了一段代码，我能够看懂，并根据需求进行修改。

第三层：写得出常见功能

面对简单需求，我可以自己写出基本代码。

第四层：遇到不会的东西知道怎么解决

真正进入项目之后，不可能所有东西都提前学过。

遇到陌生 API、框架或者错误时，我可以：

看报错
↓
定位问题
↓
查资料 / 看官方文档
↓
借助 AI
↓
理解解决方案
↓
修改代码
↓
验证结果

我认为这比要求自己“完全不用 AI 写出所有代码”更加符合现在的软件开发环境。

十二、AI 对我的学习方式也产生了新的影响

这次重新学习 Java，我最大的变化之一，就是开始重新思考 AI 应该怎么使用。

以前容易变成：

AI 给代码 → 我复制 → 能运行 → 觉得自己会了。

但是经过这段时间的练习，我发现：

真正重要的不是：

“这段代码是不是我一个字一个字写出来的。”

而是：

“我能不能理解这段代码为什么这样写，以及出了问题之后能不能处理。”

尤其现在 AI 辅助编程的发展越来越快。

未来开发过程中，使用 AI 帮助生成代码、解释代码、排查问题，本身并不是问题。

真正需要避免的是：

自己完全不知道 AI 写出来的东西在干什么。

所以以后进入项目之后，我会逐渐采用：

自己分析需求
↓
理解实现思路
↓
必要时使用 AI 辅助
↓
阅读并理解生成的代码
↓
自己运行、调试、修改
↓
完成需求

而不是完全排斥 AI。

十三、Java 够用线结束，下一站 Spring Boot

到这里，我认为 Java 基础已经达到当前阶段的目标。

所以接下来，我准备正式进入：

Spring Boot

我接下来不会再把目标定成：

“把 Spring Boot 所有知识全部学完。”

而是直接围绕真实后端开发需要学习。

第一阶段：

Spring Boot 项目创建
↓
认识项目结构
↓
启动项目
↓
Controller
↓
HTTP 请求
↓
JSON

然后继续：

Controller
↓
Service
↓
Mapper
↓
MySQL

最终能够真正跑通：

前端 / Postman
        ↓
     Controller
        ↓
      Service
        ↓
      Mapper
        ↓
      MySQL

也就是说：

从现在开始，我的重点不再是“继续刷 Java 知识点”，而是开始进入真正的后端开发。

十四、后面的学习路线

目前我重新确定的路线是：

Java 够用线
      ↓
Spring Boot
      ↓
Spring Web
      ↓
MySQL
      ↓
MyBatis / MyBatis-Plus
      ↓
Controller → Service → Mapper → Database
      ↓
CRUD
      ↓
登录 / 用户 / 权限等常见业务
      ↓
完整 Spring Boot 项目
      ↓
GitHub
      ↓
技术博客
      ↓
项目部署
      ↓
微服务 / Docker
      ↓
RAG / Agent / Tool Calling
      ↓
Java 后端 + AI 应用项目

我希望尽快完成从：

“学习知识”

到：

“真正做项目”

的转换。

十五、GitHub + 博客 + 项目展示继续同步

之前给自己确定的三件事情不会改变。

1. GitHub

继续整理自己的学习代码和项目。

GitHub：

https://github.com/jiayi-dev/java-learning

这次 Java 够用线结束之后，也会把这一阶段具有代表性的代码整理好并提交。

2. 技术博客

继续记录学习过程。

前三篇主要记录了：

重新开始 Java
↓
Java 基础
↓
面向对象

这一篇则作为：

Java 够用线阶段总结

后面进入 Spring Boot 后，会继续记录：

Spring Boot 项目创建
Controller
HTTP
MySQL
MyBatis
CRUD
项目开发过程中遇到的问题
项目架构和实现思路

3. 公网项目

等真正完成一个比较成熟的 Spring Boot 项目之后，再把项目部署到公网。

最终希望形成：

学习
↓
代码实践
↓
GitHub
↓
技术博客
↓
完整项目
↓
公网部署
↓
简历作品

让学习真正形成一个闭环。

十六、这一阶段最大的收获

如果一定要总结这次重新学习 Java 最大的收获，我觉得并不是：

“我学会了多少 Java 语法。”

而是我开始接受一件事情：

技术学习不需要等到 100% 完美之后才能进入下一阶段。

以前可能会因为一个知识点没有完全理解，就一直停在那里。

现在我更希望：

理解基本原理
↓
能够自己写
↓
知道常见错误
↓
能够看懂和修改
↓
进入项目
↓
在项目中继续学习

因为真正的项目本身就是一个不断学习的过程。

总结

从第一篇开始重新学习 Java，到现在已经完成了这一阶段的主要目标。

我重新捡起了：

Java 基础
方法
类和对象
构造方法
this
封装
继承
super
方法重写
多态
ArrayList
异常处理

也通过综合练习把这些知识真正串联起来。

现在，我认为：

Java 已经达到目前进入 Spring Boot 所需要的“够用线”。

这并不代表 Java 已经全部学完。

而是代表：

我不再需要继续停留在 Java 基础阶段。

接下来应该把更多时间投入到真正的后端开发和项目实践中。

所以从这一篇开始，我准备正式进入下一阶段：

Spring Boot。

接下来要做的事情也会更加明确：

学框架 → 连数据库 → 写接口 → 做 CRUD → 完成真实项目 → 整理 GitHub → 写技术博客 → 部署项目 → 为秋招准备真正可以展示的作品。

这一次，我不想再只是“学过”。

我希望真正把知识变成可以运行的项目。

Java 够用线，告一段落。

下一站：Spring Boot。

代码仓库

本文学习过程中的相关代码已经同步上传到 GitHub：

GitHub：

https://github.com/jiayi-dev/java-learning

欢迎交流学习，也欢迎参考代码。

本文使用 AI 工具辅助整理文章结构，内容基于本人实际学习过程、代码实践以及学习记录整理。

posted @ 2026-09-06 16:35 jiang-jiayi 阅读(2) 评论(0) 收藏举报

刷新页面返回顶部

《Java 学习阶段总结：从面向对象到 Java 够用线，准备进入 Spring Boot》

前言

一、为什么要给 Java 划一条“够用线”

二、继承：开始理解类之间的关系

三、super：子类如何调用父类

四、方法重写：子类可以重新实现父类的方法

五、多态：开始理解“同一个接口，不同实现”

六、ArrayList：开始接触集合

七、异常处理：程序出错以后怎么办

八、第一次把这些知识真正串起来

九、综合练习过程中，我又发现了一些问题

十、现在我对 Java “够用线”的理解

Java 基础

方法

面向对象

面向对象进阶

集合

异常

十一、这次我对“学会”的标准也发生了变化

第一层：看得懂

第二层：改得动

第三层：写得出常见功能

第四层：遇到不会的东西知道怎么解决

十二、AI 对我的学习方式也产生了新的影响

十三、Java 够用线结束，下一站 Spring Boot

Spring Boot

十四、后面的学习路线

十五、GitHub + 博客 + 项目展示继续同步

1. GitHub

2. 技术博客

3. 公网项目

十六、这一阶段最大的收获

总结

Spring Boot。

代码仓库

公告