Java奠基】方法的讲解与使用

目录

方法概述

方法的定义与调用

方法的重载

方法的值传递

方法概述

方法是程序中最小的执行单元，在实际开发中会将重复的具有独立功能的代码抽取到方法中，这样可以提高代码的复用性和可维护性。

方法的定义与调用

在Java中定义方法的格式都是相同的，不过根据具体的需要可以抽离成以下三种形式方法，如下：

最简单的方法定义，格式如下：

public static void 方法名() { 方法体(就是打包起来的代码) };

public class Main {
    public static void main(String[] args) {
        // 调用say方法
        say();
    }
    // 定义一个方法
    public static void say(){
        System.out.println("你好，世界！"); // 你好，世界！
    }
}

带参数的方法定义，格式如下：

public static void 方法名(参数1,参数2….){ 方法体 };

求和

public class Main {
    public static void main(String[] args) {
        // 调用getSum方法
        getSum(10,20); // 实参，方法调用中的参数
    }
    // 定义一个方法
    public static void getSum(int n,int m){ // 形参，方法定义中的参数
        int sum = n + m;
        System.out.println(sum);
    }
}

打印原数组

public class Main {
    public static void main(String[] args) {
        // 将数组进行打印在控制台
        int[] arr = {12,14,15,16,17,18};
        // 调用方法
        printArr(arr); // [12,14,15,16,17,18]
    }
    // 定义一个方法
    public static void printArr(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else{
                System.out.print(arr[i]+",");
            }
        }
        System.out.print("]");
    }
}

带返回值的方法定义，格式如下：

public static 返回值类型 方法名 (参数) { 方法体; return 返回值; };

如果想在调用处要根据方法的结果，去编写另外一段代码的逻辑，为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法。方法的返回值其实就是方法运行的最终结果。

数组求和

public class Main {
    public static void main(String[] args) {
        // 直接调用，如果是带有返回值的方法，是没有任何结果的
        getSum(10,20,30);

        // 赋值调用
        int result = getSum(10,20,30);
        System.out.println(result); // 60

        // 输出调用
        System.out.println(getSum(10,20,30)); // 60
    }
    // 定义一个方法
    public static int getSum(int n,int m,int x){
        int sum = n + m + x;
        return sum;
    }
}

数组求最大值

public class Main {
    public static void main(String[] args) {
        // 将数组进行打印在控制台
        int[] arr = {12,14,15,16,17,18};
        // 调用方法
        int result = getMax(arr);
        // 打印
        System.out.println(result); // 18
    }
    // 定义一个方法
    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
}

判断数组是否存在元素

public class Main {
    public static void main(String[] args) {
        // 定义数组
        int[] arr = {12,14,15,16,17,18};
        // 判断一个数字是否在数组中存储
        boolean result = decide(arr,10);
        // 打印结果
        System.out.println(result); // false
    }
    // 定义一个方法
    public static boolean decide(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number){
                return true;
            }
        }
        // 当数组中的所有数据比较完毕之后，还是没有任何结果则执行以下语句。
        return false;
    }
}

拷贝数组

public class Main {
    public static void main(String[] args) {
        // 定义数组
        int[] arr = {12,14,15,16,17,18};
        // 调用方法拷贝数据
        int[] copyArr = copyArr(arr,1,4);// 14 15 16 
        // 遍历copyArr
        for (int i = 0; i < copyArr.length; i++) {
            System.out.print(copyArr[i]+" ");
        }
    }
    // 定义一个方法
    public static int[] copyArr(int[] arr,int from,int to){
        // 定义数组
        int[] newArr = new int[to - from];
        // 伪造索引
        int index = 0;
        for (int i = from; i < to; i++) {
            newArr[index] = arr[i];
            index++;
        }
        // 将新数组返回
        return newArr;
    }
}

注意：

方法不调用就不执行
方法与方法之间是平级关系，不能互相嵌套定义
方法的编写顺序和执行顺序无关
方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据。

return语句下面，不能编写代码，因为永远执行不到，属于无效代码。

方法的重载

在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。

简单理解：同一个类中，方法名相同，参数不同的方法，与返回值无关。

                  参数不同：个数不同、类型不同、顺序不同。

public class Main {
    public static void main(String[] args) {
        // 调用方法
        compare(1,2);
        compare((byte)1,(byte)2);
        compare((short)1,(short)2);
        compare(1.1,2.2);
    }
    // 定义一个方法
    public static void compare(byte b1,byte b2){
        System.out.println("byte");
    }
    public static void compare(short s1,short s2){
        System.out.println("short");
    }
    public static void compare(int i1,int i2){
        System.out.println("int");
    }
    public static void compare(double d1,double d2){
        System.out.println("double");
    }
}

方法的值传递

传递基本数据类型时，传递的是真实的数据，形参的改变不影响实际参数的值：

public class Main {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前："+number);// 100
        change(number);
        System.out.println("调用change方法后："+number);// 100
    }
    // 定义一个方法
    public static void change(int number){
        number = 200;
    }
}

如果想改变number的值，需要将方法中的number的值return出去来修改main方法的number内存值

传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值：

public class Main {
    public static void main(String[] args) {
        int[] arr = {10,130,12,14,144};
        System.out.println("调用change方法前："+arr[1]);// 130
        change(arr);
        System.out.println("调用change方法后："+arr[1]);// 200
    }
    // 定义一个方法
    public static void change(int[] arr){
        arr[1] = 200;
    }
}