day22 Java基础——方法（干货）

day22 Java基础——方法

在Java中，方法是一段组织好的、可重复使用的代码块，用于执行一个特定的操作。方法提供了一种封装代码的方式，使得代码模块化，便于管理和重用。以下是关于Java中方法的一些基本介绍：

文章目录

day22 Java基础——方法
- 1. 方法的定义
- 2. 方法的调用
- - 2.1 方法调用的基本步骤
  - 2.2 方法调用的类型
  - - 2.2.1 静态方法调用
    - 2.2.2实例方法调用
    - 2.2.3方法的重载调用
  - 2.3 方法调用的注意事项
- 3. 方法的重载
- - 3.1 参数列表的区别
  - 3.2 返回类型
  - 3.3 示例
  - 3.4 调用重载方法
  - 3.5 注意事项
- 4. 命令行传参
- - 4.1 主函数的参数
  - 4.2 传递命令行参数
  - 4.3 访问命令行参数
  - 4.4 注意事项
- 5. 可变参数
- - 5.1 可变参数的定义
  - 5.2 可变参数的规则
  - 5.3 调用可变参数方法
  - 5.4 注意事项
- 6. 递归
- - 6.1 递归的步骤
  - 6.2 示例
  - 6.3 注意事项
- 7. 方法的特性
- 8. 方法的种类
- 9. 实操
- - 1. 重载
  - 2. 可变参数

1. 方法的定义

一个方法由以下几个部分组成：

访问修饰符：定义了方法的访问级别，比如public、private、protected等。
返回类型：方法执行后返回的结果类型，比如int、void（无返回值）、String等。
方法名称：用于唯一标识该方法的名字。
参数列表：方法执行时可能需要的数据，用括号括起来，参数可以有多个，也可以没有。形式参数：定义方法时使用的参数，实际参数：方法被使用时用的参数。
方法体：包含具体的操作语句，用花括号括起来。
以下是方法定义的一个示例：

public static int addNumbers(int number1, int number2) {
    int sum = number1 + number2;
    return sum;
}

2. 方法的调用

定义好方法后，可以在程序的其他部分调用它。调用方法时，需要提供相应的参数（如果有的话），并可以使用返回值（如果方法有返回类型）。

public class Main {
    public static void main(String[] args) {
        int result = addNumbers(5, 3);
        System.out.println("The sum is: " + result);
    }
    public static int addNumbers(int number1, int number2) {
        int sum = number1 + number2;
        return sum;
    }
}

在上面的例子中，addNumbers方法被调用，并传递了两个整型参数5和3。方法计算它们的和，并将结果返回，然后在main方法中打印出来。
在Java中，方法的调用是指执行一个已经定义好的方法的过程。以下是方法调用的详细介绍：

2.1 方法调用的基本步骤

方法声明：首先，必须有一个已经声明和定义好的方法。方法可以在同一个类中，也可以在不同的类中。
创建对象（对于非静态方法）：如果方法是实例方法（非静态），则需要先创建该类的一个对象。
调用方法：使用对象名和方法名，后面跟着括号和参数（如果有参数的话）来调用方法。

2.2 方法调用的类型

2.2.1 静态方法调用

静态方法是属于类的，不依赖于类的任何实例。因此，可以直接使用类名来调用静态方法。

public class MathUtils {
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
}
public class Main {
    public static void main(String[] args) {
        // 调用静态方法
        int result = MathUtils.add(5, 3);
        System.out.println("The sum is: " + result);
    }
}

2.2.2实例方法调用

实例方法是属于类的实例的，因此需要通过类的实例（对象）来调用。

public class Calculator {
    // 实例方法
    public int multiply(int a, int b) {
        return a * b;
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建Calculator类的实例
        Calculator calc = new Calculator();
        
        // 通过对象调用实例方法
        int product = calc.multiply(5, 3);
        System.out.println("The product is: " + product);
    }
}

2.2.3方法的重载调用

如果类中有多个同名方法，但参数列表不同（即方法重载），Java会根据提供的参数类型和数量来决定调用哪个方法。

public class OverloadExample {
    // 方法重载
    public void print(String message) {
        System.out.println("String: " + message);
    }
    
    public void print(int number) {
        System.out.println("Integer: " + number);
    }
}
public class Main {
    public static void main(String[] args) {
        OverloadExample example = new OverloadExample();
        
        // 调用重载方法
        example.print("Hello World");
        example.print(123);
    }
}

2.3 方法调用的注意事项

参数匹配：调用方法时，提供的参数必须与方法的参数列表匹配，包括参数的数量和类型。
返回值：如果方法有返回值，可以将其赋值给变量，或者在表达式中直接使用。
异常处理：如果方法声明了可能抛出的异常，调用者需要处理这些异常（使用try-catch块或声明抛出）。
正确的方法调用是Java编程中实现功能的基础，理解方法调用的规则和方式对于编写有效的Java代码至关重要。

3. 方法的重载

在Java中，方法的重载（Overloading）是指在一个类中存在多个同名的方法，但这些方法的参数列表必须不同。这意味着每个重载的方法必须接受不同数量或类型的参数。方法的重载可以让代码更加清晰和易于理解，因为它允许程序员使用相同的方法名执行相似的操作，但针对不同的数据类型或参数数量。
以下是方法重载的几个关键点：

3.1 参数列表的区别

重载的方法必须在其参数列表中有至少一个不同的参数，这可以是参数的数量不同，参数的类型不同，或者参数的顺序不同。

3.2 返回类型

方法的返回类型不是区分重载方法的标准。也就是说，两个重载的方法可以有相同的返回类型，只要它们的参数列表不同。

3.3 示例

以下是一个简单的Java类，其中包含了重载方法的示例：

public class Calculator {
    // 第一个add方法，接受两个整数参数
    public int add(int a, int b) {
        return a + b;
    }
    // 第二个add方法，接受三个整数参数
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    // 第三个add方法，接受两个双精度浮点数参数
    public double add(double a, double b) {
        return a + b;
    }
}

在上面的Calculator类中，add方法被重载了三次，每次都有不同的参数列表。

3.4 调用重载方法

当调用一个重载方法时，Java编译器会根据提供的参数类型和数量来确定使用哪个重载版本：

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        // 调用第一个add方法
        int result1 = calc.add(5, 3);
        System.out.println("5 + 3 = " + result1);
        
        // 调用第二个add方法
        int result2 = calc.add(1, 2, 3);
        System.out.println("1 + 2 + 3 = " + result2);
        
        // 调用第三个add方法
        double result3 = calc.add(1.5, 2.5);
        System.out.println("1.5 + 2.5 = " + result3);
    }
}

3.5 注意事项

构造器重载：构造器也可以被重载，以提供不同的初始化方式。
方法签名：方法签名包括方法名和参数列表，不包括返回类型。因此，只有方法签名不同，方法才能被重载。
默认参数：Java不支持像某些其他语言那样的默认参数，因此不能通过默认参数来区分重载方法。
方法重载是Java多态性的一种体现，它提高了代码的灵活性和可读性。通过重载，可以创建一组相关的方法，每个方法都针对特定类型的参数进行操作。

4. 命令行传参

在Java中，命令行参数是通过主函数（main 方法）的参数传递给Java应用程序的。这些参数通常用于配置程序的行为或提供运行时所需的数据。

4.1 主函数的参数

Java程序的主函数定义如下：

public static void main(String[] args) {
    // 程序代码
}

其中，args 是一个字符串数组，它包含了从命令行传递给程序的参数。

4.2 传递命令行参数

当你在命令行运行一个Java程序时，可以在Java命令后面添加参数，如下所示：

java MyProgram arg1 arg2 arg3

在这个例子中，MyProgram 是包含 main 方法的Java类的名称，arg1、arg2 和 arg3 是传递给程序的三个参数。

4.3 访问命令行参数

在Java程序中，你可以通过 args 数组来访问这些参数：

public class MyProgram {
    public static void main(String[] args) {
        // 检查参数数量
        if (args.length > 0) {
            // 输出每个参数
            for (int i = 0; i < args.length; i++) {
                System.out.println("args[" + i + "]: " + args[i]);
            }
        } else {
            System.out.println("No arguments were provided.");
        }
    }
}

在上面的代码中，程序会检查 args 数组的长度来确定是否提供了参数，并遍历数组来打印每个参数。

4.4 注意事项

参数类型：所有命令行参数都是作为字符串传递的，即使它们看起来像数字或其他类型。如果需要，你需要在程序中将其转换为适当的类型。
空格处理：命令行参数是以空格分隔的。如果参数本身包含空格，通常需要将参数用引号包围起来，例如 "argument with space"。
参数数量：应该始终检查传递给程序的参数数量，以避免数组越界异常。
命令行参数为Java程序提供了灵活性和可配置性，使得用户可以在不修改代码的情况下改变程序的行为。

5. 可变参数

在Java中，可变参数（Varargs）是一种特殊的方法参数，它允许你传递不定数量的参数给一个方法。可变参数在方法签名中使用省略号（...）表示，它实际上代表了一个数组。这意味着你可以传递零个或多个参数，这些参数在方法内部被视为数组元素。
在这里插入图片描述

5.1 可变参数的定义

下面是如何在方法定义中使用可变参数的示例：

public class VarargsExample {
    // 可变参数方法
    public static int sum(int... numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return sum;
    }
    public static void main(String[] args) {
        // 调用可变参数方法
        System.out.println(sum(1, 2, 3)); // 输出 6
        System.out.println(sum(1, 2, 3, 4, 5)); // 输出 15
        System.out.println(sum()); // 输出 0
    }
}

在上面的例子中，sum 方法使用了可变参数，可以接受任意数量的整数参数。

5.2 可变参数的规则

可变参数必须是方法的最后一个参数：一个方法只能有一个可变参数，并且它必须是参数列表中的最后一个参数。
可变参数的实际类型是数组：在方法内部，可变参数被视为与省略号对应的数组类型。例如，int... numbers 在方法内部被视为 int[] numbers。

5.3 调用可变参数方法

当调用可变参数方法时，你可以传递相应类型的单个值、数组，或者直接传递逗号分隔的值序列。
如果你有一个数组，你可以直接传递这个数组给可变参数方法，而不需要使用省略号。

5.4 注意事项

类型检查：可变参数方法在编译时不会检查参数的具体类型，因此在运行时可能会抛出 ArrayStoreException，如果尝试将错误类型的元素存储到数组中。
性能考虑：虽然可变参数方法提供了灵活性，但在某些情况下，它可能会比固定参数方法慢，因为涉及到数组的创建和遍历。
可变参数是Java语言的一个强大特性，它简化了方法调用，使得代码更加简洁和灵活。然而，它应该谨慎使用，以避免不必要的性能开销和潜在的类型安全问题。

6. 递归

在Java中，递归是指一个方法调用自己。这种调用机制可以用来解决那些可以分解为多个相似子问题的复杂问题。递归通常用于解决树形结构或图形的遍历、排序、搜索等问题。
在这里插入图片描述

6.1 递归的步骤

递归调用：方法调用自身。
递归终止条件：定义一个条件，当这个条件满足时，递归调用停止。
递归的分解：将问题分解为更小的子问题，并递归地解决这些子问题。

6.2 示例

以下是一个简单的递归方法示例，用于计算一个整数的阶乘：

public class Factorial {
    public static int factorial(int n) {
        // 递归终止条件
        if (n == 0) {
            return 1;
        }
        // 递归分解
        return n * factorial(n - 1);
    }
    public static void main(String[] args) {
        // 调用递归方法
        int result = factorial(5);
        System.out.println("5! = " + result);
    }
}

在这个例子中，factorial 方法被自己调用，直到达到递归终止条件。
在这里插入图片描述

6.3 注意事项

栈溢出：如果递归调用没有终止条件，或者终止条件永远不会满足，程序可能会出现栈溢出（Stack Overflow）错误。
性能：递归可能会导致性能问题，因为它涉及到大量的函数调用和返回，增加了栈的开销。
代码重复：递归可能会导致代码重复，这可能会使得代码难以维护。
递归深度：Java虚拟机（JVM）对递归深度有一定的限制，超过这个限制可能会导致异常。
递归是一种强大的编程技术，但它需要谨慎使用。正确使用递归可以简化问题解决的过程，但过度使用或不当使用可能会导致性能问题和代码难以维护。

7. 方法的特性

重载：Java允许方法名称相同但参数列表不同的方法存在，这被称为方法重载。
递归：方法可以调用自身，这称为递归。
作用域：方法的局部变量只在方法内部有效，方法外部无法访问。

8. 方法的种类

实例方法：属于类的实例，需要通过类的实例来调用。
静态方法：属于类本身，可以通过类名直接调用，不需要类的实例。
方法在Java编程中扮演着核心角色，它们有助于降低代码的冗余，提高代码的可读性和可维护性。正确地使用方法可以使得程序结构更加清晰，功能更加模块化。

9. 实操

1. 重载

package com.study.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {

        System.out.println(add(1,2));

        System.out.println(add(1.2,2.3));

        System.out.println(max(1,2));

        System.out.println(max(1,2,3));

    }

    //加法(int)
    public static int add(int a,int b){
        return a+b;
    }
    //加法(double)
    public static double add(double a,double b) {
        return a+b;
    }

    //比大小max(a, b)
    public static int max(int num1,int num2){
        int result;
        if (num1>num2){
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }
    //比大小max(a, b, c)
    public static int max(int num1,int num2,int num3){
        return max(max(num1,num2),max(num2,num3));
    }
}

3
3.5
2
3

2. 可变参数

package com.study.method;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.test(1,2,3);
    }

    public void test(int... i){
        System.out.println(i[2]);
    }
}