04-你的 main 方法是不是写了 200 行？方法拆分技巧让代码清爽 10 倍🔥 前言 "木圭，我的 main 方

🔥 前言

"木圭，我的 main 方法写了 200 多行，逻辑全堆在一起，自己都看不懂了怎么办？"

这个问题我太熟悉了——刚开始学 Java 时，我也觉得"反正能跑就行"，把所有代码都塞进 main 方法里。结果过了一个星期再看，完全不知道哪段代码是干什么的，想改个功能都要小心翼翼，生怕弄坏其他地方。

后来老师跟我说了一句话，彻底改变了我的编程思维：

"好的代码是自己会说话的"

什么意思？就是看到方法名就知道它是干什么的，看到代码结构就知道数据怎么流转。而实现这一点的关键，就是合理定义和拆分方法。

今天这篇，我就把方法定义的核心技巧、参数传递的本质、以及方法拆分的实战经验一次性分享给你。都是我踩过坑后总结的血泪教训，帮你避开 90% 新手都会犯的错误。

📌 本文你将获得：

理解方法的本质："封装可复用代码块"，而不是"为了拆分而拆分"
掌握方法定义的三要素：明确参数、明确返回值、明确职责
搞懂值传递的核心机制：为什么修改参数不影响原变量？
学会方法重载的实际应用：同一个方法名，应对不同场景
掌握方法拆分技巧：从 200 行臃肿代码到 50 行清晰结构

👋 关于作者

我是木圭，正在学习AI 智能应用开发，这是我从 0 开始系统学习 Java 的第 4 篇笔记。
我会持续记录从 0 基础到能独立开发 AI 应用的完整过程，包括学习笔记、项目实战、避坑指南。
关注我，一起见证从小白到开发者的成长之路！

📅 学习进度：第 3 天 | JavaSE 阶段（共 17 篇，已完结 4 篇）

1- 方法的基本定义与调用

方法（函数）：就是一个完成特定功能的代码块，通过这个方法名可以调用此代码块完成功能

方法的基本定义

public static 返回值类型 方法名(参数列表){  
   方法体  
}
// public: 方法的访问修饰符，表示方法可以任意访问
// static: 表示方法不需要创建对象就可以访问

方法的调用 方法调用格式：方法名(实际参数列表); 代码示例：

public class FunctionDemo1 {  
    public static void main(String[] args) {  
        //示例：计算两个数的最大值  
        int max = getMax();  
        System.out.println("最大值是：" + max);  // 20
    }  
    public static int getMax(){  
        int a = 10;  
        int b = 20;  
        int max = a > b ? a : b;  
        return max;  
    }  
}

2- 方法的调用流程

方法没有被调用的时候，在方法区中的字节码文件中存放
方法被调用的时候，需要进入到栈内存中运行 示例代码

public class FunctionDemo2 {  
    public static void main(String[] args) {  
		study(); //我爱学习  
		eat();  //我爱吃  
		sleep(); //我爱睡觉 
    }  
    public static void study(){  
        System.out.println("我爱学习");  
    }  
    public static void eat(){  
        System.out.println("我爱吃");  
    }  
    public static void sleep(){  
        System.out.println("我爱睡觉");  
    }  
}

2.1 方法调用流程详解

程序启动阶段
- JVM 加载FunctionDemo 2类到内存的方法区（Method Area）
- 找到程序的入口点 main 方法
- 在虚拟机栈（JVM Stack）中为 main 方法分配一个栈帧（Stack Frame）
执行 main 方法当 main 方法执行时：
- 栈内存：在虚拟机中创建 main 的栈帧
- 栈帧包含：局部变量表、操作数栈、动态链接、方法返回地址等
- main 方法的参数 args 存储在局部变量表中
第一次调用 - study() 调用过程：

暂停 main 方法：JVM 暂停 main 方法的执行，保存当前的执行位置（第 12 行）
创建 study () 栈帧：在虚拟机栈中压入 study () 方法的栈帧
执行 study () 方法：
- 执行 System.Out.Println ("我爱学习")
- 在堆内存（Heap）中创建字符串对象 "我爱学习"（如果不存在则创建）
- 调用 println 方法输出
方法返回：
- Study () 方法执行完毕，其栈帧从虚拟机栈中弹出（销毁）
- JVM 返回到 main 方法中保存的位置（第 12 行之后）内存变化

虚拟机栈:
┌─────────────────┐
│ main 栈帧       │ ← 栈顶 (暂停状态)
│ - args          │
│ - PC: line 12   │
└─────────────────┘
        ↓ 调用 study()
┌─────────────────┐
│ study() 栈帧    │ ← 新的栈顶
│ - 局部变量表     │
│ - PC: line 19   │
└─────────────────┘
│ main 栈帧       │ ← 被压在下面
└─────────────────┘

第二次调用 - eat () 调用过程：

继续 main 方法：JVM 继续执行 main 方法的下一条指令（第 13 行）
暂停 main 方法：保存当前执行位置
创建 eat () 栈帧：在虚拟机栈中压入 eat () 方法的栈帧
执行 eat () 方法：
- 执行 System.Out.Println ("我爱吃")
- 在堆内存中创建字符串对象 "我爱吃"
- 调用 println 方法输出
方法返回：
- Eat () 方法栈帧弹出销毁
- 返回到 main 方法（第 13 行之后）

第三次调用 - sleep () 调用过程：

继续 main 方法：执行第 14 行
暂停 main 方法：保存当前位置
创建sleep ()栈帧：压入 sleep () 方法的栈帧
执行sleep ()方法：
- 执行 System.Out.Println ("我爱睡觉")
- 在堆内存中创建字符串对象 "我爱睡觉"
- 调用 println 方法输出
方法返回：
- Sleep () 方法栈帧弹出销毁
- 返回到 main 方法（第 14 行之后）

main 方法结束
- main 方法执行完毕，其栈帧从虚拟机栈中弹出
- 程序结束完整内存示意图

JVM 内存结构:
┌──────────────────────────────────────┐
│         堆内存 (Heap)                 │
│  ┌────────────────────────────────┐  │
│  │ String: "我爱学习"              │  │
│  │ String: "我爱吃"                │  │
│  │ String: "我爱睡觉"              │  │
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│      虚拟机栈 (JVM Stack)             │
│                                      │
│  [方法调用时的动态变化]               │
│  调用 study():                       │
│  ┌─────────────┐                    │
│  │ study()     │ ← 栈顶              │
│  ├─────────────┤                    │
│  │ main()      │                    │
│  └─────────────┘                    │
│                                      │
│  study() 返回后:                     │
│  ┌─────────────┐                    │
│  │ main()      │ ← 栈顶              │
│  └─────────────┘                    │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│       方法区 (Method Area)            │
│  ┌────────────────────────────────┐  │
│  │ FunctionDemo2 类信息            │  │
│  │ - main 方法字节码               │  │
│  │ - study 方法字节码              │  │
│  │ - eat 方法字节码                │  │
│  │ - sleep 方法字节码              │  │
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘

关键特点总结

后进先出（LIFO）：方法调用遵循栈的后进先出原则
独立性：每个方法都有自己独立的栈帧，局部变量互不干扰
生命周期：方法调用时创建栈帧，方法返回时销毁栈帧
顺序执行：虽然是方法调用，但本质上是顺序执行的过程
无返回值：这三个方法都是 void 类型，不需要在操作数栈中存储返回值
由于这三个方法都是静态方法（static），它们随着类的加载而存在于方法区中，可以直接通过类名调用，不需要创建对象实例。

3- 带参数的方法

带参数的方法：传递数据灵活

带参方法的定义格式：

public static 返回值类型 方法名(参数列表){  
   // 方法体  
}

调用格式

方法名(实际参数列表);

注意：形参：形式参数，方法定义时，定义的参数；实参：实际参数，方法调用时，传递的参数 带参方法的示例

public class FunctionDemo3 {  
    public static void main(String[] args) {  
        add(10, 20);  
    }  
    public static void add(int a, int b) {  
        System.out.println(a + b);//30  
    }  
}

参数方法的内存图解

main 方法入栈  
	↓
调用 add(10, 20) → add 方法入栈，形参 a=10, b=20  
	↓
add 方法执行：打印 30  
	↓
add 方法出栈  
	↓
main 方法继续执行  
	↓
main 方法出栈，程序结束

3.1 补充：值传递

值传递：方法调用时，传递的参数是参数的值，而不是参数的地址 代码示例：

public static void testValuePass() {  
    int num = 10;  
    change(num);  
    System.out.println(num);  // 输出10（因为 Java 是值传递）  
}  
  
public static void change(int n) {  
    n = 100;  // 修改的是副本，不影响原变量  
}

4- 带返回值的方法

带返回值方法：A 方法产生的数据, B 方法想要使用的话, 就需要定义带返回值的方法

定义格式

public static 返回值类型 方法名(参数列表){  
      // 方法体  
      return 返回值;  
}

代码示例

public class FunctionDemo4 {  
    public static void main(String[] args) {  
        int max = getMax(10, 20);  
        System.out.println(max);  //20
    }  
    public static int getMax(int a, int b){  
        return a > b ? a : b;  
    }  
}

5-方法的通用格式定义

方法的通用格式定义：方法的定义格式实际上只有一种，是拆成了三个部份让大家循序渐进的接受，现在我们整合一下，介绍通用定义格式

public static 返回值类型 方法名(参数列表){  
      方法体  
      return 返回值;  
}

定义方法时要做到两个明确： 明确参数：主要明确参数的类型和参数的个数
明确返回值：主要明确是否有返回值，如果有返回值，那么返回值的类型是什么，返回值类型必须与方法定义的返回值类型一致；没有返回值，那么方法定义的时候，返回值类型为 void 调用方法时：

void类型的方法，直接调用方法名即可
非void类型方法，必须接收返回值，推荐创建一个变量，将返回值赋给这个变量

代码示例：

public class FunctionDemo5 {  
    public static void main(String[] args) {  
		 // 练习1：设计一个方法，计算两个数之和  
        int sum = getSum(10, 20);  
        System.out.println("和是：" + sum);// 30  
        System.out.println("=========================");  
        // 练习2：设计一个方法，计算三个数的最小值  
        int min = getMin(10, 20, 30);  
        System.out.println("最小值是：" + min);// 10  
        System.out.println("=========================");  
        // 练习3：设计一个方法：打印出一个人的个人信息，参数：姓名，年龄，性别，地址  
        printPersonInfo("小王", 18, '男', "北京");// 姓名：小王，年龄：18，性别：男，地址：北京  
    }  
    public static int getSum(int a, int b){  
        int sum = a + b;  
        return sum;  
    }  
    public static int getMin(int a, int b, int c) {  
        int min = a;  
        //判断a和b的大小  
        int temp = a < b ? a : b;  
        //判断temp和c的大小  
        min = temp < c ? temp : c;  
        return min;  
    }  
    public static void printPersonInfo(String name, int age, char gender, String address){  
        System.out.println("姓名：" + name);  
        System.out.println("年龄：" + age);  
        System.out.println("性别：" + gender);  
        System.out.println("地址：" + address);  
    }  
}

6- 方法的重载

方法的重载：同一个类中，方法名相同，参数不同的方法，与返回值无关 重载：在同一个类中，定义了多个同名的方法，但每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系 (Overload) 方法重载的作用：提高代码的复用性，减少代码的编写

代码示例：

public class MethodToReloadDemo1 {  
        public static void main(String[] args) {  
	        // 案例：提供四个方法，计算 2 个整数、2 个小数相加，3 个小数相加，3 个整数相加  
	        int sum1 = add(10, 20);  
			System.out.println("和是：" + sum1);// 30  
			System.out.println("=========================");  
			double sum2 = add(10.1, 20.2);  
			System.out.println("和是：" + sum2);// 30.3  
			System.out.println("=========================");  
			double sum3 = add(10.1, 20.2, 30.3);  
			System.out.println("和是：" + sum3);// 60.6  
			System.out.println("=========================");  
			int sum4 = add(10, 20, 30);  
			System.out.println("和是：" + sum4);// 60
    }  
  
    public static int add(int a, int b){  
        return a + b;  
    }  
    public static double add(double a, double b){  
        return a + b;  
    }  
    public static double add(double a, double b, double c){  
        return a + b + c;  
    }  
    public static int add(int a, int b, int c) {  
        return a + b + c;  
    }  
}

⚠️ 注意：仅返回值类型不同，不构成重载！ 示例代码

public class MethodToReloadDemo2 {  
    public static void main(String[] args) {  
        // 调用两个整数相加的方法  
        int result1 = add(10, 20);  
        System.out.println("两个整数相加：" + result1);// 30  
        // 调用三个整数相加的方法  
        int result2 = add(10, 20, 30);  
        System.out.println("三个整数相加：" + result2);// 60  
        // 调用两个小数相加的方法  
        double result3 = add(10.5, 20.3);  
        System.out.println("两个小数相加：" + result3);// 30.8  
        // 调用两个字符串拼接的方法  
        String result4 = add("Hello", "World");  
        System.out.println("两个字符串拼接：" + result4);// HelloWorld  
    }  
    public static int add(int x, int y) {  
        return x + y;  
    }  
    public static int add(int x, int y, int z) {  
        return x + y + z;  
    }  
    public static double add(double x, double y) {  
        return x + y;  
    }  
    public static String add(String x, String y) {  
        return x + y;  
    }  
  
    /**  
     * ⚠️ 错误示例：仅返回值类型不同，不构成重载！  
     * 下面这样的代码会编译失败：  
     * 原因：方法重载只看参数列表（参数个数、类型、顺序），与返回值类型无关  
     */  
//    public static int add(int x, int y) { return x + y; } // ❌ 错误  
//    public static double add(int x, int y) { return x + y; }  // ❌ 错误  
}

🔥 前言

"木圭，我的 main 方法写了 200 多行，逻辑全堆在一起，自己都看不懂了怎么办？"

后来老师跟我说了一句话，彻底改变了我的编程思维：

"好的代码是自己会说话的"

什么意思？就是看到方法名就知道它是干什么的，看到代码结构就知道数据怎么流转。而实现这一点的关键，就是合理定义和拆分方法。

📌 本文你将获得：

理解方法的本质："封装可复用代码块"，而不是"为了拆分而拆分"
掌握方法定义的三要素：明确参数、明确返回值、明确职责
搞懂值传递的核心机制：为什么修改参数不影响原变量？
学会方法重载的实际应用：同一个方法名，应对不同场景
掌握方法拆分技巧：从 200 行臃肿代码到 50 行清晰结构

👋 关于作者

我是木圭，正在学习AI 智能应用开发，这是我从 0 开始系统学习 Java 的第 4 篇笔记。
我会持续记录从 0 基础到能独立开发 AI 应用的完整过程，包括学习笔记、项目实战、避坑指南。
关注我，一起见证从小白到开发者的成长之路！

📅 学习进度：第 3 天 | JavaSE 阶段（共 17 篇，已完结 4 篇）

1- 方法的基本定义与调用

方法（函数）：就是一个完成特定功能的代码块，通过这个方法名可以调用此代码块完成功能

方法的基本定义

public static 返回值类型 方法名(参数列表){  
   方法体  
}
// public: 方法的访问修饰符，表示方法可以任意访问
// static: 表示方法不需要创建对象就可以访问

方法的调用 方法调用格式：方法名(实际参数列表); 代码示例：

public class FunctionDemo1 {  
    public static void main(String[] args) {  
        //示例：计算两个数的最大值  
        int max = getMax();  
        System.out.println("最大值是：" + max);  // 20
    }  
    public static int getMax(){  
        int a = 10;  
        int b = 20;  
        int max = a > b ? a : b;  
        return max;  
    }  
}

2- 方法的调用流程

方法没有被调用的时候，在方法区中的字节码文件中存放
方法被调用的时候，需要进入到栈内存中运行 示例代码

public class FunctionDemo2 {  
    public static void main(String[] args) {  
		study(); //我爱学习  
		eat();  //我爱吃  
		sleep(); //我爱睡觉 
    }  
    public static void study(){  
        System.out.println("我爱学习");  
    }  
    public static void eat(){  
        System.out.println("我爱吃");  
    }  
    public static void sleep(){  
        System.out.println("我爱睡觉");  
    }  
}

2.1 方法调用流程详解

程序启动阶段
- JVM 加载FunctionDemo 2类到内存的方法区（Method Area）
- 找到程序的入口点 main 方法
- 在虚拟机栈（JVM Stack）中为 main 方法分配一个栈帧（Stack Frame）
执行 main 方法当 main 方法执行时：
- 栈内存：在虚拟机中创建 main 的栈帧
- 栈帧包含：局部变量表、操作数栈、动态链接、方法返回地址等
- main 方法的参数 args 存储在局部变量表中
第一次调用 - study() 调用过程：

暂停 main 方法：JVM 暂停 main 方法的执行，保存当前的执行位置（第 12 行）
创建 study () 栈帧：在虚拟机栈中压入 study () 方法的栈帧
执行 study () 方法：
- 执行 System.Out.Println ("我爱学习")
- 在堆内存（Heap）中创建字符串对象 "我爱学习"（如果不存在则创建）
- 调用 println 方法输出
方法返回：
- Study () 方法执行完毕，其栈帧从虚拟机栈中弹出（销毁）
- JVM 返回到 main 方法中保存的位置（第 12 行之后）内存变化

虚拟机栈:
┌─────────────────┐
│ main 栈帧       │ ← 栈顶 (暂停状态)
│ - args          │
│ - PC: line 12   │
└─────────────────┘
        ↓ 调用 study()
┌─────────────────┐
│ study() 栈帧    │ ← 新的栈顶
│ - 局部变量表     │
│ - PC: line 19   │
└─────────────────┘
│ main 栈帧       │ ← 被压在下面
└─────────────────┘

第二次调用 - eat () 调用过程：

继续 main 方法：JVM 继续执行 main 方法的下一条指令（第 13 行）
暂停 main 方法：保存当前执行位置
创建 eat () 栈帧：在虚拟机栈中压入 eat () 方法的栈帧
执行 eat () 方法：
- 执行 System.Out.Println ("我爱吃")
- 在堆内存中创建字符串对象 "我爱吃"
- 调用 println 方法输出
方法返回：
- Eat () 方法栈帧弹出销毁
- 返回到 main 方法（第 13 行之后）

第三次调用 - sleep () 调用过程：

继续 main 方法：执行第 14 行
暂停 main 方法：保存当前位置
创建sleep ()栈帧：压入 sleep () 方法的栈帧
执行sleep ()方法：
- 执行 System.Out.Println ("我爱睡觉")
- 在堆内存中创建字符串对象 "我爱睡觉"
- 调用 println 方法输出
方法返回：
- Sleep () 方法栈帧弹出销毁
- 返回到 main 方法（第 14 行之后）

main 方法结束
- main 方法执行完毕，其栈帧从虚拟机栈中弹出
- 程序结束完整内存示意图

JVM 内存结构:
┌──────────────────────────────────────┐
│         堆内存 (Heap)                 │
│  ┌────────────────────────────────┐  │
│  │ String: "我爱学习"              │  │
│  │ String: "我爱吃"                │  │
│  │ String: "我爱睡觉"              │  │
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│      虚拟机栈 (JVM Stack)             │
│                                      │
│  [方法调用时的动态变化]               │
│  调用 study():                       │
│  ┌─────────────┐                    │
│  │ study()     │ ← 栈顶              │
│  ├─────────────┤                    │
│  │ main()      │                    │
│  └─────────────┘                    │
│                                      │
│  study() 返回后:                     │
│  ┌─────────────┐                    │
│  │ main()      │ ← 栈顶              │
│  └─────────────┘                    │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│       方法区 (Method Area)            │
│  ┌────────────────────────────────┐  │
│  │ FunctionDemo2 类信息            │  │
│  │ - main 方法字节码               │  │
│  │ - study 方法字节码              │  │
│  │ - eat 方法字节码                │  │
│  │ - sleep 方法字节码              │  │
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘

关键特点总结

后进先出（LIFO）：方法调用遵循栈的后进先出原则
独立性：每个方法都有自己独立的栈帧，局部变量互不干扰
生命周期：方法调用时创建栈帧，方法返回时销毁栈帧
顺序执行：虽然是方法调用，但本质上是顺序执行的过程
无返回值：这三个方法都是 void 类型，不需要在操作数栈中存储返回值
由于这三个方法都是静态方法（static），它们随着类的加载而存在于方法区中，可以直接通过类名调用，不需要创建对象实例。

3- 带参数的方法

带参数的方法：传递数据灵活

带参方法的定义格式：

public static 返回值类型 方法名(参数列表){  
   // 方法体  
}

调用格式

方法名(实际参数列表);

注意：形参：形式参数，方法定义时，定义的参数；实参：实际参数，方法调用时，传递的参数 带参方法的示例

public class FunctionDemo3 {  
    public static void main(String[] args) {  
        add(10, 20);  
    }  
    public static void add(int a, int b) {  
        System.out.println(a + b);//30  
    }  
}

参数方法的内存图解

main 方法入栈  
	↓
调用 add(10, 20) → add 方法入栈，形参 a=10, b=20  
	↓
add 方法执行：打印 30  
	↓
add 方法出栈  
	↓
main 方法继续执行  
	↓
main 方法出栈，程序结束

3.1 补充：值传递

值传递：方法调用时，传递的参数是参数的值，而不是参数的地址 代码示例：

public static void testValuePass() {  
    int num = 10;  
    change(num);  
    System.out.println(num);  // 输出10（因为 Java 是值传递）  
}  
  
public static void change(int n) {  
    n = 100;  // 修改的是副本，不影响原变量  
}

4- 带返回值的方法

带返回值方法：A 方法产生的数据, B 方法想要使用的话, 就需要定义带返回值的方法

定义格式

public static 返回值类型 方法名(参数列表){  
      // 方法体  
      return 返回值;  
}

代码示例

public class FunctionDemo4 {  
    public static void main(String[] args) {  
        int max = getMax(10, 20);  
        System.out.println(max);  //20
    }  
    public static int getMax(int a, int b){  
        return a > b ? a : b;  
    }  
}

5-方法的通用格式定义

方法的通用格式定义：方法的定义格式实际上只有一种，是拆成了三个部份让大家循序渐进的接受，现在我们整合一下，介绍通用定义格式

public static 返回值类型 方法名(参数列表){  
      方法体  
      return 返回值;  
}

void类型的方法，直接调用方法名即可
非void类型方法，必须接收返回值，推荐创建一个变量，将返回值赋给这个变量

代码示例：

public class FunctionDemo5 {  
    public static void main(String[] args) {  
		 // 练习1：设计一个方法，计算两个数之和  
        int sum = getSum(10, 20);  
        System.out.println("和是：" + sum);// 30  
        System.out.println("=========================");  
        // 练习2：设计一个方法，计算三个数的最小值  
        int min = getMin(10, 20, 30);  
        System.out.println("最小值是：" + min);// 10  
        System.out.println("=========================");  
        // 练习3：设计一个方法：打印出一个人的个人信息，参数：姓名，年龄，性别，地址  
        printPersonInfo("小王", 18, '男', "北京");// 姓名：小王，年龄：18，性别：男，地址：北京  
    }  
    public static int getSum(int a, int b){  
        int sum = a + b;  
        return sum;  
    }  
    public static int getMin(int a, int b, int c) {  
        int min = a;  
        //判断a和b的大小  
        int temp = a < b ? a : b;  
        //判断temp和c的大小  
        min = temp < c ? temp : c;  
        return min;  
    }  
    public static void printPersonInfo(String name, int age, char gender, String address){  
        System.out.println("姓名：" + name);  
        System.out.println("年龄：" + age);  
        System.out.println("性别：" + gender);  
        System.out.println("地址：" + address);  
    }  
}

6- 方法的重载

代码示例：

public class MethodToReloadDemo1 {  
        public static void main(String[] args) {  
	        // 案例：提供四个方法，计算 2 个整数、2 个小数相加，3 个小数相加，3 个整数相加  
	        int sum1 = add(10, 20);  
			System.out.println("和是：" + sum1);// 30  
			System.out.println("=========================");  
			double sum2 = add(10.1, 20.2);  
			System.out.println("和是：" + sum2);// 30.3  
			System.out.println("=========================");  
			double sum3 = add(10.1, 20.2, 30.3);  
			System.out.println("和是：" + sum3);// 60.6  
			System.out.println("=========================");  
			int sum4 = add(10, 20, 30);  
			System.out.println("和是：" + sum4);// 60
    }  
  
    public static int add(int a, int b){  
        return a + b;  
    }  
    public static double add(double a, double b){  
        return a + b;  
    }  
    public static double add(double a, double b, double c){  
        return a + b + c;  
    }  
    public static int add(int a, int b, int c) {  
        return a + b + c;  
    }  
}

⚠️ 注意：仅返回值类型不同，不构成重载！ 示例代码

public class MethodToReloadDemo2 {  
    public static void main(String[] args) {  
        // 调用两个整数相加的方法  
        int result1 = add(10, 20);  
        System.out.println("两个整数相加：" + result1);// 30  
        // 调用三个整数相加的方法  
        int result2 = add(10, 20, 30);  
        System.out.println("三个整数相加：" + result2);// 60  
        // 调用两个小数相加的方法  
        double result3 = add(10.5, 20.3);  
        System.out.println("两个小数相加：" + result3);// 30.8  
        // 调用两个字符串拼接的方法  
        String result4 = add("Hello", "World");  
        System.out.println("两个字符串拼接：" + result4);// HelloWorld  
    }  
    public static int add(int x, int y) {  
        return x + y;  
    }  
    public static int add(int x, int y, int z) {  
        return x + y + z;  
    }  
    public static double add(double x, double y) {  
        return x + y;  
    }  
    public static String add(String x, String y) {  
        return x + y;  
    }  
  
    /**  
     * ⚠️ 错误示例：仅返回值类型不同，不构成重载！  
     * 下面这样的代码会编译失败：  
     * 原因：方法重载只看参数列表（参数个数、类型、顺序），与返回值类型无关  
     */  
//    public static int add(int x, int y) { return x + y; } // ❌ 错误  
//    public static double add(int x, int y) { return x + y; }  // ❌ 错误  
}

7、总结回顾

📝 核心要点速记

方法的本质：封装可复用的代码块，避免复制粘贴
三要素：明确参数、明确返回值、明确职责
值传递机制：基本类型传值的副本，引用类型传引用的副本
方法重载：同名不同参，应对不同场景
拆分原则：单一职责，每个方法只做一件事

🔥 面试高频题

Q: 方法重载和方法重写的区别？ A: 重载是同一个类中同名不同参；重写是子类重写父类方法。
Q: Java 是值传递还是引用传递？ A: Java 只有值传递。基本类型传值，引用类型传引用的副本。
Q: void 方法可以有 return 吗？ A: 可以，return; 表示方法结束，不返回任何值。

📚 系列文章导航

【JavaSE 从 0 到 1】系列（已完结 4/17 篇）

🔹 环境搭建篇

✅ [第 1 篇] 还在卡 Java 环境？10 分钟搞定 JDK 配置的保姆级教程
✅ [第 2 篇] Java 开发必备：JDK 多版本共存与切换，一篇就够

🔹 语法基础篇（ upcoming）

✅ [第 3 篇] 告别语法混乱！Java 基础语法：理清变量、数据类型与运算符
✅ [第 4 篇] 你的 main 方法是不是写了 200 行？方法拆分技巧让代码清爽 10 倍← 当前这篇

🔹 流程控制篇upcoming（upcoming）

💬 互动区

开放性问题：

"你的 main 方法写过多少行？是怎么拆分的？评论区聊聊~"
"你觉得方法命名最重要的是什么？"

如果这篇文章帮到了你：

👍 欢迎点赞 + 收藏，方便随时查阅
🔄 转发给一起学 Java 的小伙伴
➕ 关注我，不错过后续的每一篇实战笔记我们一起完成这 AI 开发学习之旅！💪"

7、总结回顾

📝 核心要点速记

方法的本质：封装可复用的代码块，避免复制粘贴
三要素：明确参数、明确返回值、明确职责
值传递机制：基本类型传值的副本，引用类型传引用的副本
方法重载：同名不同参，应对不同场景
拆分原则：单一职责，每个方法只做一件事

🔥 面试高频题

Q: 方法重载和方法重写的区别？ A: 重载是同一个类中同名不同参；重写是子类重写父类方法。
Q: Java 是值传递还是引用传递？ A: Java 只有值传递。基本类型传值，引用类型传引用的副本。
Q: void 方法可以有 return 吗？ A: 可以，return; 表示方法结束，不返回任何值。

📚 系列文章导航

【JavaSE 从 0 到 1】系列（已完结 4/17 篇）

🔹 环境搭建篇

✅ [第 1 篇] 还在卡 Java 环境？10 分钟搞定 JDK 配置的保姆级教程
✅ [第 2 篇] Java 开发必备：JDK 多版本共存与切换，一篇就够

🔹 语法基础篇（ upcoming）

✅ [第 3 篇] 告别语法混乱！Java 基础语法：理清变量、数据类型与运算符
✅ [第 4 篇] 你的 main 方法是不是写了 200 行？方法拆分技巧让代码清爽 10 倍← 当前这篇

🔹 流程控制篇upcoming（upcoming）

💬 互动区

开放性问题：

"你的 main 方法写过多少行？是怎么拆分的？评论区聊聊~"
"你觉得方法命名最重要的是什么？"

如果这篇文章帮到了你：

👍 欢迎点赞 + 收藏，方便随时查阅
🔄 转发给一起学 Java 的小伙伴
➕ 关注我，不错过后续的每一篇实战笔记我们一起完成这 AI 开发学习之旅！💪"

04-你的 main 方法是不是写了 200 行？方法拆分技巧让代码清爽 10 倍

1- 方法的基本定义与调用

2- 方法的调用流程

2.1 方法调用流程详解

3- 带参数的方法

3.1 补充 ：值传递

4- 带返回值的方法

5-方法的通用格式定义

6- 方法的重载

1- 方法的基本定义与调用

2- 方法的调用流程

2.1 方法调用流程详解

3- 带参数的方法

3.1 补充 ：值传递

4- 带返回值的方法

5-方法的通用格式定义

6- 方法的重载

7、总结回顾

📝 核心要点速记

🔥 面试高频题

📚 系列文章导航

🔹 环境搭建篇

🔹 语法基础篇（ upcoming）

🔹 流程控制篇upcoming（upcoming）

💬 互动区

7、总结回顾

📝 核心要点速记

🔥 面试高频题

📚 系列文章导航

🔹 环境搭建篇

🔹 语法基础篇（ upcoming）

🔹 流程控制篇upcoming（upcoming）

💬 互动区

3.1 补充：值传递

3.1 补充：值传递