什么是方法

Java的方法类似与其他语言的函数,是一段用来完成特定功能的代码块,设计方法的时候最好保持方法的原子性,即一个方法只完成一个功能.

方法的定义和调用

定义方法

要定义一个方法，你需要遵循以下的Java语法规则：

访问修饰符 返回类型 方法名(参数列表) {
    // 方法体
}

下面是对这些术语的解释：

1. 访问修饰符：它决定了谁可以访问这个方法。常见的访问修饰符有 public（公开的，任何地方都可以访问）、private（私有的，只有在同一个类内部可以访问）和 protected（受保护的，在同一个包或子类中可以访问）。
2. 返回类型：它指定了方法返回的结果的数据类型。如果方法不返回任何值，可以使用关键字 void。
3. 方法名：它是方法的标识符，可以自定义，通常使用驼峰命名法。
4. 参数列表：它包含了方法接受的输入参数。参数列表由一个或多个参数组成，每个参数都有自己的数据类型和名称。如果方法不需要参数，可以省略参数列表。
5. 方法体：它包含了方法的实际代码逻辑。方法体由一对花括号 {} 包围，其中包含了要执行的语句。

下面是一个示例，展示了如何定义一个简单的方法：

public class Example {
    public static void main(String[] args) {
        // 调用自定义的方法
        sayHello();
    }

    // 自定义的方法
    public static void sayHello() {
        System.out.println("Hello, World!");
    }
}

在上面的例子中，我们定义了一个名为 sayHello() 的方法。它没有任何参数，也没有返回值（使用了 void 作为返回类型）。在 sayHello() 方法的方法体中，我们使用 System.out.println() 方法打印了 “Hello, World!” 到控制台。

在 main() 方法中，我们通过调用 sayHello() 方法来执行它的代码。当我们运行这个程序时，它会输出 “Hello, World!” 到控制台。

通过定义和调用方法，可以使代码更有组织性、可读性和可重用性。

调用方法

方法重载

方法的重载（Method Overload）是指在一个类中，可以定义多个具有相同名称但参数列表不同的方法。

在方法重载中，方法的名称必须相同，而参数列表必须不同。参数列表可以通过以下方式进行区分：

1. 参数个数不同。
2. 参数类型不同。
3. 参数顺序不同。

当调用一个重载的方法时，根据传递的参数类型和数量，编译器会自动确定要调用的具体方法，以便执行相应的逻辑。

下面是一个方法重载的例子：

public class Example {
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        int sum1 = add(2, 3);
        int sum2 = add(2, 3, 4);
        
        System.out.println("Sum1: " + sum1);
        System.out.println("Sum2: " + sum2);
    }
}

在上面的例子中，我们定义了两个重载的 'add’在 'main’方法重载可以增强代码的可读性和灵活性。通过使用相同的方法名来表示类似但略有不同的操作，我们可以更直观地理解和使用代码。

命令行传参

命令行传参是指通过命令行界面（Command Line Interface）向程序传递参数。在命令行中，我们可以在执行程序的命令中提供额外的参数，这些参数会被程序接收并用于执行相应的逻辑。

在Java中，可以使用main()方法来接收命令行传参。main()方法的定义如下：

public static void main(String[] args) {
    // 程序逻辑
}

main()方法的参数args是一个字符串数组，它存储了从命令行传入的参数。数组中的每个元素对应一个参数。

下面是一个简单的示例，展示如何在命令行中传递参数：

public class Example {
    public static void main(String[] args) {
        // 打印所有传入的参数
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

在上述示例中，我们遍历了args数组，并使用System.out.println()方法打印了每个参数的值。这样，当我们在命令行中执行这个程序并传递参数时，这些参数的值将被打印出来。

假设我们将上述的Java类编译为Example.class，然后在命令行中执行以下命令：

java Example param1 param2 param3

执行上述命令后，程序将会打印出三个参数的值：param1、param2和param3。

通过命令行传参，我们可以根据不同的需求向程序提供不同的输入，以便灵活地执行程序逻辑。这在编写可配置和可扩展的应用程序时非常有用。

可变参数

可变参数传参（Variable Arguments）是Java中一种方便传递不同数量参数的机制。它允许方法接受可变数量的参数，而无需指定每个参数的具体数量。

在Java中，可变参数通过使用三个点…

返回类型 方法名(参数类型... 参数名) {
    // 方法体
}

在方法体中，我们可以像处理任何其他数组一样处理可变参数。方法调用时，我们可以传递任意数量的参数，甚至可以不传递任何参数。

下面是一个示例，展示了如何使用可变参数传参：

public class Example {
    public static void main(String[] args) {
        print("Hello");
        print("Hello", "World");
        print("Hello", "Beautiful", "World");
    }

    public static void print(String... messages) {
        for (String message : messages) {
            System.out.println(message);
        }
    }
}

在上面的例子中，我们定义了一个名为 ‘print’

在main() 方法中，我们通过多次调用 print() 方法来演示可变参数的使用。第一次调用时，我们传递了一个参数 “Hello”，第二次调用时，我们传递了两个参数 “Hello” 和 “World”，第三次调用时，我们传递了三个参数。无论传递的参数数量是多少，print() 方法都能正确处理并打印它们。

可变参数传参是一种灵活的机制，使得我们可以在调用方法时传递不同数量的参数，而不需要为每个情况编写多个方法重载。它在许多情况下可以简化代码，并提供更大的灵活性。

递归

递归（Recursion）是一种通过调用自身来解决问题的方法或过程。在递归中，一个函数或过程会直接或间接地调用自身，将原问题转化为一个或多个更小的相同类型的子问题。这些子问题将通过逐步的递归调用解决，最终达到解决原始问题的目的。 要使用递归，通常需要满足以下要求：

1. 基本情况（Base Case）：递归算法必须有一个或多个基本情况，它们是递归过程的终止条件。当满足基本情况时，递归将停止调用自身，避免无限循环。

2. 递归调用（Recursive Call）：在递归方法或过程的定义中，需要在某个位置调用自身，以解决更小规模的子问题。递归调用应朝着基本情况逼近，确保每次递归都将问题规模减小。

3. 问题规模减小：在递归过程中，问题的规模必须在每次递归调用中得以减小。如果问题规模没有减小，递归将无限进行，导致栈溢出或无法得到正确结果。

4. 合理的方法设计：使用递归时，需要考虑问题的分解方式和递归调用的位置，以确保每次递归都能向解决问题的方向前进。

5. 递归效率考虑：递归可能会导致重复计算和额外的函数调用开销。在使用递归时，需要评估算法的效率，并确保它在给定问题上能够在合理的时间内完成计算。

   递归是一种强大的问题解决技术，能够有效地解决一些问题，但它也需要慎重使用。过度深入的递归调用可能导致性能问题或栈溢出。正确理解和设计递归算法，合理选择适用场景，并满足上述要求，才能充分发挥递归的优势。

下面是一个使用递归计算阶乘的示例代码：

public class Example {
    public static int factorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        int result = factorial(5);
        System.out.println("Factorial of 5: " + result);
    }
}

在上面的代码中，我们定义了一个名为 factorial() 的递归方法，用于计算一个整数的阶乘。当传入的参数 n 为 0 时，我们返回 1（基本情况），表示 0 的阶乘为 1。否则，我们将 n 乘以 factorial(n - 1)，即调用自身并传入 n - 1，以计算 n 的阶乘。

在 main() 方法中，我们调用 factorial(5) 来计算 5 的阶乘。递归的过程如下：

• factorial(5) 调用 factorial(4) * 5
• factorial(4) 调用 factorial(3) * 4
• factorial(3) 调用 factorial(2) * 3
• factorial(2) 调用 factorial(1) * 2
• factorial(1) 调用 factorial(0) * 1
• factorial(0) 返回 1

根据基本情况和递归调用，factorial(0) 返回 1，然后逐步回溯计算得到最终结果，即 5 的阶乘为 120。

递归实现了将问题分解为更小的子问题，并通过递归调用解决子问题的过程。它在求解需要重复相同操作的问题时非常有用。

练习

package com.mek.demo;

public class Main {

    public static void main(String[] args) {
        // 命令行传参
        if (args.length > 0) {
            for (String cmd : args) {
                System.out.println(cmd);
            }
        }

        // 调用类方法并接受返回值
        int sum = add(10, 20);
        double dsum = add(3.1, 2.2);

        // 调用实例方法
        Main m = new Main();
        int sumg = m.multiply(9, 9);

        System.out.println(sumg);


    }

    /*
    定义一个类类方法
    public  公共
    static  类方法
     */
    public static int add(int x, int y) {
        return x + y;
    }

    /*
    重载
     */

    public static double add(double x, double y) {
        return x + y;
    }

    /*
    定义实例方法
     */

    public int multiply(int x, int y) {
        return x * y;
    }

}