java入门day06：方法的定义，重载，内存

1. 什么是方法?

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

比如：public static void main(String[] args) {} 中，main就是一个方法，方法中的代码不能只执行一行，而是全部执行

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

2. 方法的格式

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

2.调用方法：方法定义后并不是直接运行的，需要手动调用才能执行

格式：不用记忆，下面会逐个学习，分析。

2.1最简单的方法定义及调用

定义

调用： 方法名();                                                           playGame();

必须先定义，后调用！！！无论是否带参数和返回值都一样

练习1：

刺绣绣一朵花，把步骤写在方法中，调用几次，就是绣几朵花

public class classDingYi {
    public static void main(String[] args) {
//        主入口，方法调用一般会放在这里
        embroidery();
        embroidery();//调用两次，就是绣两朵花
    }
//    在main外面写方法
    public static void embroidery() {
        System.out.println("劈丝");
        System.out.println("穿线");
        System.out.println("长短针绣第一层颜色");
        System.out.println("长短针绣第二层颜色");
        System.out.println("长短针绣花蕊");
    }
}

练习2：

看代码，说出执行顺序

前置知识：看到方法调方法，执行完毕回到调用处

来想一想吧

答案：adecb

练习3：

定义一个方法，方法中定义两个变量，求两个变量的和，并调用这个方法

public class classSum {
    public static void main(String[] args) {
        sum();
    }
    public static void sum () {
        int a = 10;
        int b = 20;
        int ab = a+b;
        System.out.println(ab);
    }
}

想一下，a，b两个值是固定的，不满足方法复用性的特点，我想给方法传什么，他就计算什么的和

2.2带参数的方法定义及调用

定义：定义时参数要定义好数据类型，这里定义的参数叫形参 形式参数（相当于占座）

如果要传入多个参数，参数之间用逗号隔开即可

调用：

这里写的参数，叫实参 实际参数（相当于人入座）

注意:方法调用时，形参和实参的数量及类型必须一一对应，否则将报错

练习1：

定义一个方法，计算圆的面积（考虑一下，是否需要传参） 圆的面积 公式：半径平方* Π（派）

public class classArea {
    public static void main(String[] args) {
        area(3.7); //42.9866 
    }
    public static void area(double a) { //形参：类型 形参名
        double res = a * a * 3.14;
        System.out.println(res);
    }
}

2.3带返回值方法的定义及调用

实际开发中，更多时候是，调用要拿到方法的返回结果，根据返回结果进行下一步操作。所以需要返回值

定义：注意public static 后面接的不再是void，而是返回值的类型

调用： 3种

练习1： 

定义一个方法，求一家商场每个季度的营业额。根据方法结果再计算出全年营业额。

public class classReturn {
    public static void main(String[] args) {
        getSum(1,2,3); //直接调用
        int a = getSum(1323,3232,333); //调用后赋值，可以做其他操作，比如，把四个季度的销售总额加起来
        System.out.println(getSum(323,232,54)); //控制台输出，实际开发时可用于查看调用是否成功
    }
    public static int getSum (int num1,int num2,int num3) { //一个季度三个月
        int result = num1 + num2 + num3;
        return result;
    }
}

//      计算全年销售额  调用时放在main中哦
        int sum1 = getSum(123,321,232);
        int sum2 = getSum(2,321,232);
        int sum3 = getSum(123,3,232);
        int sum4 = getSum(123,321,5);
        int sum = sum1 + sum2 + sum3 + sum4;
        System.out.println(sum); //2038

练习2：

对比未知数量的长方形的面积大小，比较哪个面积更大。

分析：方法是用于封装多次，重复的功能的地方，这里，求每个长方形的面积才是需要封装成方法的部分，而不是整个求面积+比较

public class classCompare {
    public static void main(String[] args) {
        double area1 = area(13,2); //需要接收结果，进行比较
        double area2 = area(12,4.3);
        if(area1 > area2) {
            System.out.println("长方形1面积更大");
        } else {
            System.out.println("长方形2面积更大");
        }
    }
    public static double area(double len, double width) {
        double areaC = len * width;
        return areaC;
    }
}

2.4方法的注意事项

 

return的规则：

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

3. 方法的重载

是什么？   在同一个类中，定义了多个同名的方法，方法名相同，参数不同的方法

参数怎样算不同？ 个数不同、类型不同、顺序不同，满足三个中的一个，就是参数不同

例： 以下就是方法的重载，虚拟机会根据参数的不同来区分同名方法

思考下，下图代码是否构成承载关系？

答案：不构成，因为，方法名相同，参数相同。其他不同不算

答案：构成重载关系，因为方法名相同，参数不同

答案：不构成，1.方法名相同√，2.参数不同√  3.在同一个类中×

练习1：

使用方法重载的思想，设计比较两个整数是否相同的方法，要兼容全整数类型(byte,short,int,long)

public class classCompareNum {
    public static void main(String[] args) {
        compare(12,32); //直接调用  定义的方法名那个亮就是调用了哪个，注意分辨
        compare((byte)40,(byte)20); //强行转换数据类型为byte
        
        char a = 1;
        char b = 1;
        compare(a,b); //开发中最常用的方法
    }
    public  static void compare(byte b1,byte b2){
        System.out.println("byte");
        System.out.println(b1 == b2);
    }
    public  static void compare(int i1,int i2){
        System.out.println("int");
        System.out.println(i1 == i2);
    }
    public  static void compare(short s1,short s2){
        System.out.println("short");
        System.out.println(s1 == s2);
    }
    public  static void compare(char c1,char c2){
        System.out.println("char");
        System.out.println(c1 == c2);
    }
    public  static void compare(long n1,long n2){
        System.out.println("long");
        System.out.println(n1 == n2);
    }
}

练习2：

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

前置：控制台打印语句

public class classForArray {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        printArr(arr);
    }
    public  static void printArr (int[] arr) {
        System.out.print("["); //for循环外面放代表数组的中括号
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]); //先打印数据
            if(i == arr.length - 1) { //再判断数据后面是拼接空格还是逗号
                System.out.print("");
            }else{
                System.out.print(",");
            }

        }
        System.out.print("]");
    }
}

练习3：

定义一个方法，计算数组中的最大值，并返回。

public class classGetMaxNum {
    public static void main(String[] args) {
        int arr[] = {1,5,7,3,8,10};
        int maxNum = getMax(arr);
        System.out.println(maxNum);
    }
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

练习4：

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

补充知识：return和breack的区别：

return和方法有关，1. 结束方法。 2.返回结果

breack和循环有关  结束的是循环，不是方法，也就是说breack结束循环后，循环后的代码依旧会执行。

public class classContains {
    public static void main(String[] args) {
        int arr[] = {1,5,7,3,8,10};
        boolean flag = contains(arr,4);
        System.out.println(flag); //false
    }
    public static boolean contains(int arr[],int num) { //我需要数组和猜的数字
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == num) {
                return true; //不能用breack哦！
            }
        }
        return false; //这里是循环完数组，全部对比完之后，发现没有相同的，那么就返回false，说明该数据在数组中不存在
    }
}

练习5：有些难度

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

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

public class classCopyArray {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6,7,8,9};
        int copyArr[] = copyOfRange(arr,3,7);
        for (int i = 0; i < copyArr.length; i++) {
            System.out.print(copyArr[i] + " ");
        }
    }
    public static int[] copyOfRange(int[] arr,int from, int to) {
        int[] newArr = new int[to - from]; //数组长度我们知道是to - from
        int index = 0; //定义一个代表数组下标的数值，每循环一次，就++
        for (int i = from; i < to; i++) {
            newArr[index] = arr[i]; //此处arr[i]的值就是from的值，因为i = from
            index++;
        }
        return newArr;
    }
}

4. 方法的内存

4.1简单说明

tips：main推出栈内存后，里面存的数据也会消失

多个方法的时候，执行顺序是什么样？先进后出（比如弹夹的子弹，先放进去的，最后打出）

1.main方法进入栈内存，调用了eat方法

2.eat方法进入栈内存，调用study方法

3.study方法进入栈内存，执行代码（控制台打印），study方法执行完毕，退出栈内存

以此类推。。。。。直到main方法中的方法都执行完毕，也会退出栈内存。栈内存就什么都没有了

4.2从内存角度解释数据类型

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

1.main方法进入栈，开辟了一个int number的空间 存入了100

2.调用change方法，change方法进入栈，并接收了number 的值，100

3.change方法中，修改了change方法int的number空间中的100 ，改为了200 。change执行完毕

4.回到main方法，继续执行打印，此处打印的时main方法中的number空间中的100

总结：

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值

 如果方法有返回值，并且返回值赋值到了main中的number上，才会真正修改到main中的number值

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

虽然是不同方法中的数组，但他们引用的是同一个地址值，所以调用方法中修改了数组中的值后，再调用也是修改后的值 

总结：

传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值

 day06完结~撒花花~   day07练习会比较多哦，都是综合练习