06-方法

1、什么是方法

方法（method）是程序中最小的执行单元

方法的作用：方便调用重复的代码块；提高代码可维护性

总结：
    1、什么是方法：
            方法是程序中最小的执行单元
    2、实际开发中，什么时候用到方法？
            重复的代码、具有独立功能的代码可以抽取到方法中
    3、方法有什么好处？
            提高代码的复用性
            提高代码的可维护性

2、方法的格式

2.1 方法的定义：

将一些代码打包在一起

2.1.1 最简单的方法定义、调用

/* 格式(定义)：
public static void 方法名(){
    方法体(打包的代码);
}
*/
​
//范例(定义)
public static void playGame(){
    七个打印语句;
}
​
//调用
playGame();
​

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

案例：

package com.yq.methoddemo;
​
public class MethodDemo1 {
    public static void main(String[] args){
        //目标：掌握最简单的方法定义、调用的格式
​
        //调用方法
        playGame();
        playGame();
    }
​
    //定义一个方法
    public static void playGame(){
        System.out.println("1.选人物");
        System.out.println("2.准备开局");
        System.out.println("3.对线");
        System.out.println("4.崩盘");
        System.out.println("5.骂队友");
        System.out.println("6.送人头");
        System.out.println("7.GG");
    }
}
​

练习：展示信息

package com.yq.methoddemo;
​
public class MethodDemo2 {
    public static void main(String[] args) {
        //目标：利用方法最简单的格式，完成当前的练习
​
        //调用方法
        printGFInfo();
    }
​
    public static void printGFInfo(){
        System.out.println("小惠惠");
        System.out.println("萌妹子");
        System.out.println("18岁");
    }
}

练习：看代码说结果1

看到方法进入方法，执行完毕回到调用处

public class Test{
    public static void main(String[] args){
        System.out.println("a");
        method();
        System.out.println("b");
    }
    public static void method(){
        System.out.println("c");
        System.out.println("d");
    }
}
​
/* 输出结果：
a
c
d
b
*/

练习：看代码说结果2

public static Test{
    public static void main(){
        System.out.println("a");
        method1();
        System.out.println("b");
    }
    public static void method1(){
        method2();
        System.out.println("c");
    }
    public static void method2(){
        System.out.println("d");
        System.out.println("e");
    }
}
​
/* 输出结果：
a
d
e
c
b
*/

练习：求出和、并进行打印

package com.yq.methoddemo;
​
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);
    }
}
​

2.1.2 带参数的方法定义、调用

每次调用方法时，向方法这种传递不同参数

public static void method(int num1, int num2){
    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 方法名(int number1, int number2){...}
*/
​
/* 带参数的方法调用
单个参数格式:
    方法名(参数);
    method(10);
多个参数格式:
    方法名(参数1, 参数2, ...);
    getSum(19, 20);
*/

注意：

形参：全称形式参数，指方法定义中的参数

实数：全称实际参数，指方法调用中的参数

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

练习：人肉计算器

package com.yq.methoddemo;
​
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、要做什么        --》(方法体)
    2、需要什么才能完成  --》(形参)

练习：求周长

package com.yq.test;
​
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);
    }
}
​

练习：求圆的面积

package com.yq.test;
​
public class Test2 {
    public static void main(String[] args) {
        //定义一个方法，求圆的面积，将结果在方法中进行打印
​
        getArea(10.2);
    }
​
    public static void getArea(double r){
        double result = r * r * 3.14;
        System.out.println(result);
    }
}
​

2.1.3 带返回值的方法定义、调用

让方法产生的结果，给后续代码使用

定义：

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

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

调用：

//1.直接调用:
方法名(实参);

//2.赋值调用
整数类型 变量名 = 方法名(实参);

//3.输出调用
System.out.println(方法名(实参))；

练习：计算营业额

package com.yq.methoddemo;
​
public class MethodDemo5 {
    public static void main(String[] args) {
        //目标：掌握带返回值方法的定义、调用
​
        /*
        //1.直接调用
        getSum(10, 20, 30);
​
        //2.赋值调用
        int sum = getSum(10, 20, 30);
        System.out.println(sum);
​
        //3.输出调用
        System.out.println(getSum(10, 20, 30));
        */
​
        //计算第一个季度的营业额
        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; //返回给方法的调用出
    }
}
​

总结：
1、什么时候用到有返回值的方法：
    在调用处，需要根据方法的结果，去编写另一段代码
    
2、有返回值方法的定义格式
public static 返回值类型 方法名(参数){
    方法体;
    return 返回值;
}
​
3、有返回值方法的调用格式
直接调用： getSum(10, 20, 30);
赋值调用： int sum = getSum(10, 20, 30);
输出调用： System.out.println(getSum(10, 20, 30));
​
4、有返回值方法中参数的运行过程

练习：比较长方形大小

package com.yq.test;

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("第二个长方形大");
        }

    }

    //定义一个方法计算长方形面积
    public static double getArea(double len, double width){
        double area = len * width;
        return area;
    }
}

2.2 方法完整定义格式

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

2.3 方法的注意事项

1、方法不调用就不执行

2、方法与方法之间是平级关系，不能互相嵌套定义

3、方法的编写顺序 和 执行顺序 无关（与调用顺序有关）

4、方法的返回值类型为void，表示该方法没有返回值   
   没有返回值的方法可以省略return不写
   如果要写return，return后面不能跟具体的数据
   
5、return语句下面，不能编写代码，因为永远执行不到，属于无效的代码

6、return 关键字
	方法没有返回值：可以省略不写。如果书写，表示方法结束
	方法有返回值：必须要写。表示结束方法、返回结果

2.4 案例

public class MethodDemo{
    public static void method(){
        //代码片段
    }
}
​
//方法定义正确，定义了一个没有返回值的方法

public class MethodDemo{
    public static void method(){
        //代码片段
        return;
    }
}
​
//方法定义正确，定义了一个没有返回值的方法，没有返回值的方法中，可以写return，但是后面不能跟具体的数据

public class MethodDemo{
    public static void method(){
        //代码片段
        return 100;
    }
}
​
//方法定义错误，定义了一个没有返回值的方法，没有返回值的方法中，可以写return，但是后面不能跟具体的数据

public class MethodDemo{
    public static void method(){
        //代码片段
        return;
        System.out.println("卑微代码");
    }
}
​
//方法定义错误，return语句下面，不能编写代码，因为永远执行不到，属于无效的代码

3、方法的重载

同一个类中，方法名相同，参数不同就是重载（与返回值无关）(方法名相同、参数不同) 参数不同：个数不同、类型不同、顺序不同

Java虚拟机会通过参数不同来区分同名的方法

//案例
public class MethodDemo {
    public static int sum(int a, int b){
        return a + b;
    }
​
    public static int sum(int a, int b, int c){
        return a + b + c;
    }
}

3.1 练习：判断以下方法是否构成重载

public class MethodDemo{
    public static void fn(int a){
        //方法体
    }
    public static int fn(int a){
        //方法体
    }
}
​
//不构成重载。同一个类中：方法名相同、参数相同（与返回值无关）

public class MethodDemo{
    public static float fn(int a){
        //方法体;
    }
    public static int fn(int a, int b){
        //方法体;
    }
}
​
//构成重载。同一个类中：方法名相同、参数不同(参数个数不同)

public class MethodDemo1{
    public static void fn(int a){
        //方法体;
    }
}
public class MethodDemo2{
    public static int fn(double a){
        //方法体;
    }
}
​
//不构成重载。不在同一个类中

public class MethodDemo{
    public static void fn(int a){
        //方法体;
    }
    public static int fn(double a){
        //方法体;
    }
}
​
//构成重载。同一个类中：方法名相同、参数不同(参数类型不同)

public class MethodDemo{
    public static void fn(int a, double b){
        //方法体
    }
    public static void fn(double a, int b){
        //方法体
    }
}
​
//构成重载。同一个类中：方法名相同、参数不同(参数顺序不同)
// 注意：参数的顺序不同可以构成重载，但是不建议使用

3.2 使用方法重载

package com.yq.test;
​
public class Test4{
    // 需求：定义重构的方法比较两个整数是否相同
    public static void main(String[] args){
        //1.使用数据类型强转调用
        // compare((byte)10, (byte)20);
​
        //2.定义变量调用
        byte b1 = 10;
        byte b2 = 20;
        compare(b1, b2);
    }
​
    //定义重构的方法比较两个整数是否相同
    /*
       1.定义方法时不需要很多单词
       2.调用方法时不会很麻烦
    */
    public static void compare(byte b1, byte b2){
        System.out.println("byte");
        System.out.println(b1 == b2);
    }
    public static void compare(short s1, short s2){
        System.out.println("short");
        System.out.println(s1 == s2);
    }
    public static void compare(int i1, int i2){
        System.out.println("int");
        System.out.println(i1 == i2);
    }
    public static void compare(long n1, long n2){
        System.out.println("long");
        System.out.println(n1 == n2);
    }
}

3.2.1 练习：数组遍历

package com.yq.test;
​
public class Test5{
    public static void main(String[] args){
        //需求：设计一个方法用于数组遍历，要求遍历的结果在一行上显示。例如：[11, 22, 33, 44, 55]
    
        //1.定义数组
        int[] arr = new int[]{11, 22, 33, 44, 55};
​
        //2.调用方法遍历数组
        printArr(arr);
​
        /* 拓展：输出的拓展
               System.out.println("abc"); //先打印abc，再进行换行
               System.out.print("abc"); //只打印abc,不换行
               System.out.print(bcd);
               System.out.println(); //不打印任何数据，只做换行处理
        */
    }
​
    //定义方法用于数组遍历
    // 1.遍历数组
    // 2.需要数组
    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("]");
    }
}

3.2.2 练习：求数组最大值

package com.yq.test;
​
public class Test6{
    public static void main(String[] args){
        //1.定义数组
        int[] arr = new int[]{1, 5, 7, 3, 8, 10};
​
        //2.调用数组求最大值
        int max = getMax(arr);
        System.out.println(max);
    }
​
    //需求：设计一个方法求数组最大值，并将最大值返回
    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;
    }
}

3.2.3 练习：判断数据是否存在

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

package com.yq.test;
​
public class Test7{
    public static void main(String[] args){
        //需求：定义一个方法判断数组中的某个数是否存在，将结果返回给调用处
        //1.定义数组
        int[] arr = new int[]{1, 5, 8, 12, 56, 89, 34, 67};
​
        //2.调用方法
        boolean flag = containers(arr, 189);
        System.out.println(flag);
    }
​
    //1.判断数组中的数据是否存在
    //2.需要数组中的数据
    //3.需要返回值
    public static boolean containers(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有关系
*/
​

3.2.4 练习：复制数组

需求：定义一个方法copyOfRange(int[] arr, int from, int to) 功能：将数组arr中索引from(包含from) 开始 到索引to结束（不包含to）的元素复制到新数组中 将新数组返回

package com.yq.test;
​
/*
需求：定义一个方法copyOfRange(int[] arr, int from, int to)
功能：将数组arr中索引from(包含from) 开始
      到索引to结束（不包含to）的元素复制到新数组中
      将新数组返回
*/
public class Test8{
    public static void main(String[] args){
        //1.定义数组
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
​
        //2.调用方法实现功能
        int[] copyArr = copyOfRange(arr, 3, 5);
​
        //3.调用方法遍历新数组
        getArr(arr);
        getArr(copyArr);
    }
​
    //定义方法复制数组
    public static  int[] copyOfRange(int[] arr, int from, int to){
        // 1.定义新数组
        int[] arr1 = new int[to - from];
​
        // 2.复制数组中的数据
        int index = 0;  //伪造索引思想
        for (int i = from; i < to; i++){
            arr1[index] = arr[i];
            index++;
        }
        return arr1;
    }
​
    //定义方法遍历数组
    public static void getArr(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("]");
        System.out.println();
    }
}

4、方法的内存

4.1 方法调用的基本内存原理

方法被调用之后就会进栈执行

4.2 方法传递基本数据类型内存原理

基本数据类型：数据值存储在自己的空间中 特点：赋值给其他变量，赋值真实的值

package com.yq.test;
​
public class Test9 {
    public static void main(String[] args){
        int number = 100;
        System.out.println("调用change方法前：" + number); //100
        change(number);
        System.out.println("调用change方法后：" + number); //100
        number = change1(number);
        System.out.println("调用change1方法后：" + number); //100
    }
​
    public static void change(int number){
        number = 200;
    }
    public static int change1(int number){
        number = 200;
        return number;
    }
​
    // 传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
}

4.3 方法传递引用数据类型内存原理

变量中存储的是地址值 引用：使用率其他空间中的数据 引用数据类型：数据值存储在其他空间中 特点：赋值给其他变量，赋值的是地址值

package com.yq.test;
​
public class Test10{
    public static void main(String[] args){
        int[] arr = new int[]{10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]); //20
        change(arr);
        System.out.println("调用change方法后：" + arr[1]); //200
    }
​
    public static void change(int[] arr){
        arr[1] = 200;
    }
​
    //传递引用数据类型，传递的是地址值，形参的改变，会影响实际参数的值
}

总结：
     基本数据类型：传递的是真实的数据（形参的改变，不影响实际参数的值）
     引用数据类型：传递的是地址值（形参的改变，会影响实际参数的值）