Java新特性-（四）方法与数组

一、方法

1.1 方法的基本概念

• 介绍：方法（Method）是一段封装了特定功能的代码块，可被重复调用，无需反复编写相同逻辑。例如 "计算两个数的和""打印数组内容" 等功能，均可封装为方法。
• 作用：
  1. 简化代码：将重复逻辑抽取为方法，减少代码冗余；
  2. 提高可读性：通过方法名直观理解功能（如calculateSum表示 "计算总和"）；
  3. 便于维护：修改功能时只需调整方法内部代码，无需修改所有调用处。
• 使用方式代码（方法的声明与调用）：

	/**
     * 1. 方法声明：定义"计算两个int类型数的和"的方法
     * 格式：修饰符 返回值类型 方法名(参数列表) { 方法体 }
     */
    public static int calculateSum(int a, int b) {
        int sum = a + b; // 方法体：实现求和逻辑
        return sum; // 返回计算结果（返回值类型需与声明一致）
    }

    public static void main(String[] args) {
        // 2. 方法调用：使用方法完成功能，接收返回值
        int num1 = 10;
        int num2 = 20;
        int result = calculateSum(num1, num2); // 传入实际参数（实参），接收返回值

        System.out.println(num1 + " + " + num2 + " = " + result); // 输出：10 + 20 = 30
    }

1. 方法声明的核心要素：修饰符（如public static，入门阶段固定使用）、返回值类型（无返回值用void）、方法名（见名知意，驼峰式命名）、参数列表（括号内的变量，用于接收外部传入的数据）、方法体（实现功能的代码）、return（返回结果，无返回值时可省略或仅写return;）；
2. 方法必须定义在类中，不能嵌套定义（即一个方法内不能再定义另一个方法）；
3. main方法是程序入口，由 JVM 自动调用，其他方法需手动调用。

1.2 方法的参数与返回值

1.2.1 无参数无返回值方法

• 介绍：方法不需要外部传入数据（参数列表为空），也不需要向调用者返回结果（返回值类型为void），常用于执行 "打印提示信息""输出固定内容" 等操作。
• 作用：封装无输入、无输出的简单操作，简化重复打印逻辑。
• 使用方式代码：

    public static void main(String[] args) {
        // 调用方法（无需传参，无需接收返回值）
        printWelcome();
        System.out.println("\n程序继续执行...");
    }
    // 声明无参数无返回值方法：打印欢迎信息
    public static void printWelcome() {
        System.out.println("==================");
        System.out.println("  欢迎使用Java程序  ");
        System.out.println("==================");
        // 无return语句
    }

1.2.2 有参数无返回值方法

• 介绍：方法需要外部传入数据（参数列表非空），但无需返回结果（返回值类型为void），常用于 "根据传入参数执行特定操作"（如 "根据姓名打印问候语"）。
• 作用：实现 "输入数据→执行操作" 的逻辑，提高方法的灵活性（同一方法可处理不同输入）。
• 使用方式代码：

    // 声明有参数无返回值方法：根据姓名打印问候语
    public static void printGreeting(String name) { // 参数列表：String类型的name
        System.out.println("你好，" + name + "！很高兴认识你~");
    }

    public static void main(String[] args) {
        // 调用方法：传入不同实参，执行不同操作
        printGreeting("张三"); // 输出：你好，张三！很高兴认识你~
        printGreeting("李四"); // 输出：你好，李四！很高兴认识你~
    }

1.2.3 有参数有返回值方法

• 介绍：方法需要外部传入数据（参数列表非空），且需向调用者返回结果（返回值类型与return的结果类型一致），是最常用的方法类型（如 "计算两个数的乘积""根据身高体重计算 BMI 值"）。
• 作用：实现 "输入数据→处理→输出结果" 的完整逻辑，支持多处调用并复用结果（如多次计算不同数值的乘积，无需重复编写乘法逻辑）。
• 使用方式代码：

    // 声明有参数有返回值方法1：计算两个int类型数的乘积
    public static int calculateProduct(int num1, int num2) { // 参数：两个int类型的数
        int product = num1 * num2; // 方法体：实现乘法逻辑
        return product; // 返回乘积（int类型，与方法声明的返回值类型一致）
    }

    // 声明有参数有返回值方法2：根据身高（米）和体重（公斤）计算BMI值（BMI=体重/身高²）
    public static double calculateBMI(double height, double weight) { // 参数：身高和体重（double类型）
        double bmi = weight / (height * height); // 实现BMI计算公式
        return bmi; // 返回BMI值（double类型）
    }

    public static void main(String[] args) {
        // 调用方法1：计算3和5的乘积，接收返回值
        int result1 = calculateProduct(3, 5);
        System.out.println("3 × 5 = " + result1); // 输出：3 × 5 = 15

        // 调用方法2：计算身高1.75米、体重65公斤的BMI值
        double height = 1.75;
        double weight = 65;
        double bmiValue = calculateBMI(height, weight);
        System.out.println("身高" + height + "米，体重" + weight + "公斤，BMI值：" + bmiValue); // 输出：身高1.75米，体重65公斤，BMI值：21.224489795918366
    }

1. 参数列表中，多个参数需用逗号分隔（如calculateBMI(double height, double weight)），调用时实参的 "顺序、数量、类型" 必须与形参完全匹配（如不能用calculateBMI(65, 1.75)，会导致身高和体重参数颠倒）；
2. 返回值类型需与return后数据的类型一致（如方法声明为double，return后不能是int类型，除非可自动转换，如return 10可自动转为10.0）；
3. 若方法有返回值，调用时可选择接收返回值（如int result1 = calculateProduct(3,5)），也可直接使用返回值（如System.out.println(calculateProduct(3,5))），但不建议忽略返回值（会失去方法的核心作用）。

1.3 方法的重载（Overload）

• 介绍：在同一个类中，允许存在多个 "方法名相同但参数列表不同" 的方法，称为方法重载。调用时，JVM 会根据实参的数量和类型自动匹配对应的方法。
• 作用：用相同的方法名实现 "相似功能"（如 "计算两个数的和""计算三个数的和"），减少记忆多个方法名的成本。
• 使用方式代码：

    // 方法1：计算两个int类型数的和
    public static int calculateSum(int a, int b) {
        System.out.println("调用两个int参数的方法");
        return a + b;
    }

    // 方法2：计算三个int类型数的和（参数数量不同，构成重载）
    public static int calculateSum(int a, int b, int c) {
        System.out.println("调用三个int参数的方法");
        return a + b + c;
    }

    // 方法3：计算两个double类型数的和（参数类型不同，构成重载）
    public static double calculateSum(double a, double b) {
        System.out.println("调用两个double参数的方法");
        return a + b;
    }

    public static void main(String[] args) {
        // 调用时，JVM根据实参自动匹配方法
        System.out.println("结果1：" + calculateSum(10, 20)); // 匹配方法1，结果30
        System.out.println("结果2：" + calculateSum(10, 20, 30)); // 匹配方法2，结果60
        System.out.println("结果3：" + calculateSum(1.5, 2.5)); // 匹配方法3，结果4.0
    }

1. 方法重载的判定条件（三者满足其一即可）：① 参数数量不同；② 参数类型不同；③ 参数类型的顺序不同（如(int a, double b)与(double a, int b)）；
2. 方法重载与 "返回值类型""修饰符" 无关，仅看方法名和参数列表（如public static int add(int a)与public static double add(int a)不构成重载，会编译报错）；
3. 方法重载的核心是 "功能相似，参数不同"，避免为相似功能定义不同方法名（如add2、add3），提升代码简洁性。

1.4 方法的内存执行原理

• 介绍：Java 中方法的执行依赖 "栈内存"（Stack），栈遵循 "先进后出" 的原则：调用方法时，JVM 为方法分配栈（存储方法的参数、局部变量等）；方法执行完毕后，方法弹栈，释放内存。

  1. 每个方法调用时都会进入栈内存，存储方法的参数、局部变量（定义在方法内的变量），方法执行完毕后弹栈方法立即销毁，局部变量也随之失效（作用域仅在方法内）；
  2. main方法是第一个入栈的方法，也是最后一个出栈的方法（程序入口和出口）；

二、数组：存储批量相同类型数据的容器

2.1 数组的基本概念

• 介绍：数组（Array）是一种线性数据结构，用于存储 "批量相同类型的数据"，数组中的每个元素有唯一的 "索引"（从 0 开始），可通过索引快速访问元素。
• 作用：解决 "多个相同类型变量管理困难" 的问题（如存储 50 个学生的成绩，无需定义 50 个变量，用一个数组即可）。
• 使用方式代码（数组的声明）：

  public static void main(String[] args) {
        // 数组声明格式（两种，推荐第一种）
        int[] scores; // 格式1：数据类型[] 数组名（清晰表示"数组"类型）
        // int scores[]; // 格式2：数据类型 数组名[]（兼容C/C++语法，不推荐）

        // 注意：声明数组时不能指定长度（如int[5] scores; 错误），长度在初始化时确定
    }

1. 数组的核心特性：① 存储的数据类型必须相同（如int[]数组不能存double类型数据）；② 长度固定（初始化后不可修改，如数组长度为 5，不能再添加第 6 个元素）；③ 索引从 0 开始（第一个元素索引 0，第二个 1，...，第 n 个 n-1）；
2. 数组属于 "引用数据类型"，数组名存储的是数组在堆内存中的地址，而非数据本身。

2.2 数组的初始化

2.2.1 动态初始化（指定长度，默认赋值）

• 介绍：只指定数组的长度，不直接指定元素值，JVM 会为数组元素赋 "默认值"（如int数组默认 0，double默认 0.0，boolean默认 false，引用类型默认 null）。
• 作用：适合 "知道数据数量，但不确定具体值" 的场景（如存储用户输入的 10 个分数）。
• 使用方式代码：

    public static void main(String[] args) {
        // 动态初始化格式：数据类型[] 数组名 = new 数据类型[数组长度];
        int[] scores = new int[5]; // 初始化int数组，长度5，元素默认0

        // 访问数组元素（通过索引），并修改值
        scores[0] = 85; // 第一个元素（索引0）赋值85
        scores[1] = 92; // 第二个元素（索引1）赋值92
        scores[2] = 78; // 第三个元素（索引2）赋值78

        // 输出数组元素
        System.out.println("索引0的元素：" + scores[0]); // 85
        System.out.println("索引3的元素（默认值）：" + scores[3]); // 0（未修改，保持默认）
        System.out.println("数组长度：" + scores.length); // 5（通过数组的length属性获取长度）
    }

2.2.2 静态初始化（指定元素，自动确定长度）

• 介绍：直接指定数组的所有元素值，JVM 会根据元素数量自动计算数组长度，无需手动指定。
• 作用：适合 "已知所有数据值" 的场景（如存储固定的 5 个省份名称）。
• 使用方式代码：

    public static void main(String[] args) {
        // 静态初始化格式1：数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, ...};
        String[] provinces = new String[]{"北京", "上海", "广东", "江苏", "浙江"};

        // 静态初始化格式2（简化版，推荐）：数据类型[] 数组名 = {元素1, 元素2, ...};
        int[] numbers = {10, 20, 30, 40, 50};

        // 输出数组信息
        System.out.println("省份数组长度：" + provinces.length); // 5（自动计算）
        System.out.println("numbers数组索引2的元素：" + numbers[2]); // 30
        System.out.println("最后一个元素（索引length-1）：" + numbers[numbers.length - 1]); // 50
    }

1. 动态初始化与静态初始化的核心区别：动态初始化 "先定长度，后填值"，静态初始化 "先填值，自动定长度"，二者不能混合使用（如int[] arr = new int[5]{1,2,3};错误）；
2. 数组的长度通过数组名.length获取（如scores.length），长度是int类型，且初始化后不可修改（如scores.length = 10错误）；
3. 访问数组元素时，索引范围是0 ~ 数组长度-1，超出范围会报ArrayIndexOutOfBoundsException（数组越界异常），需格外注意。

2.3 数组的核心操作（遍历、求和、最值、反转）

2.3.1 数组遍历（访问所有元素）

• 介绍：遍历是指 "依次访问数组的每个元素"，常用for循环（通过索引控制）或增强for循环（直接遍历元素，无需索引）实现。
• 作用：后续所有数组操作（求和、最值）的基础，只有遍历才能获取每个元素的值。
• 使用方式代码：

    public static void main(String[] args) {
        int[] numbers = {15, 25, 35, 45, 55};

        // 方式1：普通for循环（需索引，可修改元素值）
        System.out.println("普通for循环遍历（带索引）：");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("索引" + i + "：" + numbers[i]);
            // 可修改元素值（如numbers[i] *= 2;）
        }

        // 方式2：增强for循环（foreach，无索引，仅读取元素，不能修改）
        System.out.println("\n增强for循环遍历（仅元素）：");
        for (int num : numbers) { // 格式：for (元素类型 变量名 : 数组名)
            System.out.println("元素值：" + num);
            // num = 100; // 仅修改局部变量num，数组元素不变
        }
    }

2.3.2 数组求和（累加所有元素）

• 介绍：通过遍历数组，将每个元素的值累加到一个 "总和变量" 中，最终得到数组所有元素的和。
• 作用：实现 "批量数据求和" 场景（如计算班级所有学生的总分）。
• 使用方式代码：

    // 封装求和方法，提高复用性
    public static int getArraySum(int[] arr) {
        int sum = 0; // 总和变量，初始值0（累加起点）
        for (int num : arr) { // 遍历数组
            sum += num; // 累加每个元素到sum
        }
        return sum; // 返回总和
    }

    public static void main(String[] args) {
        int[] scores = {88, 95, 76, 92, 80};
        int total = getArraySum(scores);
        System.out.println("数组所有元素的和：" + total); // 输出：431
    }

2.3.3 数组求最值（最大值 / 最小值）

• 介绍：通过遍历数组，用一个 "基准变量"（如初始化为第一个元素）与每个元素比较，更新基准变量为更大 / 更小的值，最终得到最值。
• 作用：实现 "批量数据极值查询" 场景（如找出班级最高分、最低分）。
• 使用方式代码：

    // 方法：获取数组的最大值
    public static int getArrayMax(int[] arr) {
        int max = arr[0]; // 基准变量，初始化为第一个元素
        for (int i = 1; i < arr.length; i++) { // 从第二个元素开始比较
            if (arr[i] > max) {
                max = arr[i]; // 若当前元素更大，更新max
            }
        }
        return max;
    }

    // 方法：获取数组的最小值
    public static int getArrayMin(int[] arr) {
        int min = arr[0]; // 基准变量，初始化为第一个元素
        for (int i = 1; i < arr.length; i++) { // 从第二个元素开始比较
            if (arr[i] < min) {
                min = arr[i]; // 若当前元素更小，更新min
            }
        }
        return min;
    }

    public static void main(String[] args) {
        int[] numbers = {23, 45, 18, 56, 32};
        int max = getArrayMax(numbers);
        int min = getArrayMin(numbers);
        System.out.println("数组最大值：" + max); // 56
        System.out.println("数组最小值：" + min); // 18
    }

2.3.4 数组反转（首尾元素交换）

• 介绍：通过 "双指针"（一个指向数组开头，一个指向结尾），交换两个指针指向的元素，然后指针向中间移动，直到指针相遇，实现数组元素反转。
• 作用：实现 "数据顺序反转" 场景（如将数组[1,2,3,4,5]转为[5,4,3,2,1]）。
• 使用方式代码：

    // 方法：反转数组（直接修改原数组）
    public static void reverseArray(int[] arr) {
        int left = 0; // 左指针：指向数组开头（索引0）
        int right = arr.length - 1; // 右指针：指向数组结尾（索引length-1）

        while (left < right) { // 指针未相遇时，继续交换
            // 1. 交换left和right指向的元素（需临时变量）
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;

            // 2. 指针向中间移动
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        System.out.println("反转前数组：");
        for (int num : arr) {
            System.out.print(num + " "); // 输出：10 20 30 40 50
        }

        // 调用反转方法
        reverseArray(arr);

        System.out.println("\n反转后数组：");
        for (int num : arr) {
            System.out.print(num + " "); // 输出：50 40 30 20 10
        }
    }

1. 数组遍历的两种方式：普通for循环适合 "需要索引" 的场景（如修改元素、反转），增强for循环适合 "仅读取元素" 的场景（如求和、打印）；
2. 求最值时，基准变量初始化为arr[0]（而非 0），避免数组元素全为负数时出错（如数组[-5,-3,-10]，初始化为 0 会导致最大值错误）；
3. 数组反转的 "双指针" 思路是高效实现方式，仅需遍历数组一半元素（时间复杂度 O (n/2)），比 "新建数组存储反转后元素" 更节省内存。

三、案例

案例需求：

定义一个方法，接收一个int类型数组，实现以下功能：① 遍历数组并打印所有元素；② 计算数组的总和；③ 找出数组的最大值；④ 找出数组的最小值；⑤ 调用方法并输出所有结果。

实现代码：

public class ArrayMethodDemo {

    public static void main(String[] args) {
        // 初始化数组
        int[] scores = {75, 88, 92, 60, 85, 78};
        // 调用综合处理方法
        System.out.println("=== 数组综合处理结果 ===");
        processArray(scores);
    }

    //  方法：综合处理数组（调用所有方法）
    public static void processArray(int[] arr) {
        printArray(arr);
        System.out.println("数组总和：" + getArraySum(arr));
        System.out.println("数组最大值：" + getArrayMax(arr));
        System.out.println("数组最小值：" + getArrayMin(arr));
    }

    //  方法：遍历并打印数组
    public static void printArray(int[] arr) {
        System.out.print("数组元素：[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]); // 最后一个元素不加逗号
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.println("]");
    }

    //  方法：计算数组总和（复用之前的方法）
    public static int getArraySum(int[] arr) {
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        return sum;
    }

    //  方法：获取数组最大值（复用之前的方法）
    public static int getArrayMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    //  方法：获取数组最小值（复用之前的方法）
    public static int getArrayMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

}