Java中的方法

方法的定义

Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合；方法包含于类或对象中；方法在程序中被创建，在其他地方被引用。一般情况下，定义一个方法包含以下语法：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
• 返回值类型 ：方法可能会返回值。是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，是关键字void。
• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• 方法体：方法体包含具体的语句，定义该方法的功能。

实例代码:

public int add(int num1,int num2){
    return num1 + num2;
}

方法的调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

result = calculator.mul(num1,num2);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("hello world");

方法重载

Java允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）。例如，在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。

public void println(int i){…}
public void println(double d){…}
public void println(String s){…}

方法重载的要求是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。使用方法重载其实就是避免出现繁多的方法名，有些方法的功能是相似的，如果重新建立一个方法，重新取个方法名称，会降低程序可读性。实例代码：

//方法重载
public static int add(int num1,int num2){
    return num1+num2;
}

public static int add(int num1,int num2,int num3){
    return num1 + num2 + num3;
}

命令行传参

在Java中我们的main方法可以传入多个参数，通过命令行进行调用执行的时候，可以进行传参，我们用下面代码进行演示:

public static void main(String[] args) {
    for (int i = 0; i < args.length; i++) {
        System.out.println("args[" + i + "] = " + args[i]);
    }
}

通过命令行界面传参执行代码：

在写类名的时候要写完整的类名，将所在的包也写完整。

可变参数

在 Java 5 中提供了变长参数，允许在调用方法时传入不定长度的参数。变长参数是 Java 的一个语法糖，本质上还是基于数组的实现：

public static void PrintMax(int... nums)

在定义方法时，在最后一个形参后加上三点 …，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。上述定义有几个要点需要注意：

• 可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数

• 由于可变参数必须是最后一个参数，所以一个函数最多只能有一个可变参数

• Java的可变参数，会被编译器转型为一个数组

• 变长参数在编译为字节码后，在方法签名中就是以数组形态出现的。这两个方法的签名是一致的，不能作为方法的重载。如果同时出现，是不能编译通过的。可变参数可以兼容数组，反之则不成立

  public void foo(String...varargs){}
  foo("arg1", "arg2", "arg3");
  //上述过程和下面的调用是等价的
  foo(new String[]{"arg1", "arg2", "arg3"});
  

实例演示:

public static void main(String[] args) {
    PrintMax(3,5,2,4);//5
    PrintMax(13,10,15,34,56);//56
}
//通过传入可变参数，传入参数的个数是可变的
public static void PrintMax(int... nums){
    if(nums.length == 0){
        System.out.println("传入的参数必须大于一个");
        return;
    }

    int result = nums[0];
    //排序比较，将最大值赋值给result
    for (int i = 1; i < nums.length; i++) {
        if(nums[i] > result){
            result = nums[i];
        }
    }
    System.out.println("最大值为: " + result);
}

递归

编程语言中，函数Func(Type a,……)直接或间接调用函数本身，则该函数称为递归函数。递归包含两个部分：递归头和递归体。递归头决定什么时候结束调用，递归体决定什么时候调用自己。递归调用的细节：必须要求递归中有可以让函数调用的结束条件。否则函数一直调用，就会导致内存溢出。

实例演示：

//使用递归求阶乘
public static void main(String[] args) {
    System.out.println(func(5));//120
}

public static int func(int i){
    if(i == 1){//递归头，当参数为1的时候返回1
        return 1;
    }else{//递归体，当参数大于1的时候，调用自己
        return i * func(i-1);
    }
}

小实战

我们使用方法、循环、选择结构来写一个小型计算器代码：

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Calculator calculator = new Calculator();
        boolean flag = true;
        //通过一个循环，多次执行计算器逻辑，直到用户选择退出系统，通过一个flag标志来标识
        while(flag){
            System.out.println("请选择要进行的算术运算");
            System.out.println("1. 加");
            System.out.println("2. 减");
            System.out.println("3. 乘");
            System.out.println("4. 除");
            System.out.println("5. 退出");
            int order = scanner.nextInt();
            int num1,num2,result;
            //通过switch选择结构来进行选择对应的想要调用的算术逻辑结构
            switch(order){
                case 1:
                    System.out.println("请输入想要相加的两个整数:");
                    num1 = scanner.nextInt();
                    num2 = scanner.nextInt();
                    result = calculator.add(num1,num2);
                    System.out.println("结果为: " + result);
                    break;
                case 2:
                    System.out.println("请输入想要相减的两个整数:");
                    num1 = scanner.nextInt();
                    num2 = scanner.nextInt();
                    result = calculator.sub(num1,num2);
                    System.out.println("结果为: " + result);
                    break;
                case 3:
                    System.out.println("请输入想要相乘的两个整数:");
                    num1 = scanner.nextInt();
                    num2 = scanner.nextInt();
                    result = calculator.mul(num1,num2);
                    System.out.println("结果为: " + result);
                    break;
                case 4:
                    System.out.println("请输入想要相除的两个整数:");
                    num1 = scanner.nextInt();
                    num2 = scanner.nextInt();
                    result = calculator.div(num1,num2);
                    System.out.println("结果为: " + result);
                    break;
                case 5:
                    flag = false;
                    break;
                default:
                    System.out.println("输入的指令非法");
            }
        }
        System.out.println("退出系统");
    }
    //定义相加方法，并将相加的结果返回
    public int add(int num1,int num2){
        return num1 + num2;
    }
    //定义相减方法，并将相减的结果返回
    public int sub(int num1,int num2){
        return num1 - num2;
    }
    //定义相乘的方法，并将相乘的结果返回
    public int mul(int num1,int num2){
        return num1*num2;
    }
    //定义相乘的方法，并将相除的结果返回
    public int div(int num1,int num2){
        if(num2==0){
            new RuntimeException("除数不能为0");
        }
        return num1 / num2;
    }
}