方法-总和

发布时间：2024年01月15日

方法的概述

什么是方法？

方法是具有特定功能的代码块。

简单的理解就是：把一段完整的代码，看成一个整体，并给这段代码起个名字，以后在用的时候，使用这个名字就相当于执行了这一段代码。

例如：洗衣机洗衣服就是一系列动作看成了一个整体。打开洗衣机，放入衣服，放入洗衣液，注水，洗涤，甩干，排水。一提到洗衣机洗衣服，我们就会想到上述过程。

方法必须先创建才可以使用，创建只需要进行一次创建，使用可以多次。方法的创建过程称为方法的定义。

和变量类似，变量必须先定义再使用，方法也是先定义再使用。

方法创建后并不是直接运行的，需要手动使用才执行，使用方法称为方法调用。

方法的定义

方法隶属于类，因此方法要定义在类中，且方法不能定义在别的方法内。---类后面会详细讲。

方法定义的格式

public static 返回值类型 方法名(参数列表){
 ? ?方法体
}

public、static在讲类和对象的时候会详细讲，此处先固定这么写。

方法名的命名规范和变量名的命名规范相同。

返回值、参数列表下面专门讲解。

方法定义示例

    public static void sum() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数，将为您计算1到这个数的和：");
        int num = scanner.nextInt();
        int sum = 0;
        for(int i = 1; i <= num; i++) {
            sum += i;
        }
        System.out.println("1到" + num + "的和是：" + sum);
    }

上述案例就是一个方法，这个方法的功能是计算从1到num的和，num是用户输入的数据。

由此可见：方法是一个具有特定功能的代码段。我们定义的方法sum的功能是求从1到num的和。

方法的调用

方法定义好之后，就可以在想要使用的时候调用方法，达到使用方法的目的。

方法调用的格式

方法名(参数);

方法调用的示例

public class LessonMethod {
?
    public static void main(String[] args) {
        sum();//调用sum方法
    }
?
    public static void sum() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数，将为您计算1到这个数的和：");
        int num = scanner.nextInt();
        int sum = 0;
        for(int i = 1; i <= num; i++) {
            sum += i;
        }
        System.out.println("1到" + num + "的和是：" + sum);
    }
}

上述代码就是方法的调用，main方法是程序的入口，在main方法中我们调用了sum方法。

方法可以简化程序的代码，让代码得以复用。

方法的调用过程

    public static void main(String[] args) {
        System.out.println("sum方法执行之前");
        sum();
        System.out.println("sum方法执行之后");
        sum();
        System.out.println("sum方法再次执行之后");
    }
?
    public static void sum() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数，将为您计算1到这个数的和：");
        int num = scanner.nextInt();
        int sum = 0;
        for(int i = 1; i <= num; i++) {
            sum += i;
        }
        System.out.println("1到" + num + "的和是：" + sum);
    }

程序的入口是main方法，因此程序一旦运行会自动执行main方法。

首先会打印一句话 “sum方法执行之前”

然后执行 sum 方法，此时程序会跳转到sum方法中，将sum方法中的代码全部执行完毕之后，回到main方法中。此时相当于 sum() 执行完毕。

然后打印一句话 “sum方法执行之后”

紧接着执行sum方法，此时程序会跳转到sum方法中，将sum方法中的代码全部执行完毕之后，回到main方法中。此时相当于 sum() 执行完毕。

然后打印一句话 “sum方法再次执行之后”

最后main函数结束执行，程序结束。

方法的组成

修饰符：public、static

方法名称：命名方式遵循变量的命名方式

参数：方法执行所需要的外界数据，多个参数用 "," 分隔。

返回值：方法执行完之后，给外界的数据。

方法体：方法中封装的要执行的代码

例如：

public static 饭 买饭(钱, 饭的名字){
    买饭的具体过程
}

再例如：

public static 钱 ATM取钱(银行卡, 取款金额){
 ? ?取款的具体过程
}

方法的分类

方法按有没有参数，有没有返回值可以分为以下4类：

无参数无返回值方法
无参数有返回值方法
有参数无返回值方法
有参数有返回值方法

无参数无返回值方法

如果一个方法没有参数，也没有返回值，这样的方法就是无参数无返回值方法。

如果方法没有返回值，我们在定义方法的时候，将返回值类型指定为 void。

无参数无返回值方法的定义格式

public static void 方法名(){
 ? ?方法体
}

无参数无返回值方法示例

    public static void sum() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数，将为您计算1到这个数的和：");
        int num = scanner.nextInt();
        int sum = 0;
        for(int i = 1; i <= num; i++) {
            sum += i;
        }
        System.out.println("1到" + num + "的和是：" + sum);
    }

无参数无返回值方法的调用格式

方法名();

无参数无返回值方法的调用示例

    public static void main(String[] args) {
        sum();//调用sum方法
    }
?
    public static void sum() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数，将为您计算1到这个数的和：");
        int num = scanner.nextInt();
        int sum = 0;
        for(int i = 1; i <= num; i++) {
            sum += i;
        }
        System.out.println("1到" + num + "的和是：" + sum);
    }

无参数有返回值方法

如果一个方法没有参数，但是有返回值，这样的方法就是无参数有返回值方法。

如果方法有返回值，方法体里要通过return语句将结果返回给外界。

定义方法时，返回值类型必须和方法体中return 返回的值的类型一致。

无参数有返回值方法的定义格式

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

无参数有返回值方法示例

public static double PI(){
 ? ?return 3.1415926;
}

无参数有返回值方法的调用格式

数据类型 变量名 = 方法名();//如果外界要用返回值，拿一个变量接收返回值

或

方法名();//如果外界不需要使用返回值，可以不接收

无参数有返回值方法的调用示例

    public static void main(String[] args) {
        double num = PI();//方法调用
        double area = num * 10 * 10;
        System.out.println(area);
    }
    
    public static double PI() {
        return 3.1415926;
    }

有参数无返回值方法

有参数无返回值方法的定义格式

public static void 方法名(参数类型 参数名1, 参数类型 参数名2, ...){
 ? ?方法体
}

有参数无返回值方法示例

    //打印一个整数
    public static void printNum(int num) {
        System.out.println(num);
    }
    
    //打印一个数组
    public static void printArray(int[] array) {
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

有参数无返回值方法的调用格式

方法名(参数值1,参数值2,...);

有参数无返回值方法的调用示例

    public static void main(String[] args) {
        int a = 100;
        printNum(a);//方法调用
 ? ? ? ?
        int[] arr = {10, 7, 21, 13, 45, 17};
        printArray(arr);//方法调用
    }
?
    // 打印一个整数
    public static void printNum(int num) {
        System.out.println(num);
    }
?
    // 打印一个数组
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

有参数有返回值方法

有参数有返回值方法的定义格式

public static 返回值类型 方法名(参数类型 参数1, 参数类型 参数2, ...){
 ? ?方法体
 ? ?return 返回值;
}

有参数有返回值方法示例

    //计算圆的面积
    public static double area(double r) {
        return 3.1415926 * r * r;
    }
    
    //求三个数的和
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

有参数有返回值方法的调用格式

数据类型 变量名 = 方法名(参数1,参数2,...);//如果外界要用返回值，拿一个变量接收返回值

或

方法名(参数1,参数2,...);//如果外界不需要使用返回值，可以不接收

有参数有返回值方法的调用示例

    public static void main(String[] args) {
        double a = area(10);//方法调用
        System.out.println(a);
 ? ? ? ?
        int sum = sum(10,20,30);//方法调用。变量名可以和方法名重名。
        System.out.println(sum);
    }
    // 计算圆的面积
    public static double area(double r) {
        return 3.1415926 * r * r;
    }
    // 求三个数的和
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

方法分类总结

如果方法有返回值，在方法体内必须要有return语句。并且 return后面的返回值必须和返回值类型一致。
如果方法有参数，参数可以是1个也可以是多个，如果是多个参数，参数与参数之间用“,”隔开。
定义方法时的参数叫形参（形式参数），调用方法时的参数叫实参（实际参数）。
定义方法时：参数的类型和参数名都不能少。
调用方法时：不需要参数类型
参数可以是常量、变量、表达式、或者另外一个方法的返回值。
方法不能嵌套定义。

形参、实参

形参

形参：全名叫形式参数，出现在方法定义中，形参只是用来占位的，用来代表未来调用方法时传递过来的数据。

实参

实参：全名叫实际参数，出现在方法调用中，实参是方法执行时真正要用到的数据。在方法调用时，会把实参传递给形参，在执行方法过程中用于参与运算。

在方法调用时，要保证实参的数据类型和形参的数据类型一致。

实参到形参只是单向的值拷贝过程。如果实参是个数据，会把数据拷贝给形参；如果实参是个地址，会把地址拷贝给形参。----实参和形参是2个变量，只是值相等，实参的值拷贝给了形参。

    public static void main(String[] args) {
        int num = 100;
        changeValue(num);
 ? ? ? ?System.out.println(num)
?
        int[] arr = { 10, 20, 30 };
        changeArrayValue(arr);
 ? ? ? ?System.out.println(arr[0]);
    }
?
    public static void changeValue(int num) {
        num = 200;
    }
?
    // 打印一个数组
    public static void changeArrayValue(int[] array) {
        arry[0]=200;
    }

如果参数是引用类型，可以在方法内修改内容。

如果参数是基本数据类型，无法在方法内修改内容。

方法重载

在同一个类中，如果多个方法具有相同的方法名，但参数类型或者参数个数不相同（或都不相同），这就是方法的重载。-----方法重载和返回值没有关系，不看返回值，只看方法名以及参数。

    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(3.5, 2.0));
        System.out.println(sum(1,2,3));
    }
    
    public static double sum(double x, double y) {
        return x +y;
    }
    
    public static int sum(int x, int y) {
        return x +y;
    }
    
    public static int sum(int x, int y, int z) {
        return x + y + z;
    }

不定参数方法

不定参数方法：指的是方法的参数是可变的，不确定的，只有调用的时候，才知道参数的具体个数。

    public static void main(String[] args) {
        int num1 = calculate(1,2,3);
        System.out.println(num1);
        int num2 = calculate(100,20,50,30,200,150);
        System.out.println(num2);
    }
    
    //不定参数方法
    public static int calculate(int... nums) {
        int sum = 0;
        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }

在不定参数的方法里，形参本质上是一个数组，数组里存放的是各个实参，实参按顺序存入数组。取的时候按数组名[下标]取出元素使用即可。

    public static void main(String[] args) {
        int num1 = calculate(true, 1, 2, 3, 4, 5);
        System.out.println(num1);
        int num2 = calculate(false, 2, 5, 20);
        System.out.println(num2);
    }
    
    //不定参数方法---既有固定参数，又有不定参数时，不定参数要放到最后。
    public static int calculate(boolean doAdd,int... nums) {
        int result = doAdd ? 0 : 1;//如果是求和，初值设置为0，否则初值设置为1（求乘积）
        if(doAdd) {
            for(int i = 0; i < nums.length; i++) {
                result += nums[i];
            }
        }else {
            for(int i = 0; i < nums.length; i++) {
                result *= nums[i];
            }
        }
        return result;
    }

不定参数有两个规定：

第一，方法的参数列表中最多只有一个不定长度的参数；

第二，就是不定长度的参数的位置必须是最后一个参数。

对于第一个规定，是因为如果有多于一个不定长度的参数，当真正调用这个方法的时候，JVM将不知道前面的不定长度参数有多长, 下一个参数是从哪里开始.

对于第二个参数也是一样，编译器不知道不定长度参数的长度，无法确定从哪里开始下一个参数。

不定参数方法，也可以重载。

方法练习

打印2个数的最大值

需求：设计一个方法，用于打印2个数中的最大数，并调用方法测试结果是否正确。

代码：

public static void main(String[] args) {
        System.out.print("请输入2个整数：");
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        printMaxNum(x, y);
    }
    //需求：设计一个方法，用于打印2个数中的最大数，并调用方法测试结果是否正确。
    //分析：
    //1.打印2个数的最大数。----无需返回值、有2个参数、方法名见名知意。
    //2.方法体： 计算出最大值，并打印最大值。
    //3.在main方法中调用方法，测试方法的正误
    public static void printMaxNum(int a, int b) {
        int max = a > b ? a : b;
        System.out.println(max);
    }

求2个数的最大值

需求：设计一个方法，返回2个数的最大值，并调用方法测试结果是否正确。

代码：

    public static void main(String[] args) {
        System.out.print("请输入2个整数：");
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        int max = maxOfTwoNum(x, y);
        System.out.println(max);
    }
    
    //需求：设计一个方法，返回2个数的最大值，并调用方法测试结果是否正确。
    //分析：
    //1. 返回2个数的最大值----- 有返回值， 有2个参数，返回值类型和参数类型相同 ， 方法名见名知意
    //2. 方法体： 计算2个数的最大值，返回最大值。
    //3. 在main方法中调用方法，测试方法的正误
    public static int maxOfTwoNum(int num1, int num2) {
        int max = num1 > num2 ? num1 : num2;
        return max;
    }

在设计方法的时候，一定要弄清楚2件事：1.有没有参数，几个参数，每个参数什么数据类型；2.有没有返回值，返回值是什么类型。

一般来说：如果某个方法只是为了完成某件事情，这样的方法通常没有返回值。如果某个方法是为了做计算，这样的方法通常会有返回值。

求从min到max的和

需求：设计一个方法，有两个参数min和max，计算从min累加到max的和。

代码：

    public static void main(String[] args) {
        int a = sum(5, 8);
        int b = sum(1, 100);
        System.out.println(a);
        System.out.println(b);
    }   
    
    //需求：设计一个方法，有两个参数min和max，计算从min累加到max的和。
    //分析：
    //有返回值，有2个参数。
    //方法体：计算从min到max的和
    public static int sum(int min, int max) {
        int sum = 0;
        for(int i = min; i <= max; i++) {
            sum += i;
        }
        return sum;
    }

限制用户输入内容

需求：设计一个方法，获取用户输入的数据。要求用户必须输入0~9之间的数，如果不是，让用户重新输入，直到用户输入的内容合法。

代码：

    public static void main(String[] args) {
        int num = getInputNum();
        System.out.println(num);
    }   
    //需求：设计一个方法，获取用户输入的数据。
    //要求用户必须输入0~9之间的数，如果不是，让用户重新输入，直到用户输入的内容合法。
    //分析：
    //有返回值，没有参数
    //方法体：处理用户输入过程
    public static int getInputNum() {
        Scanner scanner = ?new Scanner(System.in);
        int num = 0;
        do {
            System.out.print("请输入0~9之间的数：");
            num = scanner.nextInt();
            if(num >= 0 && num <= 9) {
                break;
            }else {
                System.out.println("输入的内容超出范围！");
            }
        }while(true);
 ? ? ? ?
        return num;
    }

计算数字位数

需求：设计一个方法计算数字是几位数。

代码：

    public static void main(String[] args) {
        System.out.println(bitsOfNum(9527));
        System.out.println(bitsOfNum(10086));
    }   
    //需求：设计一个方法计算数字是几位数。
    //分析：
    //有返回值，有1个参数
    //方法体：计算数字的位数
    public static int bitsOfNum(int num) {
        int bits = 0;
        while(num != 0) {
            num /= 10;
            bits++;
        }
        return bits;
    }

数7游戏

需求：设计一个方法，实现数n游戏，n是一个0~9之间的数。

数n游戏：遍历100以内的数字，如果数字是n的倍数或者数字包含n，输出过，否则输出数据本身。

例如：如果数字是7的倍数或者数字包含7，输出过，否则输出数据本身。

代码：

    public static void main(String[] args) {
        countGame(7);
        countGame(4);
        countGame(9);
    }
    //需求：设计一个方法，实现数n游戏，并调用方法测试结果是否正确。
    //数n游戏：遍历100以内的数字，如果数字是n的倍数或者数字包含n，输出过，否则输出数据本身。
    //分析：
    //1. 通过分析得知，无需返回值，需要一个参数（数几）。
    //2. 方法体：遍历100以内的数，根据判断结果输出内容
    //3. 在main方法中调用方法，测试方法的正误
    public static void countGame(int num) {
        for(int i = 1; i < 100; i++) {
            if(i % num == 0 || (i % 10 == num || i / 10 == num)) {
                System.out.print("过 ");
            }else {
                System.out.print(i + " ");
            }
        }
        System.out.println();
    }

查看数组中是否包含某个数据（练习）

需求：设计一个方法，查找数组中是否包含指定的数据。

代码：

    public static void main(String[] args) {
        int[] array = {10, 20, 18, 32, 7};
        System.out.println(isArrayContainsNum(array, 20));
        System.out.println(isArrayContainsNum(array, 15));
    }   
    //需求：设计一个方法，查找数组中是否包含指定的数据。
    //分析：
    //有返回值（boolean类型）  有2个参数
    public static boolean isArrayContainsNum(int[] arr, int num) {
        boolean isContain = false;
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] == num) {
                isContain = true;
                break;
            }
        }
        return isContain;
    }

判断两个数组是否相等（练习）

需求：设计一个方法，判断两个数组是否相等

代码：

    public static void main(String[] args) {
        int[] array = {10, 20, 18, 32, 7};
        int[] array2 = {10, 20, 18, 32, 7};
        System.out.println(isArrayEqual(array, array2));
    }   
    //需求：设计一个方法，判断两个数组是否相等
    //有返回值（boolean类型），有2个参数
    public static boolean isArrayEqual(int[] arr1, int[] arr2) {
        boolean isEqual = true;
        int length1 = arr1.length;
        int length2 = arr2.length;
        if(length1 == length2) {
            for(int i = 0; i < length1; i++) {
                if(arr1[i] != arr2[i]) {
                    isEqual = false;
                    break;
                }
            }
        }else {
            isEqual = false;
        }
        return isEqual;
    }

数组拷贝

需求：设计一个方法，实现数组拷贝

代码：

    public static void main(String[] args) {
        int[] array = {10, 20, 18, 32, 7};
        int[] array2 = new int[10];
        arrayCopy(array, array2);
        printArray(array2);
    }   
    //需求：设计一个方法，实现数组拷贝
    //有返回值（boolean类型）  2个参数
    public static boolean arrayCopy(int[] source, int[] destination) {
        int sourceLength = source.length;
 ? ? ? ?int destinationLength = destination.length;
        if(destinationLength < sourceLength) {
            return false;
        }else {
            for(int i = 0; i < sourceLength; i++) {
                destination[i] = source[i];
            }
            return true;
        }
    }
    // 打印一个数组
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

数组翻转

需求：设计一个方法，实现数组翻转

代码：

    public static void main(String[] args) {
        int[] array = { 10, 20, 18, 32, 7 };
        printArray(array);
        invertArray(array);
        printArray(array);
    }
?
    // 需求：设计一个方法，实现数组翻转
    // 没有返回值，有参数
    public static void invertArray(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }
?
    // 打印一个数组
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

冒泡排序

需求：设计一个方法，实现数组排序（冒泡）。

代码：

    public static void main(String[] args) {
        int[] array = {18, 25, 11, 36, 9, 20, 3};
        bubbleSort(array);
        printArray(array);
    }
    
    //需求：设计一个方法，实现往数组数组排序（冒泡）。
    //分析：
    //无返回值，有一个参数
    public static void bubbleSort(int[] arr) {
        for(int i = 0; i < arr.length - 1; i++) {
            for(int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    // 打印一个数组
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

总结

方法是具有特定功能的代码块。方法可以大大简化程序的代码，提高代码的复用度。

方法分为：无参数无返回值方法，无参数有返回值方法，有参数无返回值方法，有参数有返回值方法。

方法必须先定义，再使用。

方法调用时，实参的值会拷贝给形参，实参和形参是2个变量。

在Java中，方法可以重载。

不定参数的方法，不定参数一定要放到末尾，而且一个方法最多只能有1个不定参数。

文章来源:https://blog.csdn.net/m0_58798123/article/details/135574378
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！