JAVA 方法

方法是一段可以重复执行的代码，我们对其进行封装起来，方便调用，节省代码。

1. 传统方法 

1.1 定义传统方法，定义传统方法，需要确定返回值类型，方法名和参数等三要素。

      语法格式 : 

public static 返回值类型 方法名(类型 形参1， 类型 形参2， ……）{
    方法体;
    [return 表达式];
}

上面的语法格式中，方法声明前面加入public static 关键字，表示该方法能直接被main() 方法调用。

1.2 调用传统方法

方法名(实参1， 实参2， ……）

package String_;
 
public class foreach_test {
 
    public static void printBook(String name)
    {
        if(name.equals("孔子")){
            System.out.println("孔子的代表作是《论语》");
        } else if(name.equals("老子")){
            System.out.println("老子的代表作是《道德经》");
        } else if (name.equals("司马光")) {
            System.out.println("司马光的代表作是《资治通鉴》");
        } else {
            System.out.println("抱歉，没找到" + name + "的代表作");
        }
    }
 
    public static double total(double arr[]){
        double sum = 0;
        for(double d : arr){
            sum += d;
        }
        return sum;
    }
 
    public static void main(String[] args) {
        printBook("老子");
        double score[] = {88.3, 98.4, 96.3};
        System.out.println("总分是: " + total(score));
    }
}

1.3  参数传递方式

Java方法的实参向形参传递参数也有两种方式：传递基本数据类型和传递引用类型。如果传递引用类型(相当于C/C++传递指针)，形参的改变影响实参。

package String_;
 
import java.util.Arrays;
 
public class Demo0103 {
    public static void update(int [] arr, int location, int newValue){
        arr[location] = newValue;
        String str = Arrays.toString(arr);
        System.out.println("形参数组:\t\t" + str);
    }
 
    public static void main(String[] args) {
        int tempArr[] = {1,3,5};
        update(tempArr, 1, 100);
        String strTempArr = Arrays.toString(tempArr);
        System.out.print("原始数组(实参)：\t" + strTempArr);
    }
}

2.  形参长度可变方法

2.1 定义形参长度可变方法

public static 返回值类型 方法名(类型 形参1， 类型 形参2， 类型……形参){
    方法体;
    [return 表达式];
}

定义方法时，最后一个形参类型后增加省略号，表明该形参能接受个数不确定的实参，多个实参被当成数组传入。

定义形参长度可变方法需要注意两点：a. 方法只能定义一个可变形参；b. 如果这个方法还有其他形参，他们要放在可变形参之前。

编译时，编译器会把最后一个可变形参转换为一个数组形参， 并在编译的class文件中标上记号，表明该方法的实参个数可变。

public static int total(int begin, int end, int... arr){
    int sum = 0;
    if(!(begin >= 0 && end <= arr.length))
        return sum;
    for(int i = begin; i < end; i++)
        sum += arr[i];
 
    return sum;
}

2.2  调用形参长度可变方法

调用形参长度可变方法有两种形式：a. 实参是对应类型的一维数组；b. 实参是若干对应类型的变量或常量。

格式 : 

    方法名(实参1， 实参2， 数组名)

或者

    方法名(实参1， 实参2， 实参x1, 实参x2, ..., 实参n)

package String_;
 
public class Demo0202 {
    public static void main(String[] args) {
        int arr[] = {3,4,5,6};
        int sum1 = total(0, arr.length, arr); // 第一种调用，实参是数组
        int sum2 = total(0 , 3, new int[]{5,6,7,8,9}); // 第一种调用，实参是数组
 
        int sum3 = total(0, 2, 9, 8, 7, 6);
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
    }
 
    public static int total(int begin, int end, int... arr){
        int sum = 0;
        
        if(!(begin >= 0 && end <= arr.length))
            return sum;
 
        for(int i = begin; i < end; i++)
            sum += arr[i];
 
        return sum;
    }
}

3. 方法重载

一个类中定义多个同名方法，但这些方法的参数类型和个数不同，称这些方法是重载(overload)。编译阶段，Java编译器根据每个方法的参数类型和个数决定调用哪个具体方法。

package String_;
 
public class Demo0301 {
    public static void main(String[] args) {
        int a = 1921;
        int b = 28;
        int c = 29;
        String s1 = "1921";
        String s2 = "28";
        System.out.println(a + " + " + b + " = " + add(a, b));
        System.out.println(s1 + " + " + s2 + " = " + add(s1, s2));
        System.out.println("s1 + s2 = " + s1 + s2);
        System.out.println(a + " + " + b + " + " + c + " = " + add(a,b,c));
    }
 
    public static int add(int a , int b){
        return a + b;
    }
 
    public static String add(String a, String b){
        return a + b;
    }
 
    public static int add(int a, int b, int c){
        return a + b + c;
    }
}

定义方法重载时，有以下三个问题需要注意。

a. 一个类中(或者有继承关系的类之间)的方法才能重载，不同类中的方法不能重载。

如下两个add方法签名一样，但是不是重载关系

class DemoX{
    int add(int x, int y){
        return x + y;
    }
}
 
class DemoY{
    int add(int x, int y){
        return x + y;
    }
}

b.  方法重载有3种形式：① 方法声明的形参个数不同；②方法声明中对应的形参类型不同；③方法声明的形参个数和类型都不同；

c.  方法的返回值类型不同不能作为方法重载的依据；

如下代码段类的两个add方法不是重载

class DemoX{
    int add(int x, int y){
        return x + y;
    }
    String add(int x, int y){
        return String.valueOf(x) + String.valueOf(y);
    }
}

4. 递归方法

package String_;
 
public class Demo0401 {
    public static void main(String[] args) {
        int number = 10;
        System.out.println(number + " != " + factorial(number));
    }
 
    public static long factorial(int num){
        if(1 == num)
            return 1;
        else
            return factorial(num - 1) * num;
    }
}