【Java SE 基础学习打卡】27 方法的概述

目录

• 前言
• 一、先搞懂：什么是方法？
• • [1.1 生活中的 "方法"：可复用的固定流程](#1.1 生活中的 “方法”：可复用的固定流程)
  • [1.2 编程中的 "方法"：可复用的代码块](#1.2 编程中的 “方法”：可复用的代码块)
  • [1.3 方法的本质总结（小白必记）](#1.3 方法的本质总结（小白必记）)
• [二、为什么要用方法？（3 个核心意义）](#二、为什么要用方法？（3 个核心意义）)
• • [2.1 意义 1：减少代码冗余（告别复制粘贴）](#2.1 意义 1：减少代码冗余（告别复制粘贴）)
  • [2.2 意义 2：提高代码可读性（一眼看懂功能）](#2.2 意义 2：提高代码可读性（一眼看懂功能）)
  • [2.3 意义 3：便于维护（改一处，全生效）](#2.3 意义 3：便于维护（改一处，全生效）)
• [三、方法的核心作用：代码复用 & 功能模块化](#三、方法的核心作用：代码复用 & 功能模块化)
• • [3.1 核心作用 1：代码复用（基础作用）](#3.1 核心作用 1：代码复用（基础作用）)
  • [3.2 核心作用 2：功能模块化（进阶作用）](#3.2 核心作用 2：功能模块化（进阶作用）)
• 四、新手易混淆：方法和循环的区别（别搞反了！）
• 总结

前言

前面咱们学完了循环和跳转语句，能实现不少功能了 ------ 比如计算 1-100 的和、打印 99 乘法表、找指定条件的数字。但如果遇到这样的场景："既想计算 1-100 的和，又想计算 50-200 的和，还想计算 1000-2000 的和"，难道要把求和的循环代码写三遍吗？

如果每次需要这个功能都复制粘贴一遍代码，不仅写起来麻烦，万一要修改逻辑（比如从 "求和" 改成 "求平均值"），还得把三处代码都改一遍，很容易漏改、改错。这时候就需要 "方法" 来解决这个问题 ------ 把重复使用的代码块封装起来，想用的时候直接 "调用" 就行，就像生活中用现成的工具一样，不用每次都从头造。

这一节咱们就搞懂方法的核心概念：先通过生活场景理解 "什么是方法"，再明白用方法的意义，最后掌握它的核心作用 ------ 全程用大白话 + 生活化例子，保证刚学完循环的你能轻松理解！

一、先搞懂：什么是方法？

1.1 生活中的 "方法"：可复用的固定流程

先从生活里找例子，你每天都会接触到 "方法"，只是没意识到：

• 做奶茶的方法：准备茶叶→煮茶汤→加牛奶→加糖→摇匀 ------ 这套流程固定不变，想喝奶茶时，不用每次都重新想步骤，直接按这个流程做就行（复用）；

• 煮泡面的方法：烧开水→放面饼→加调料→煮 3 分钟 ------ 不管是红烧味还是香辣味，核心流程都能复用；

• 上班的方法：起床→洗漱→吃早餐→通勤→打卡 ------ 每天重复这套流程，不用每天重新规划。

这些例子的共同点是：把完成某个特定功能的 "步骤" 封装成固定流程，需要的时候直接执行这套流程，不用重复想步骤。

1.2 编程中的 "方法"：可复用的代码块

对应到 Java 编程中，方法的本质就是：把完成某个特定功能的若干行代码封装成一个 "代码块"，给这个代码块起个名字，需要使用这个功能时，直接喊名字调用即可，不用重复写代码。

举个直观的例子：计算两个数的和

• 不用方法的写法（每次用都要写一遍）：

  // 计算10+20
  int a1 = 10, b1 = 20;
  int sum1 = a1 + b1;
  System.out.println("10+20=" + sum1);
  
  // 计算30+40（重复写求和代码）
  int a2 = 30, b2 = 40;
  int sum2 = a2 + b2;
  System.out.println("30+40=" + sum2);
  
  // 计算50+60（又重复写）
  int a3 = 50, b3 = 60;
  int sum3 = a3 + b3;
  System.out.println("50+60=" + sum3);

• 用方法的写法（把求和代码封装成方法，调用即可）：

  // 先封装求和方法（给代码块起名字叫add）
  public static int add(int num1, int num2) {
      return num1 + num2;
  }
  
  public static void main(String[] args) {
      // 调用方法，不用重复写求和代码
      System.out.println("10+20=" + add(10, 20));
      System.out.println("30+40=" + add(30, 40));
      System.out.println("50+60=" + add(50, 60));
  }

两者执行结果完全一样，但用方法的写法只写了一次求和逻辑，后续想计算任意两个数的和，直接调用add(数字1, 数字2)就行 ------ 这就是方法的核心：一次封装，多次复用。

1.3 方法的本质总结（小白必记）

方法就是编程里的 "工具"：

• 工具名：方法的名字（比如上面的add），用来标识这个工具是做什么的；

• 工具功能：方法里的代码块（比如return num1 + num2），完成特定功能；

• 使用方式：调用方法名（比如add(10,20)），就能触发工具的功能。

二、为什么要用方法？（3 个核心意义）

不用方法也能写代码，但会越写越乱，而方法能解决新手最容易遇到的 3 个问题：

2.1 意义 1：减少代码冗余（告别复制粘贴）

这是最直观的好处 ------ 重复的代码只写一次，后续调用即可，避免 "复制粘贴几十遍，改的时候改到崩溃"。

痛点举例：如果要计算 1-10、1-100、1-1000 的和，不用方法需要写 3 遍循环：

// 计算1-10的和
int sum1 = 0;
for (int i = 1; i <= 10; i++) {
    sum1 += i;
}
System.out.println("1-10的和：" + sum1);

// 计算1-100的和（重复循环代码）
int sum2 = 0;
for (int i = 1; i <= 100; i++) {
    sum2 += i;
}
System.out.println("1-100的和：" + sum2);

// 计算1-1000的和（又重复）
int sum3 = 0;
for (int i = 1; i <= 1000; i++) {
    sum3 += i;
}
System.out.println("1-1000的和：" + sum3);

用方法解决：把 "计算 1 到 n 的和" 封装成方法，调用时只传不同的 n 就行：

// 封装求和方法（n是要计算到的数字）
public static int sumToN(int n) {
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum += i;
    }
    return sum;
}

public static void main(String[] args) {
    // 调用方法，传不同的参数即可
    System.out.println("1-10的和：" + sumToN(10));
    System.out.println("1-100的和：" + sumToN(100));
    System.out.println("1-1000的和：" + sumToN(1000));
}

代码量直接减少一半，而且后续想计算 1-500 的和，只需要加一行sumToN(500)，不用再写循环。

2.2 意义 2：提高代码可读性（一眼看懂功能）

新手写的代码容易 "一坨到底"------ 几百行代码堆在 main 方法里，分不清哪部分是求和、哪部分是打印、哪部分是判断。

方法能把代码按 "功能" 拆分，每个方法只做一件事，看方法名就知道功能：

• sumToN()：一看就知道是 "计算 1 到 n 的和"；

• print99Table()：一看就知道是 "打印 99 乘法表"；

• findFirst7()：一看就知道是 "找第一个能被 7 整除的数"。

2.3 意义 3：便于维护（改一处，全生效）

如果需要修改功能逻辑，比如把 "计算 1 到 n 的和" 改成 "计算 2 到 n 的和"：

• 无方法：需要找到所有复制粘贴的循环代码，逐处修改（容易漏改、改错）；

• 有方法：只需要修改sumToN()方法里的for (int i = 2; i <= n; i++)，所有调用这个方法的地方都会自动生效，一次修改，全量生效。

这就像生活中修改奶茶配方：只要改一次 "做奶茶的方法"，后续所有做出来的奶茶都会是新口味，不用每次做都重新改步骤。

三、方法的核心作用：代码复用 & 功能模块化

上面的 3 个意义，本质上都是围绕两个核心作用展开的 ------ 这也是方法的灵魂：

3.1 核心作用 1：代码复用（基础作用）

复用是方法最基础、最核心的作用，解决 "重复写代码" 的问题。

• 复用的前提：方法封装的是 "通用功能"（比如求和、打印、判断），而不是一次性的逻辑；

• 复用的方式：调用方法名 + 传参数（比如sumToN(100)），参数就是给方法的 "原材料"（比如 100 就是 "计算到 100" 这个原材料）；

• 复用的价值：节省时间、减少代码量、降低出错概率。

3.2 核心作用 2：功能模块化（进阶作用）

模块化是把程序按 "功能" 拆分成多个方法，每个方法负责一个独立功能，就像把一辆车拆分成发动机、车轮、方向盘等模块，每个模块只做自己的事。

**举例：一个简单的 "成绩统计程序"**如果不用方法，所有逻辑堆在 main 里：

public static void main(String[] args) {
    // 1. 计算语文、数学、英语的平均分
    int chinese = 90, math = 85, english = 95;
    double avg = (chinese + math + english) / 3.0;
    // 2. 判断是否及格（平均分≥60）
    boolean isPass = avg >= 60;
    // 3. 打印结果
    System.out.println("平均分：" + avg);
    System.out.println("是否及格：" + isPass);
}

如果用方法模块化拆分：

// 模块1：计算平均分
public static double calcAvg(int a, int b, int c) {
    return (a + b + c) / 3.0;
}

// 模块2：判断是否及格
public static boolean isPass(double avg) {
    return avg >= 60;
}

// 模块3：打印结果
public static void printResult(double avg, boolean isPass) {
    System.out.println("平均分：" + avg);
    System.out.println("是否及格：" + isPass);
}

public static void main(String[] args) {
    int chinese = 90, math = 85, english = 95;
    // 调用各个模块，完成整体功能
    double avg = calcAvg(chinese, math, english);
    boolean pass = isPass(avg);
    printResult(avg, pass);
}

拆分后：

• 每个方法只做一件事，逻辑更清晰；

• 如果想修改 "及格标准"（比如改成≥70），只改isPass()方法即可；

• 如果想新增 "打印等级" 功能，只需要新增一个printLevel()方法，不用动其他代码。

模块化的核心价值（新手提前了解）

模块化让代码从 "一坨乱麻" 变成 "条理清晰的积木"：

• 可拆分：大功能拆成小方法，每个小方法容易写、容易懂；

• 可组合：不同的小方法可以组合成大功能（比如calcAvg()+isPass()+printResult()组合成 "成绩统计"）；

• 可扩展：新增功能只需要加新方法，不影响原有代码。

四、新手易混淆：方法和循环的区别（别搞反了！）

刚学完循环的小白，容易把方法和循环搞混 ------ 两者都和 "重复" 有关，但本质完全不同：

特点	方法	循环
核心目的	代码复用、功能模块化	重复执行同一批代码
重复的维度	跨场景重复（比如不同地方求和）	单一场景内重复（比如 1-100 求和的循环）
关系	方法里可以包含循环	循环里可以调用方法

举例理解：

• 循环："连续做 10 个俯卧撑"------ 单一场景内重复执行 "做俯卧撑" 这个动作；

• 方法：把 "做俯卧撑" 封装成方法，今天做 10 个、明天做 20 个、后天做 30 个 ------ 跨场景重复使用 "做俯卧撑" 这个动作。

简单说：循环是 "同一处重复做"，方法是 "不同处重复用"。

总结

这一节咱们搞懂了方法的核心概念，记住 2 个核心点：

1. 方法的本质：封装特定功能的可复用代码块，一次封装、多次调用；

2. 方法的核心作用：代码复用（减少冗余）、功能模块化（提高可读性、便于维护）。

方法是 Java 编程从 "写零散代码" 到 "写结构化程序" 的关键，掌握方法的概念后，下一节咱们会学方法的具体语法（怎么定义、怎么调用、参数和返回值），把今天的 "概念" 落地成可运行的代码～