Java基础重新学习记录（一）：从变量、流程控制到方法，我是怎么一步步重新把Java写起来的

前言

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

上一篇主要记录了我的个人背景、为什么重新开始学习软件开发，以及接下来准备走的学习路线。

从这一篇开始，我会正式记录自己重新学习 Java 的过程。

包括：

学习了哪些知识点
遇到了哪些问题
自己是如何分析和解决的
哪些地方是真正理解了，哪些地方还需要继续加强

其实重新开始学习 Java 的时候，我发现自己并不是完全没有接触过 Java。

大学期间也学习过相关课程，但是以前更多时候是：

看过、听过、跟着老师写过。

真正让我自己面对一个需求，从零开始写代码时，却经常不知道应该如何下手。

所以这一次重新学习 Java，我没有选择单纯重新刷一遍教程，而是改变了学习方式：

先自己写 → 出现问题 → 分析错误 → 修改代码 → 理解原因 → 再重新独立写一遍。

我希望通过这种方式，让自己真正从：

“看懂代码”

慢慢变成：

“能够自己写代码”。

一、重新认识一个 Java 程序

重新开始学习 Java 的时候，我首先从最基础的程序结构开始。

例如：

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello Java!");

    }
}

这段代码非常简单。

但是重新写的时候，我发现自己以前其实并没有真正理解 Java 程序的结构。

比如：

class 是什么？
main 方法为什么特殊？
程序为什么从 main 方法开始执行？
普通方法应该写在哪里？

以前学习的时候，我可能只是记住：

Java 程序需要 main 方法。

但是这次重新学习，我开始尝试理解程序结构。

一个 Java 类大概是：

class

 ├── main方法

 └── 其他方法

而不是：

main方法

 └── 再定义其他方法

这个理解也为后面学习方法打下了基础。

二、变量和数据类型：让程序开始拥有数据

接下来重新学习变量和基本数据类型。

例如：

int age = 20;

以前学习变量时，更多像是在记语法。

但是重新学习时，我开始尝试拆开理解：

int

代表数据类型。

age

代表变量名称。

代表变量保存的数据。

也就是说：

创建变量，就是告诉程序：

我要保存什么类型的数据，这个数据叫什么，它现在的值是什么。

这种拆开的理解方式，也帮助我后面理解方法参数。

三、运算符：代码能运行，不代表逻辑正确

之后开始练习基本运算。

例如：

int a = 10;
int b = 20;

System.out.println(a + b);

这一部分本身并不困难。

但是在后面的方法练习中，我遇到了一个印象比较深的问题。

题目要求：

实现两个数字相乘。

但是我写代码时，把：

a * b

写成了：

a + b

代码没有报错，也可以正常运行。

但是结果是错误的。

这让我第一次比较明显地意识到：

程序错误不仅有语法错误，还有逻辑错误。

以前容易认为：

代码能运行就是正确。

但是实际上：

代码运行只是第一步。

更重要的是：

程序有没有完成真正的需求。

四、if 判断：从固定数据到参数

接下来开始练习条件判断。

例如：

判断成绩是否及格：

int score = 75;

if(score >= 60){

    System.out.println("及格");

}else{

    System.out.println("不及格");

}

之后继续练习：

if(score >= 90){

    System.out.println("优秀");

}else if(score >= 60){

    System.out.println("及格");

}else{

    System.out.println("不及格");

}

但是后来发现：

如果每次都把成绩写死：

int score = 75;

那么这个代码只能判断固定的数据。

如果想判断不同人的成绩，就需要让数据传入方法。

所以开始理解参数：

public static void checkScore(int score){

    if(score >= 90){

        System.out.println("优秀");

    }else if(score >= 60){

        System.out.println("及格");

    }else{

        System.out.println("不及格");

    }

}

调用：

checkScore(95);

这让我开始理解：

参数的意义，是让方法可以接收不同的数据，而不是把数据固定写在代码里面。

五、循环：理解重复执行

1. for 循环

之后开始练习 for 循环。

例如：

for(int i = 1; i <= 5; i++){

    System.out.println(i);

}

学习过程中，我逐渐理解：

for(初始化; 条件; 变化)

三个部分分别代表：

从哪里开始
满足什么条件继续
每次循环之后如何变化

例如输出：

可以：

for(int i = 1; i <= 9; i += 2){

    System.out.println(i);

}

重点不是死记代码，而是理解循环过程。

2. while 循环

之后学习 while：

int i = 2;

while(i <= 10){

    System.out.println(i);

    i += 2;

}

通过和 for 对比，我开始理解：

for 和 while 都可以实现循环。

真正重要的是：

理解什么时候需要重复执行，以及循环变量如何变化。

六、数组：第一次认真理解下标和边界

接下来学习数组。

例如：

int[] array = {10,20,30,40,50};

刚开始遍历数组时，我遇到了一个典型问题：

数组长度：

array.length

但是数组下标是从 0 开始的。

例如：

10  下标0
20  下标1
30  下标2
40  下标3
50  下标4

数组长度：

但是最大合法下标：

如果写：

i <= array.length

就会多访问一次，导致数组越界。

所以更常见：

for(int i = 0; i < array.length; i++){

    System.out.println(array[i]);

}

这个问题让我意识到：

很多错误不是 Java 太难，而是边界条件没有真正考虑清楚。

七、String：开始组合多个知识点

之后学习 String。

例如：

String name = "江江";

String city = "广东";

System.out.println("我叫" + name + "，来自" + city);

这一阶段开始把之前学过的内容组合起来：

变量
String
字符串拼接
输出

虽然程序很简单，但是开始让我从：

学一个知识点

变成：

用多个知识点完成一个小需求。

八、Scanner：让程序接收用户输入

之前写程序时，很多数据都是直接写在代码里面。

例如：

int age = 20;

学习 Scanner 后，可以让用户输入数据：

Scanner scanner = new Scanner(System.in);

System.out.println("请输入年龄：");

int age = scanner.nextInt();

System.out.println("你的年龄是：" + age);

程序开始可以接收外部数据。

这让我理解：

一个程序不应该永远处理提前写好的数据，而应该能够和外部进行交互。

这也是以后学习管理系统的重要基础。

九、真正让我卡住的地方：方法

前面的变量、循环、数组等内容虽然会遇到问题，但是整体还能理解。

真正让我开始感觉困难的是：

方法到底应该怎么写？

以前知道方法的大概概念：

方法就是一段可以重复使用的代码。

但是自己写的时候，会遇到很多问题：

方法应该写在哪里？
main 和普通方法是什么关系？
参数什么时候需要？
返回值什么时候使用？
为什么需要 static？

这些问题让我开始真正接触程序设计。

十、方法练习：从 sum 到 multiply

在方法练习中，我第一次遇到了比较明显的结构问题。

例如：

想实现一个求和方法：

sum()

但是刚开始不知道：

方法是不是可以写在 main 里面。

后来发现：

Java 中方法不能定义在另一个方法里面。

正确结构：

class

 ├── main()

 └── sum()

而不是：

class

 └── main()

      └── sum()

这个错误让我真正理解：

一个类中可以有多个方法，但是方法之间是平级关系。

十一、multiply：理解参数和返回值

之后继续练习：

写一个 multiply 方法，接收两个 int 参数，返回相乘结果。

最终理解：

public static int multiply(int a,int b){

    return a*b;

}

调用：

int result = multiply(3,4);

System.out.println(result);

这里：

int a,int b

表示方法接收的数据。

return a*b;

表示返回计算结果。

这让我开始理解：

方法的过程：

接收参数

↓

执行功能

↓

返回结果

十二、void 和 return 的理解

之前我对于 void 和 return 的关系理解并不清楚。

例如：

如果方法：

void

代表：

没有返回值。

那么：

return a*b;

这种写法就是错误的。

如果需要返回结果：

应该：

public static int multiply(int a,int b){

    return a*b;

}

这一次我开始理解：

返回值类型决定方法最后能不能返回对应的数据。

十三、static：从背定义到理解使用场景

static 是目前让我比较困惑的知识点之一。

以前只知道：

static 是静态。

但是不知道什么时候使用。

现在的理解：

如果方法只是完成独立计算：

例如：

multiply(3,4)

它不依赖某一个具体对象的数据。

那么可以使用 static。

但是如果方法属于某一个对象：

例如：

Student student = new Student();

那么更适合通过对象调用。

虽然目前还没有完全掌握 static，但是已经开始从：

看到 static 就背定义

变成：

思考这个方法是否依赖对象。

十四、重新学习过程中遇到的小错误

重新写代码时，也遇到了一些很真实的问题。

例如：

把：

public

写成：

pulbic

这种错误非常简单。

但是它提醒我：

看懂代码和自己写出代码，是完全不同的事情。

以前依赖 AI 时，代码可能很快完成。

但是自己真正写的时候，才会发现：

很多细节其实没有掌握。

十五、关于 AI 辅助学习方式的改变

这次重新学习 Java，我最大的变化之一，就是改变了使用 AI 的方式。

以前：

看到 AI 生成代码：

public static int multiply(int a,int b){

    return a*b;

}

可能觉得：

我看懂了。

但是如果让我重新写：

可能会遇到：

方法位置不知道
参数不会设计
返回值不会判断

所以现在我的学习方式：

第一遍：自己写

先思考：

需要什么类？
需要什么方法？
参数是什么？
返回什么？

第二步：允许犯错

错误不是失败。

错误可以帮助自己发现真正不会的地方。

第三步：重新独立写

确认：

如果没有 AI，我是否还能完成。

十六、目前 Java 学习进度

目前已经重新学习：

Java 基础结构
变量
数据类型
运算符
if/else
for
while
数组
String
Scanner
方法
参数
返回值
boolean
&& 和 ||
类和对象基础
构造方法
this
private
getter/setter

其中让我变化最大的是：

以前：

我学过 Java。

现在：

我开始能够自己分析需求并尝试写代码。

十七、下一阶段计划

接下来不会为了“学完全部 Java”而无限学习。

目标是：

达到能够支撑 Spring Boot 学习的 Java 基础程度。

下一阶段：

继承

↓

super

↓

方法重写

↓

多态

↓

ArrayList

↓

HashMap 基础

↓

异常处理

↓

Java 综合练习

↓

Spring Boot

在进入 Spring Boot 前，我会完成一次 Java 综合练习。

把之前学习的：

类
对象
方法
集合
条件判断
循环

真正结合起来。

同时继续同步记录：

GitHub：

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

博客园：

记录自己的学习过程。

总结

重新学习 Java 这一阶段，我最大的收获不是记住多少语法。

而是开始理解：

编程不是看懂代码，而是能够自己解决问题。

真正的学习过程：

不会

↓

自己尝试

↓

出现错误

↓

分析原因

↓

修改

↓

重新写

↓

掌握

我希望保持这样的学习方式。

因为未来学习 Spring Boot、微服务甚至 AI 应用开发时，遇到的问题只会越来越复杂。

如果现在没有建立自己分析问题和解决问题的能力，后面的学习也会一直依赖别人。

所以这一次重新开始 Java，对我来说不仅是在补基础。

更是在重新建立自己的编程能力。

后续会继续学习 Java 面向对象、集合等内容，并通过更多练习提升自己的代码能力。

代码仓库

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