Java的编程之旅17——方法（函数）

1.方法的简介

在Java中，方法是一段代码的集合，它执行特定的任务。方法可以被多次调用，并且可以接受输入参数和返回值。方法用于将代码模块化，提高代码的可读性和复用性。

一个方法由以下组成：

• 方法名：用于标识方法的唯一名称。
• 参数列表：方法可能接受的输入参数。
• 返回类型：方法执行完毕后返回的结果的数据类型。
• 方法体：包含实际的代码实现。

方法分为静态方法和实例方法：

• 静态方法（static method）属于类，可以直接通过类名调用，无需创建对象。
• 实例方法（instance method）属于对象，需要通过对象来调用。

2.方法的定义 

1.封装一个函数，实现两个数相加

以下是一个示例方法的定义：

public int add(int a, int b) {
    int sum = a + b;
    return sum;
}

在上述示例中，方法名为add，参数列表为两个int类型的参数a和b，返回类型为int。方法体里面将a和b相加，并将结果赋给sum变量，最后通过return语句返回sum的值。

通过调用这个方法，可以实现两个数相加的功能：

int result = add(3, 5);
System.out.println(result); // 输出8

2.输出图形

public static void printStar(int n){
    for(int i = 0;i < n;i++){
        for(int j = ;j < n;j++){
            System.out.print("* ");
        }
        System.out.println();
    }
}

这段代码定义了一个静态方法 printStar，它接受一个整数参数 n。

在方法体里面，有两个嵌套的循环。外层循环控制行数，内层循环控制每一行的星号数量。

首先，在外层循环中，初始化一个变量 i 为0，然后判断 i 是否小于 n。如果满足条件，则进入循环体内执行下面的代码。

内层循环中，初始化一个变量 j 为0，然后判断 j 是否小于 n。如果满足条件，则进入循环体内执行下面的代码。

在内层循环的循环体内，使用 System.out.print("* ") 在控制台输出一个星号和一个空格。

完成内层循环后，执行 System.out.println()，在控制台上输出一个换行符，实现换行的效果。

然后，内层循环继续执行，直到 j 不满足条件。

完成内层循环后，外层循环的迭代部分执行， i 的值增加1。

直到 i 不满足条件，整个方法的执行结束。

通过调用 printStar 方法并传入一个整数参数，就可以在控制台上打印出对应数量的星号图案。

调用

printStar(5);

会打印出一个5行5列的星号图案：

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

3.方法的重载

* 函数名相同，形参不同，与返回值无关
* 在调用方法时，根据所传的实参，来选择具体是那一个方法

public static void printStar(){
    System.out.println("******");
}
 
public static int printStar(int n){
    System.out.println("!!!!!!");
    return 1;
}
 
public static void printStar(float n){
    System.out.println("------");
}

我们在同一个类中定义了三个同名但参数列表不同的方法，分别是printStar()、printStar(int n)和printStar(float n)。

1. printStar()方法没有参数，打印了一行星号******。
2. printStar(int n)方法接受一个整数参数n，打印了一行感叹号!!!!!!，并返回整数值1。
3. printStar(float n)方法接受一个浮点数参数n，打印了一行短横线------。

这些方法通过参数类型和数量的不同来区分，所以它们是方法重载。

当我们调用这些方法时，编译器会根据方法调用的参数来选择最匹配的方法。例如：

printStar(); // 调用第一个方法，输出"******"
printStar(5); // 调用第二个方法，输出"!!!!!!"，并返回1
printStar(1.5f); // 调用第三个方法，输出"------"

这样，我们可以根据不同的参数类型来调用不同的方法，以实现不同的功能。方法的重载可以提高代码的复用性和可读性，使我们的程序更加灵活。

4.方法的嵌套

方法的嵌套是指在一个方法内部调用另一个方法。通过方法的嵌套，我们可以将一个大问题分解成多个小问题，并分别编写对应的方法来解决。这样可以提高代码的可读性和可维护性。

下面是一个简单的示例，展示了方法的嵌套：

public static void main(String[] args) {
    int result = sum(3, 4);
    System.out.println("The result is: " + result);
}
 
public static int sum(int a, int b) {
    int c = multiply(a, b);
    return c;
}
 
public static int multiply(int x, int y) {
    int z = x * y;
    return z;
}

在上面的代码中，main方法调用了sum方法，sum方法又在内部调用了multiply方法。multiply方法负责计算两个数的乘积，而sum方法则调用了multiply方法来实现两数相乘后的加法运算。最后，main方法打印出结果。

通过方法的嵌套，我们可以将复杂的问题细化为更小的步骤，每个方法只负责完成一小部分功能。这样不仅使程序的逻辑更清晰，也提高了代码的可重用性和可维护性。

---

int com = Compare(Compare(5,6),7);
System.out.print(com);
 
public static int Compare(int a,int b){
    return a>b?a:b;
}

在给定的代码中，首先调用了Compare(5, 6)方法，传入参数5和6。Compare方法中比较了两个数的大小，返回较大的数，即6。然后，再将返回的结果6和参数7一起传入另一个Compare方法中，即Compare(6, 7)。这次比较后，返回的结果是7，因为7大于6。

接下来，将返回的结果7赋值给变量com。之后，调用System.out.print(com);

解释：初始的两个数为5和6，其中6比5大，所以第一个Compare方法返回6。然后，将6和7一起传入第二个Compare方法进行比较，得到7，最后将结果7打印出来。