方法

什么是方法

方法（method）是程序中最小的执行单元。
实际应用当中，将重复的方法打包
- 提高代码的复用性
- 提高代码可维持性

总结：

什么是方法?

方法是程序中最小的执行单元。
实际开发中，什么时候用到方法?

重复的代码、具有独立功能的代码可以抽取到方法中。
实际开发中，方法有什么好处?
- 可以提高代码的复用性
- 可以提高代码的可维护性

方法的格式

把一些代码打包在一起，用到的时候就调用

方法定义

把一些代码打包在一起，该过程称为方法定义。

方法的定义格式

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

方法调用

方法定义后并不是直接运行的，需要手动调用才能执行，该过程称为方法调用。

最简单的方法定义和调用

格式（方法）：

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

范例（方法）：

public static void playGame (){
    七个打印语句;
}

格式（调用）：

方法名 ();

范例（调用）：

playGame ();

注意：方法必须先定义后调用，否则程序将报错

public class MethodDemo1 {
    public static void main(String[] args) {
        //目标：掌握最简单的方法定义和调用的格式

        //调用方法
        playGame();
    }
    //定义一个方法
    public static void playGame(){
        System.out.println("选人物");
        System.out.println("准备开局");
        System.out.println("对线");
        System.out.println("崩盘");
        System.out.println("崩盘");
        System.out.println("骂队友");
        System.out.println("送人头");
        System.out.println("GG");
    }
}

练习

展示女朋友的信息

需求：定义一个方法，在方法内部打印你女朋友的所有信息。

public class MethodDemo2 {
    public static void main(String[] args) {
        //目标：利用方法最简单的格式完成当前练习

        //调用方法
        printGFInfo();
    }
    public static void printGFInfo(){
        System.out.println("柳如烟");
        System.out.println("校花");
        System.out.println("18岁");
    }
}

人肉计算机

需求：定义一个方法，在方法内部定义两个变量。

求出他们的和并进行打印。

public class MethodDemo3 {
    public static void main(String[] args) {
        //目标：利用方法最简单的格式完成当前练习
        //需求：在方法内部定义两个变量并求和打印
        getSum();
    }
    public static void getSum(){
        int num1 = 10;
        int num2 = 20;
        int result = num1 + num2;
        System.out.println(result);
    }
}

带参数的方法的定义和调用

单个参数（方法）

格式：

public static void 方法名(参数){ ... ...}

范例：

public static void method(int number){ ... ...}

多个参数（方法）

格式：

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

范例：

public static void getSum(int number1,int number2){ ... ...}

带参数方法（调用）

单个参数

单个参数：方法名(参数);

范例1：method(10);

范例2：method(变量);

多个参数

多个参数：方法名(参数1,参数2,......);

范例1：getSum(10,20);

范例2：getSum(变量1,变量2);

注意：方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序将报错。

public class MethodDemo4 {
    public static void main(String[] args) {
        //目标：掌握带参数方法定义的格式和调用的格式
        getSum(10,20);
    }
    public static void getSum(int num1, int num2){
        int result = num1 + num2;
        System.out.println(result);
    }
}

形参和实参

形参：全称形式参数，是指方法定义中的参数
实参：全称实际参数，方法调用中的参数

注意：方法调用时，形参和实参必须一一对应，否则程序将报错。

练习

人肉计算机1

需求：定义一个方法，求长方形的周长，将结果在方法中进行打印。

public class Test1 {
    public static void main(String[] args) {
        //需求：定义一个方法，求长方形的周长，将结果在方法中进行打印。

        //目标：根据不同的需求，荀泽定义无参的方法，还是带参数的方法
        getLength(5.2,1.3);
    }
    //1.我要干嘛？求长方形的周长
    //2.我干这件事情，需要干什么才能完成？长 宽
    public static void getLength(double len,double width){
        double result = (len + width) * 2;
        System.out.println(result);
    }
}

人肉计算机2

需求：定义一个方法，求圆的面积，将结果在方法中进行打印。

public class Test2 {
    public static void main(String[] args) {
        //需求：定义一个方法，求圆的面积，将结果在方法中进行打印。
        //目标：根据不同的需求，选择定义无参的方法，还是带参数的方法

        getArea(1.5);
    }
    //1.我要干嘛？求圆的面积
    //2.我干这件事，需要什么才能完成？ 半径的平方 * π
    public static void getArea(double radius){
        double result = radius * radius * 3.14;
        System.out.println(result);
    }
}

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

方法的返回值其实就是方法运行的最终结果。

如果在调用处要根据方法的结果，去编写另一段代码逻辑
为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法

带返回值方法定义

格式：

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

范例：

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

带返回值方法的调用

直接调用：
```
方法名(参数);
```

赋值调用：

整数类型 变量名 = 方法名 (实参);

输出调用：

System.out.println(方法名 (实参));

public class MethodDemo5 {
    public static void main(String[] args) {
        //目标：掌握带返回值方法的定义和调用格式

        //直接调用
        getSum(10,20,30);

        //赋值调用
        int sum = getSum(10,20,30);
        System.out.println(sum);
        
        //输出调用
        System.out.println(getSum(10,20,30));
    }
    public static int getSum(int num1,int num2,int num3){
        int result = num1 + num2 + num3;
        return result;//返回给方法的调用处
    }
}

总结

什么时候用到有返回值的方法？

在调用处要根据方法的结果，去编写另一段代码。

由返回值方法的定义格式

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

有返回值方法的调用格式

直接调用，赋值调用，输出调用
有返回值方法中参数的运行过程

练习

人肉计算机

需求：定义一个方法，求一家商场每个季度的营业额。

根据方法结果再计算出全年营业额。

public class MethodDemo5 {
    public static void main(String[] args) {
        //目标：掌握带返回值方法的定义和调用格式

        //先计算第一个季度的营业额
        int sum1 = getSum(10,20,30);
        //再来计算第二个季度的营业额
        int sum2 = getSum(20,30,40);
        //计算第三个季度的营业额
        int sum3 = getSum(20,30,40);
        //计算第四个季度的营业额
        int sum4 = getSum(20,30,40);

        //求全年的总营业额
        int sum = sum1 + sum2 + sum3 + sum4;
        System.out.println(sum);
    }
    public static int getSum(int num1,int num2,int num3){
        int result = num1 + num2 + num3;
        return result;//返回给方法的调用处
    }
}

比较大小

需求：定义方法，比较两个长方形的面积。

public class Test3 {
    public static void main(String[] args) {
        //目标：要能区分出什么时候使用带返回值的方法
        //需求：定义方法，比较两个长方形的面积。

        //调用方法获取长方形的面积，再进行比较
        double area1 = getArea(5.3,1.7);
        double area2 = getArea(2.4,2.7);

        if(area1 > area2){
            System.out.println("第一个长方形更大");
        }else{
            System.out.println("第二个长方形更大");
        }
    }
    //定义一个方法求长方形的面积
    //1.我要干什么？求长方形的面积
    //2.需要什么？长 宽
    //3.方法的调用处，是否需要继续使用方法的结果
    //如果要用，那么方法必须有返回值
    //如果不要用，方法可以写范湖只，也可以不写返回值
    public static double getArea(double len,double width){
        double area = len * width;
        return area;
    }
    //在以后实际开发应用当中，我们易班是把重复的代码或者具有独立功能的代码抽取到方法当中。
    //以后我们直接调用就可以了
}

方法小结

方法的注意事项

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

如果要编写return，后面不能跟具体的数据。
return语句下面，不能编写代码，因为永远执行不到，属于无效的代码

return关键字

方法没有返回值：可以省略不写。如果书写，表示结束方法
方法有返回值：必须要写。表示结束方法和返回结果

方法重载

在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。
每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
简单记：同一个类中，方法名相同，参数不同的方法。与返回值无关。

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

顺序不同可以构成重载，但是不建议！

练习

方法重载

需求：使用方法重载的思想，设计比价两个整数是否相同的方法。

要求：兼容全整数类型（byte,short,int,long）

public class Test4 {
    public static void main(String[] args) {
        /*需求：使用方法重载的思想，设计比价两个整数是否相同的方法。
        要求：兼容全整数类型（byte,short,int,long）
         */
        //调用
        compare(10,20);
        compare((byte) 10,(byte) 20);
        byte b1 = 10;
        byte b2 = 20;
        compare(b1,b2);
    }
    //会把相同功能的方法名起成一样的名字
    //好处1；定义方法的时候可以不用那么多的单词了
    //好处2：调用方法的时候也不需要那么麻烦了。
    public static void compare(byte b1,byte b2){
        System.out.println(b1 == b2);
    }
    public static void compare(short s1,short s2){
        System.out.println(s1 == s2);
    }
    public static void compare(int i1,int i2){
        System.out.println(i1 == i2);
    }
    public static void compare(long n1,long n2){
        System.out.println(n1 == n2);
    }
}

练习

数组遍历

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11,22,33,44,55]

public class Test5 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {11,22,33,44,55};
        //2.调用方法遍历数组
        printArr(arr);
    }
    //定义方法用于数组的遍历
    //1.我要干嘛？ 遍历数组
    //2.我干这件事需要什么才能完成？ 数组
    //3.方法的调用处是否需要继续使用结果？ 不需要返回值
    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.println("]");
    }
}

数组最大值

需求：设计一个方法求数组的最大值，并将最大值返回

public class Test6 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,2,3,4,5};
        //2.调用方法求最大值
        int max = getMax(arr);
        //3.打印
        System.out.println(max);
    }
    //1.我要干嘛？ 求最大值
    //2.我干这件事，需要什么才能完成？ 数组
    //3.是否返回？ 返回
    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }

}

判断是否存在

需求：定义一个方法判断数组中的某一个数据是否存在，将结果返回给调用处

public class Test7 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,2,3,4,5};
        //2.判断一个数字在数组中是否存在
        boolean flag = contains(arr,4);
        System.out.println(flag);
    }
    //1.我要干嘛？
    //2.我干这件事，需要什么才能完成？ 数组 数字
    //3.调用处是否需要继续使用结果？ 返回 true false
    public static boolean contains(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number){
                return true;
            }
        }
        //什么时候数字在数组中是不存在的
        //当数组里面所有的数据全部比较完毕之后
        return false;
        //return break 关键字的区别
        //return：其实跟循环没有什么关系，跟方法有关，表示1结束方法 2返回接过
        //        如果方法执行到了return，那么整个方法全部结束，里面的循环也会随之结束
        //break关键字
        //其实跟方法没有什么关系，结束循环或者switch。
    }
}

复制数组

需求：定义一个方法copyOfRange(int[] arr,int from,int to)

功能：将数组arr中从索引from（包含from）开始。到索引to结束（不包含to）的元素复制到新数组中，将新数组返回

public class Test8 {
    public static void main(String[] args) {
        /*需求：定义一个方法copyOfRange(int[] arr,int from,int to)
        功能：将数组arr中从索引from（包含from）开始。到索引to结束（不包含to）的元素复制到新数组中，将新数组返回
         */

        //1.定义原始数组
        int[] arr = {1,2,3,4,5,6,7,8,9};
        //2.调用方法
        int[] copyArr = copyOfRange(arr,3,7);
        //3.遍历数组
        for (int i = 0; i < copyArr.length; i++) {
            System.out.print(copyArr[i] + " ");
        }
    }
    public static int[] copyOfRange(int[] arr,int from,int to){
        //1.定义数组
        int[] newArr = new int[to - from];
        //2.把原始数组arr中的from到to上对应的元素，直接拷贝到newArr中
        //伪造索引
        int index = 0;
        for (int i = from; i < to; i++) {
            newArr[index] = arr[i];
            index++;
        }
        //3.返回
        return newArr;
    }
}