方法-总和

发布时间: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类:

  1. 无参数无返回值方法

  2. 无参数有返回值方法

  3. 有参数无返回值方法

  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;
    }

方法分类总结

  1. 如果方法有返回值,在方法体内必须要有return语句。并且 return后面的返回值 必须和 返回值类型一致。

  2. 如果方法有参数,参数可以是1个也可以是多个,如果是多个参数,参数与参数之间用“,”隔开。

  3. 定义方法时的参数叫形参(形式参数),调用方法时的参数叫实参(实际参数)。

  4. 定义方法时:参数的类型和参数名都不能少。

  5. 调用方法时:不需要参数类型

  6. 参数可以是常量、变量、表达式、或者另外一个方法的返回值。

  7. 方法不能嵌套定义。

形参、实参

形参

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

实参

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

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

实参到形参只是单向的值拷贝过程。如果实参是个数据,会把数据拷贝给形参;如果实参是个地址,会把地址拷贝给形参。----实参和形参是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个数的最大值

  1. 需求:设计一个方法,用于打印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个数的最大值

  1. 需求:设计一个方法,返回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的和

  1. 需求:设计一个方法,有两个参数min和max,计算从min累加到max的和。

  2. 代码:

        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;
        }

限制用户输入内容

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

  2. 代码:

        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;
        }

计算数字位数

  1. 需求:设计一个方法计算数字是几位数。

  2. 代码:

        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游戏

  1. 需求:设计一个方法,实现数n游戏,n是一个0~9之间的数。

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

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

  2. 代码:

        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();
        }

查看数组中是否包含某个数据(练习)

  1. 需求:设计一个方法,查找数组中是否包含指定的数据。

  2. 代码:

        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;
        }

判断两个数组是否相等(练习)

  1. 需求:设计一个方法,判断两个数组是否相等

  2. 代码:

        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;
        }

数组拷贝

  1. 需求:设计一个方法,实现数组拷贝

  2. 代码:

        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();
        }

数组翻转

  1. 需求:设计一个方法,实现数组翻转

  2. 代码:

        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();
        }

冒泡排序

  1. 需求:设计一个方法,实现数组排序(冒泡)。

  2. 代码:

        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
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。