day06_方法

方法概述

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。方法必须先创建才可以使用，该过程成为方法定义。方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用。

无参数无返回值方法定义和调用

代码示例

public class Demo{
    /*
       方法的定义格式:

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

       方法的调用格式:

               方法名();

       注意: 方法与方法之间是平级关系, 不能嵌套定义
    */
    public static void main(String[] args) {
        eat();
    }

    public static void eat (){
        study();
        System.out.println("吃饭");
    }

    public static void study(){
        System.out.println("学习");
    }

}

方法的调用过程

方法必须先定义，后调用，否则程序将报错。每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。

带参数方法定义和调用

参数：由数据类型和变量名组成。数据类型变量名

代码示例

public class Demo1Method {
    /*

        带参数方法的定义格式:
                public static void 方法名  ( 参数 )  { … … }
                public static void 方法名  ( 数据类型 变量名 )  { … … }

        带参数方法的调用格式:
                方法名 ( 参数 ) ;
                方法名 ( 变量名/常量值 ) ;

        tips: 参数可以是一个, 也可以是多个.

        需求: 判断一个数是奇数还是偶数
     */
    public static void main(String[] args) {
        isEvenNumber(10);
    }

    public static void isEvenNumber(int num){
        if(num % 2 == 0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }
}

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错。方法定义时，多个参数之间使用逗号( , )分隔。方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

带返回值方法的定义和调用

方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。

代码示例

public class Demo {
    /*
        带返回值方法的定义格式:
            public static 数据类型  方法名 ( 参数 ) {
                    return 数据 ;
            }

           方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

        带返回值方法的调用格式:
           数据类型 变量名 = 方法名 ( 参数 ) ;

        需求: 定义一个方法, 计算两个整数相加的和
     */
    public static void main(String[] args) {
        int num = add(10,20);
        System.out.println(num);
    }

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

方法的通用格式

格式详解：

public static： 修饰符，目前先记住这个格式。以后可以根据实际需要进行更改
返回值类型 ：方法操作完毕之后返回的数据的数据类型，如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名 ：调用方法时候使用的标识
参数： 由数据类型和变量名组成，多个参数之间用逗号隔开
方法体 ：完成功能的代码块
return： 如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确

明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
明确参数：主要是明确参数的类型和数量

调用方法时的注意：

void类型的方法，直接调用即可
非void类型的方法，推荐用变量接收调用

方法的注意事项

方法不能嵌套定义
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

代码示例

public class Demo1Method {
    public static void main(String[] args) {
        print(10,20);
    }

    public static void print(int n, int m){

        if(m < n){
            System.out.println("您传入的数据有误, 请检查");
            // return; 可以用于结束方法, 也就是将方法从栈内存中弹出去, 该过程称之为方法的弹栈
            return;
            // System.out.println();  无法执行的代码, 无效代码
            // 问题: return语句下面, 不是不能写代码吗?
        }
        System.out.println(n + "到" + m + "之间的奇数为:");
        for(int i = n; i <= m; i++){
            if(i % 2 == 1){
                System.out.println(i);
            }
        }
    }
}

方法重载

方法重载概念

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

注意：

重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

public class Demo1Overload {
    /*
            需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
     */
    public static void main(String[] args) {
        short a = 10;
        short b = 20;
        System.out.println(compare(a,b));
    }

    public static boolean compare (int a, int b){
        return a == b;
    }

    public static boolean compare (byte a, byte b){
        return a == b;
    }

    public static boolean compare (short a, short b){
        return a == b;
    }

    public static boolean compare (long a, long b){
        return a == b;
    }
}

方法的参数传递

方法参数传递基本类型

public class Test1 {
    /*
         方法参数传递为基本数据类型 :

                传入方法中的, 是具体的数值.
     */
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前:" + number);
        change(number);
        System.out.println("调用change方法后:" + number);
    }

    public static void change(int number) {
        number = 200;
    }
}

结论：

基本数据类型的参数，形式参数的改变，不影响实际参数

结论依据：

每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

方法参数传递引用类型

public class Test2 {
    /*
         方法参数传递为引用数据类型 :

                传入方法中的, 是内存地址.
     */
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前:" + arr[1]);
        change(arr);
        System.out.println("调用change方法后:" + arr[1]);
    }

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

结论：

对于引用类型的参数，形式参数的改变，影响实际参数的值

结论依据：

引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

综合练习

package com.itheima.test;

public class Test3 {
    /*
        需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值

        注意: return语句, 只能带回一个结果.
     */
    public static void main(String[] args) {

        int[] arr = {11,55,33,22,44};

        int[] maxAndMin = getMaxAndMin(arr);

        System.out.println(maxAndMin[0]);
        System.out.println(maxAndMin[1]);

    }

    public static int[] getMaxAndMin(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }

        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }

        int[] maxAndMin = {min, max};

        return maxAndMin;
    }
}