part05——方法

YangeIT大约 24 分钟

part05——方法

目标

方法的概述 🍐
- 方法的定义和调用 ✏️
- 方法的其他形式 🍐
- 方法使用常见的问题 🍐
方法案例 ✏️
方法在计算机中的执行原理 🚀
方法参数的传递机制 🍐
方法重载 🍐
return单独使用 🍐

1.方法概述

概述

方法也是Java语言中一个很重要的组成部分，在实际开发中几乎每时每刻都在使用方法。

方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用。

把一段功能代码围在一起，别人都可以来调用它。

下图是方法的完整格式👇

需求: 比如现在张工、李工两个人都需要求两个整数的和。

不使用方法 👇

// 1、李工。
int a = 10;
int b = 20;
int c = a+b;
System.out.println("和是：" + c);

// 2、张工。
int a1 = 10;
int b1 = 20;
int c1 = a1+b1;
System.out.println("和是：" + c1);

使用方法 👇

//目标：掌握定义方法的完整格式，搞清楚使用方法的好处。
public class MethodDemo1 {
    public static void main(String[] args) {
        // 需求：假如现在很多程序员都要进行2个整数求和的操作。
        // 1、李工。
        int rs = sum(10, 20);
        System.out.println("和是：" + rs);

        // 2、张工。
        int rs2 = sum(30, 20);
        System.out.println("和是：" + rs2);
    }

    public static int sum(int a,int b) {
        int c = a + b;
        return c;
    }
}

方法是一种语法结构，它可以把一段代码封装成一个功能,提高了代码的复用性，提高了开发效率 👍

当调用一个方法时，执行流程，按照下图中标注的序号执行。

① 通过sum方法名找到sum方法
② 把10传递给方法中的参数a
③ 把20传递给方法中的参数b；
④ 执行方法中的代码，此时int c=a+b;; 相当于 int c = 10+20; c的值为30 return c 的含义是，把c的结果返回给调用处。也就是调用sum方法的结果为30,

学习完方法的执行流程之后，下面有几个注意事项需要我们写代码时注意一下。

方法的修饰符：暂时都使用public static 修饰。后期可以改动
方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。
形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须用,隔开，且不能给初始化值。

方法好处:

提高了代码的复用性，提高了开发效率。
让程序的逻辑更清晰。

如下图所示：写好一个方法之后，每一个人都可以直接调用，而不用再重复写相同的代码。所以是提高了代码的复用性，不用写重复代码，自然也提高了开发效率。

那么让程序的逻辑更加清晰，是如何体现的呢？

比如，我们后期会用所学习的技术，做一个ATM系统，ATM系统中有查看账户、存钱、取钱、修改密码等功能，到时候我们可以把每一个功能都写成一个方法。如下图所示，这样程序的逻辑就更加清晰了。点击查看案例代码open in new window

🎉恭喜你🎉，掌握了方法的定义以及方法的基本使用

总结

课堂作业

1. 什么是方法？ 🎤

方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用

2. 方法的完整格式是什么样的？🎤


//格式如下：
修饰符  返回值类型  方法名( 形参列表 ){
    方法体代码(需要执行的功能代码)
    return 返回值;
}

3.方法要执行必须怎么办？🎤

必须调用才执行; 
//调用格式:
方法名(...);

4. 使用方法有什么好处？🎤

提高代码的复用性，提高开发效率，使程序 逻辑更清晰。👍

2.方法的其他形式

方法的其他形式

实际开发中，需要按照方法解决的实际业务需求，设计出合理的方法形式来解决问题。

需要重点关注下面两点:

方法是否需要接收数据处理？
方法是否需要返回数据？

设计一个合理的方法的原则如下：

如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明）, 此时方法内部不可以使用return返回数据。
方法如果不需要接收外部传递进来的数据，则不需要定义形参，且调用方法时也不可以传数据给方法。
没有参数，且没有返回值类型（void）的方法，称为值无参数、无返回值方法。此时调用方法时不能传递数据给方法。

需求

接下来我们看几个案例代码，练习根据实际需求定义出合理的方法

需求1：写一个方法，打印3个"Hello World"

需求2：写一个方法，打印若干个"Hello World"，具体多少个，有调用者指定

需求1：写一个方法，打印3个"Hello World"

分析：需求已经非常明确，打印的是3个HelloWorld，在方法中直接循环3次就可以完成需求。不需要外部给方法传递数据，所以不需要参数。

需求2：写一个方法，打印若干个"Hello World"，具体多少个，有调用者指定

分析：需求不明确打印HelloWorld的个数，而是需要调用者指定。

调用者调用方法时需要给方法传递打印HelloWorld的个数。那么定义方法时，就需要写一个参数，来接收调用者传递过来的个数。

总结

课堂作业

参考定义方法的模板格式，以及需求1-2，练习方法的定义，10分钟✏️

3.方法使用常见的问题 🍐

常见的问题

第一次写方法时，或多或少会可能会出现一些问题。下面把使用方法时，常见的问题整理一下。
目的是让大家写方法时避免出现这些问题。一旦出现这些问题，要知道是什么原因。

注意事项

1. 方法在类中没有先后顺序，但是不能把一个方法定义在另一个方法中。图解open in new window
1. 方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，图解open in new window
- 如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
1. return语句的下面，不能编写代码，属于无效的代码⚠️，执行不到这儿。图解open in new window
1. 方法不调用就不会执行, 调用方法时，传给方法的数据，必须严格匹配方法的参数情况。图解open in new window
1. 调用有返回值的方法，有3种方式：图解open in new window
  - ① 可以定义变量接收结果
  - ② 或者直接输出调用，
  - ③ 直接调用；
1. 调用无返回值的方法，只有1种方式： 只能直接调用。

总结

课堂作业

理解上述的注意事项，并在练习中演示🍐 ✏️

4. 定义方法的案例 ✏️ 🍐❤️

设计方法的技巧，主要关注三方面：

方法是否需要接收数据进行处理？
方法是否需要返回数据？
方法要处理的业务 (编程能力)。

方法的案例

案例

案例1：求1-n之和

案例2：判断一个整数是奇数还是偶数

按照需求：定义方法如下

/*
分析：
	需要求1~n的和，由于n不确定是多少，所以就把n写成形式参数，n的具体值由调用者指定。
	在方法中把n当做一个确定的数据来使用就行。
*/
public static int sum(int n){
    //定义变量接收和
    int sum = 0;
    //开启循环，遍历n次，依次累加
    for (int i = 1; i <= n; i++) {
        // i = 1 2 3 ... n
        sum += i; //等同于 sum=sum+i;
    }
    return sum; //返回和
}

定义好方法之后，在main方法中调用

public static void main(String[] args) {
    int rs = add(5);
    System.out.println("1-5的和是：" + rs); //15
    
    int rs = add(6);
    System.out.println("1-6的和是：" + rs); //21
}

> 提高代码的复用性，提高开发效率，使程序 逻辑更清晰

按照需求：定义方法如下：

/*
分析：
	需求中，是要判断一个数是奇数还是偶数，但是并没有明确说，是哪一个数。
	也就是说这个数可能是奇数，也可以能是偶数，是一个能够变化的数。
	把这个数写成方法的形式参数，就可以达到这个目的。因为调用方法时，调用者可以给传递 	 奇数，也可以传递偶数。
*/
public static void judge(int number){
    if(number % 2 == 0){
        System.out.println(number + "是一个偶数！");
    }else {
        System.out.println(number + "是一个奇数！");
    }
}

定义好方法之后，在main方法中调用

public static void main(String[] args) {
    judge(7); //调用后打印：7是一个奇数
    judge(8); //调用后打印：8是一个偶数
}

总结

课堂作业

题目如下：红色是参数，绿色是返回值

案例1：比较两个int值是否一样，一样返回true 否则返回false
案例2：比较3个int值的大小，返回其中最大的值
案例3：判断1个int值能否被6整除，如果整除返回true，否则返回false
案例4：判断一个数是否存在于某个数组中，如果存在返回true，否则返回false
案例5：判断一个数是否存在于某个数组中，如果存在就在控制台输出存在啊，否则输出不存在啊
案例6：判断1个int值能否被6整除，
- 如果被整除就继续判断是否存在于某个数组中，
  - 存在就在控制台输出 能被6整除存在啊，
  - 否则输出 能被6整除但是不存在啊
- 如果不被整除就输出：都不能被整除，不用判断是否存在了
案例7：定义一个方法用来获取一个任意数字的绝对值

点击查看代码

/**
 * 方法定义案例：
 * 1. 求1-n的和
 * <p>
 * 2. 判断一个整数 是奇数还是偶数
 */
public class MethodDemo2 {

    public static void main(String[] args) {

        //方法功能： 求1-n的和，返回和
        //1. 是否需要输入参数：n
        //2. 是否需要返回数据：sum  int类型
        //3.方法名字：sum
        int c = sum(1);
        System.out.println(c);

        //功能：判断一个整数 是奇数还是偶数，如果是奇数，打印我是奇数，如果是偶数，打印我是偶数
        //1. 有无输入：有  int
        //2. 有无返回：无 void
        //3. 方法名：judgingNumbers
        judgingNumbers(12246);
        System.out.println();


//        案例1：比较两个int值是否一样，一样返回true 否则返回false
        // 有参数，2个  int类型
        // 有返回值，boolean
        // ==  方法名equal
        //1，3 这是实际参数--实参
        boolean b = equal(1, 3);
        System.out.println(b);


//        案例2：比较3个int值的大小，返回其中最大的值
        //有参数，3个，int类型
        //有返回值，int
        int max1 = max(1, 3, 4);
        System.out.println(max1);


//        案例3：判断1个int值能否被6整除，如果整除返回true，否则返回false
        // 有参数 1个  int
        // 有返回  boolean类型
        // m1  n%6==0
        boolean b2 = m1(8);
        System.out.println(b2);


//        案例4：判断一个数是否存在于某个数组中，如果存在返回true，否则返回false
        // 有输入，2个参数，1个事整数一个是 数组
        // 有返回 boolean
        //方法名exist
        int[] arr = {1, 3, 5, 7, 2, 7};
        exist1(21, arr);


        int a = absolute(343);
        System.out.println(a);

        method2(6, arr);

    }


    /**
     * 判断2个数组是否相同
     * @param arr1
     * @param arr2
     * @return
     */
    public static boolean equalArr(int[] arr1,int[] arr2){

        //先判断2个数组是否为空
        if (arr1==null || arr2==null){
            return false;
        }
        //判断长度是否一样
        if (arr1.length!=arr2.length){
            return false;
        }
        //如果长度一样,就比较每个索引下的值，如果不相等就直接返回false
        for (int i = 0; i < arr1.length; i++) {
            int arr1_value=arr1[i];
            int arr2_value=arr2[i];

            if (arr1_value!=arr2_value){
                return false;
            }
        }
        //如果上面的循环，执行完 没有返回，说明都是相等的，返回true
        return true;
    }


    /**
     * 打印数组 输出格式：[12,1,3,3,41,12]
     * @param arr
     */
    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("]");

    }


    //        案例5：判断一个数是否存在于某个数组中，如果存在就在控制台输出 存在啊，否则输出 不存在啊
    // 有无参数：参数1：一个数 int    参数2：某个数组 int
    // 有无返回：无返回void
    // 方法名 exist1  遍历数组，一一的和参数1进行对比，如果相同 输出 存在  结束方法
    //形参 形式参数
    public static void exist1(int in, int[] arr) {

        for (int i = 0; i < arr.length; i++) {
            //获取数组中的数据，和参数1 进行对比
            if (in == arr[i]) {
                System.out.println("存在啊");
                return; //提前结束方法
            }
        }

        System.out.println("不存在啊");

    }

    /**
     * 案例7：定义一个方法用来获取一个任意整数数字的绝对值
     *
     * @param a 有  int
     * @return 绝对值 int 正式
     */
    public static int absolute(int a) {

        //如果a 是负数，则需要乘以一个-1
        if (a < 0) {
            return a * -1;
        } else {
            // 如果a是正数，直接返回a
            return a;
        }


    }




    /**
     * 案例6：判断1个int值能否被6整除(已经写了)，
     * 如果被整除就继续判断 是否存在于某个数组中(已经写了)，
     * 存在就在控制台输出
     * 否则输出 能被6整除但是不存在啊
     * 如果不被整除 就 输出： 都不能被整除，不用判断是否存在了
     *
     *
     *     //有无参数：1个int值，某个数组
     *     //有无返回值：void
     *     //method2  考核点：方法中调用其他的方法
     *
     * @param in
     * @param arr
     */
    public static void method2(int in, int[] arr) {

//        if (in%6==0)
        if (m1(in)) {
            //能被6整除
            if (exist(in, arr)) {
                System.out.println("能被6整除存在啊");
            } else {
                System.out.println("能被6整除但是不存在啊");
            }
        } else {
            //不能被6整除
            System.out.println("都不能被整除，不用判断是否存在了");
        }
    }


    /**
     * 判断一个数是否存在于某个数组中，如果存在返回true，否则返回false
     *
     * @param in
     * @param arr
     * @return
     */
    public static boolean exist(int in, int[] arr) {

        //遍历数组
        for (int i1 = 0; i1 < arr.length; i1++) {
            //获得数组中的元素,如果相等，说明存在，直接返回true
            if (in == arr[i1]) {
                return true;
            }
        }
        return false;
    }


    /**
     * 判断1个int值能否被6整除，如果整除返回true，否则返回false
     *
     * @param i
     * @return
     */
    public static boolean m1(int i) {
        return i % 6 == 0;
    }

    /**
     * 比较3个int值的大小，返回其中最大的值
     *
     * @param i
     * @param j
     * @param z
     * @return
     */
    public static int max(int i, int j, int z) {
        //两两pk 最大者赋值给max
        int max = i > j ? i : j;

        //max和第三者对比，最大者再次赋值给max
        max = max > z ? max : z;

        //返回最大值
        return max;
    }

    /**
     * 比较2个int值 是否一样
     *
     * @param i
     * @param j
     * @return 一样返回true 否则返回false
     */
    public static boolean equal(int i, int j) {

        return i == j;
    }



    /**
     * 判断奇数还是偶数
     *
     * @param i
     */
    public static void judgingNumbers(int i) {
        if (i % 2 == 0) {
            System.out.println(i + "是偶数");
        } else {
            System.out.println(i + "是奇数");
        }


    }


    /**
     * 求1-n的和
     *
     * @param n 参数
     * @return 返回值
     */
    public static int sum(int n) {
        //方法体
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum = sum + i;
        }
        //将处理好的数据，返回
        return sum;

    }


}

5. 方法在机中的执行原理 🚀

前言

Java程序的运行，都是在内存中执行的，而内存区域又分为栈、堆和方法区

Java的方法是在哪个内存区域中执行呢？

栈内存。 每次调用方法，方法都会进栈执行；执行完后，又会弹栈出去。

方法进栈和弹栈的过程，就类似于手枪子弹夹，上子弹和击发子弹的过程。最后上的一颗子弹是，第一个打出来的；第一颗上的子弹，是最后一个打出来的。

假设在main方法中依次调用A方法、B方法、C方法，在内存中的执行流程如下：

每次调用方法，方法都会从栈顶入栈执行
每个方法执行完后，会从栈顶弹栈出去

有返回值的方法，内存分析

下面我们分析一下，求两个整数和的代码，在内存中的执行原理。

public class MethodDemo {
    public static void main(String[] args) {
        int rs = sum(10, 20);
        System.out.println(rs);
	}
    public static int sum(int a, int b ){
        int c = a + b; 
        return c;  
    }
}

如下图所示：以上代码在内存中的执行过程，按照①②③④⑤⑥⑦的步骤执行.

无返回值的方法，内存分析

刚才我们分析的是有有参数有返回值的方法内存原理。下面再分析一个无返回值、无参数的内存原理。

public class Demo2Method {
    public static void main(String[] args) {
        study();
    }

    public static void study(){
		eat();
		System.out.println("学习");
		sleep();
	}
    public static void eat(){
        System.out.println("吃饭");
    }
    
    public static void sleep(){
        System.out.println("睡觉");
    }
}

总结

课堂作业

方法的运行区域在哪里？🎤
栈有什么特点?

6.方法参数的传递机制 🍐

传递机制

先记住一个结论：Java的参数传递机制都是：值传递

所谓值传递：指的是在传递实参给方法的形参的时候，传递的是实参变量中存储的值的副本。那么形参是什么？实参又是什么呢？请看下面这个张图

接下来，看一下方法参数传递是基本类型数据时，内存中是怎么执行的。

我们把参数传递的结论再复习一下：Java的参数传递机制都是：值传递，传递的是实参存储的值的副本。

6.2 参数传递的是引用数据类型

接下来，看一下方法的参数是引用类型的数据时，内存中是怎么执行的。

我们发现调用change方法时参数是引用类型，实际上也是值传递，只不过参数传递存储的地址值。

此时change方法和main方法中两个方法中各自有一个变量arrs，这两个变量记录的是同一个地址值[I@4c873330，change方法把数组中的元素改了，main方法在访问时，元素已经被修改了。

总结

基本类型和引用类型的参数在传递的时候有什么不同？

都是值传递
基本类型的参数传递存储的数据值。

 public static void main(String[] args) {
        int a=10;
        change(a);
        System.out.println(a);//结果10
    }

    private static void change(int i) {
             i=222;
    }

引用类型的参数传递存储的地址值。

 public static void main(String[] args) {
        int[] a1={11};
        change(a1);
        System.out.println(a1[0]); //结果222
    }

    private static void change(int[] i) {
             i[0]=222;
    }

7.方法参数传递案例 ✏️

7.1 方法参数传递案例1

需求：输出一个int类型的数组内容，要求输出格式为：[11, 22, 33, 44, 55]。

分析

方法是否需要接收数据进行处理？
- 方法要打印int类型数组中的元素，打印哪一个数组需求并不明确；
- 所以可以把int数组写成参数，让调用者指定
方法是否需要返回数据？
- 方法最终的目的知识打印数组中的元素。
- 不需要给调用者返回什么，所以不需要返回值，返回值类型写void
方法内部的业务：遍历数组，并输出相应的内容

点击查看代码

public class MethodTest3 {
    public static void main(String[] args) {
        // 目标：完成打印int类型的数组内容。
        int[] arr = {10, 30, 50, 70};
        printArray(arr);

        int[] arr2 = null;
        printArray(arr2);

        int[] arr3 = {};
        printArray(arr3);
    }

    /*
    	参数：int[] arr表示要被打印元素的数组，需要调用者传递
    */
    public static void printArray(int[] arr){
        if(arr == null){
            System.out.println(arr); // null
            return; // 跳出当前方法
        }

        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.println("]");
    }
}

7.2 方法参数传递案例2

需求：比较两个int类型的数组是否一样，返回true或者false

分析

方法是否需要接收数据进行处理？
- 因为，方法中需要两个int数组比较，但是需求并不明确是哪两个数组；
- 所以，需要接收两个int类型的数组，形参声明为：int[] arr1，int[] arr2
方法是否需要返回数据？
- 因为,方法最终的结果需要true或者false;
- 所以，返回值类型是boolean
方法内部的业务：判断两个数组内容是否一样🎯。

点击查看代码

public class MethodTest4 {
    public static void main(String[] args) {
        // 目标：完成判断两个int类型的数组是否一样。
        int[] arr1 = {10, 20, 30};
        int[] arr2 = {10, 20, 30};
        System.out.println(equals(arr1, arr2));
    }

    /*
    	参数：
    		int[] arr1, 参与比较的第一个int数组
    		int[] arr2  参与比较的第二个int数组
    	返回值:
    		返回比较的结果true或者false
    */
    public static boolean equals(int[] arr1, int[] arr2){
        // 1、判断arr1和arr2是否都是null.
        if(arr1 == null && arr2 == null){
            return true; // 相等的
        }

        // 2、判断arr1是null，或者arr2是null.
        if(arr1 == null || arr2 == null) {
            return false; // 不相等
        }

        // 3、判断2个数组的长度是否一样，如果长度不一样，直接返回false.
        if(arr1.length != arr2.length){
            return false; // 不相等
        }

        // 4、两个数组的长度是一样的，接着比较它们的内容是否一样。
        // arr1 = [10, 20, 30]
        // arr2 = [10, 20, 30]
        for (int i = 0; i < arr1.length; i++) {
            // 判断当前位置2个数组的元素是否不一样，不一样直接返回false
            if(arr1[i] != arr2[i]){
                return false; // 不相等的
            }
        }
        return true; // 两个数组是一样的。
    }
}

8.方法重载 🍐

方法重载

所谓方法重载指的是：

一个类中，出现多个相同的方法名，
但是它们的形参列表是不同的

返回值不影响

//方法名test 无返回值 无参数
public static void test(){
    System.out.println("===test1===");
}

//方法名test 无返回值 有参数
public static void test(int a){
    System.out.println("===test2===" + a);
}

下列哪些方法是重载方法？ ❓

public class MethodOverLoadDemo1 {
    public static void main(String[] args) {
        // 目标：认识方法重载，并掌握其应用场景。
        test();
        test(100);
    }

    //方法名test 静态的 无返回值 无参数
    public static void test(){
        System.out.println("===test1===");
    }

    //方法名test 静态的 无返回值 有1个参数(类型int)
    public static void test(int a){
        System.out.println("===test2===" + a);
    }

    //方法名test  无返回值 有1个参数(类型double)
    void test(double a){
    }

    //方法名test  无返回值 有2个参数(类型double，int类型)
    void test(double a, int b){
    }

    //方法名test  无返回值 有2个参数(int类型，类型double)
    void test(int b, double a){
    }

    //方法名test  有返回值 有2个参数(int类型，int类型)
    int test(int a, int b){
        return a + b;
    }

     //方法名test  无返回值 有2个参数(int类型，int类型)
    void test(int aa, int bb){
        System.out.println(a+b);
    }
}

我们认识了方法重载，那么方法重载有哪些应用场景呢？

一般在开发中，我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。

比如： 1. 源码中的例子

2. 我们现在看一个案例


需求：开发武器系统，功能需求如下：
    可以默认发一枚武器。
    可以指定地区发射一枚武器。
    可以指定地区发射多枚武器。

上面的几个需求中，不管以什么样的方式发武器，其实最终的目的都是发武器。所以我们可以设计几个名称相同的方法，这样调用者调用起来就不用记那么多名字了代码如下：

public class MethodTest2 {
    public static void main(String[] args) {
        // 目标：掌握方法重载的应用场景。
        fire();
        fire("岛国");
        fire("漂亮国", 999);
    }

    public static void fire(){
        fire("岛国");
    }

    public static void fire(String country){
        fire(country, 1);
    }

    public static void fire(String country, int number){
        System.out.println("发射了" + number + "枚武器给" + country);
    }
}

总结一下

总结

什么是方法重载？
- 答：一个类中，多个方法的名称相同，但它们形参列表不同。
方法重载需要注意什么？
- 一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，
  - 其它的都不管（如：修饰符，返回值类型是否一样都无所谓）。
- 形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。
方法重载有啥应用场景？
- 答：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。

课堂作业

请问方法重载的特点是什么？🎤
(单选)：下面关于方法的重载，描述错误的是（）

A:    方法重载，是指方法的名称相同，参数列表也相同的多个方法
B:   方法重载，可以减少对方法名称的命名次数
C:   方法重载，只能在同一个java类当中
D:   方法重载，返回值类型可以不相同

(判断题) 查看以下代码是否是方法重载？

public static void main(String[] args) {
}

public static void main(int[] arr) {     
}

思考一下，main方法能否重载？为什么？）

9. return单独使用 🍐

在方法中单独使用return语句，可以用来提前结束方法的执行

如，下面的chu方法中，当除数为0时，就提前结束方法的执行。

public class Test {
    public static void main(String[] args) {
        System.out.println("开始");
        chu(10 , 0);
        System.out.println("结束");
    }
    
    public static void chu(int a , int b){
        if(b == 0){
            System.err.println(“您的数据有误！！不执行！！”);
            return; // 直接跳出并结束当前chu方法的执行
        }
        int c = a / b;
        System.out.println("除法结果是："+c); 
    }
}

总结

return; 跳出并立即结束所在方法的执行。
break; 跳出并结束当前所在循环的执行。
continue; 结束当前所在循环的当次继续，进入下一次执行。

课堂作业

在无返回值的方法中，如果要直接跳出并结束当前方法的执行，怎么解决？

来做点作业巩固一下吧！！！✏️ 💪

part05——方法

# part05——方法

# 1.方法概述

# 2.方法的其他形式

# 3.方法使用常见的问题 🍐

# 4. 定义方法的案例 ✏️ 🍐❤️

# 5. 方法在机中的执行原理 🚀

# 6.方法参数的传递机制 🍐

# 6.2 参数传递的是引用数据类型

# 7.方法参数传递案例 ✏️

# 7.1 方法参数传递案例1

# 7.2 方法参数传递案例2

# 8.方法重载 🍐

# 9. return单独使用 🍐

part05——方法

1.方法概述

2.方法的其他形式

3.方法使用常见的问题 🍐

4. 定义方法的案例 ✏️ 🍐❤️

5. 方法在机中的执行原理 🚀

6.方法参数的传递机制 🍐

6.2 参数传递的是引用数据类型

7.方法参数传递案例 ✏️

7.1 方法参数传递案例1

7.2 方法参数传递案例2

8.方法重载 🍐

9. return单独使用 🍐