Java学习笔记-day06-方法

1、介绍

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

好处：提高代码的复用性；提高代码的可维护性。

注：方法必须先创建才可以使用，该过程称为方法定义。方法创建后并不是直接可以运行的，需要手动使用后，才能执行，该过程称为方法调用。

2、格式

2.1 无参数方法定义和调用

定义格式：

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

调用格式：

方法名();

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

练习：大小比较

需求：设计一个方法用于打印两个数中的较大数

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数
    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

2.2 带参数方法定义和调用

2.2.1 格式

定义格式：

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

参数：由数据类型和变量名组成 --- 数据类型 变量名，示例：int a

注：方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错。

调用格式：

方法名(参数1,参数2);

注：方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错。

2.2.2 形参和实参

形参：方法定义中的参数，等同于变量定义格式，例如：int number

实参：方法调用中的参数，等同于使用变量或常量，例如： 10 number

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

2.3.1 格式

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

定义格式：

public static 数据类型 方法名 ( 参数 ) { 
	方法体；
    return 数据 ;
}

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

调用格式：

1、方法名 ( 参数 ) ;                              //直接调用
2、数据类型 变量名 = 方法名 ( 参数 ) ;             //赋值调用
3、System.out.println(方法名 ( 参数 ));           //输出调用

注：方法的返回值通常会使用变量接收，否则该返回值将无意义。

2.3.2 练习

练习一：比较大小

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

public class Test {
    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;
    }
}

练习二：比较圆的面积

需求：键盘录入两个圆的半径（整数），比较两个圆的面积。

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //键盘录入圆的半径
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入圆的半径");
        int radii1 = sc.nextInt();

        System.out.println("请输入第二个圆的半径");
        int radii2 = sc.nextInt();
        double area1 = getArea(radii1);
        double area2 = getArea(radii2);
        if(area1 > area2){
            System.out.println("第一个圆面积更大");
        }else{
            System.out.println("第二个圆面积更大");
        }
    }

    //思路：
    //1.要做什么？   求圆的面积
    //2.做这件事情，需要什么才能完成？        半径
    //3.方法的调用处，是否需要继续使用方法的结果    要比较
    public static double getArea(int radii) {
        double area = 3.14 * radii * radii;
        return area;
    }
}

2.4 注意事项

• 方法不调用就不执行；
• 方法不能嵌套定义；
• void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据；
• return语句下面不能编写代码。

return关键字：

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

3、重载

3.1 概念

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

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

即，同一个类中，方法名相同，参数不同的方法，与返回值无关。

示例：

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}

3.2 练习

练习：判断整数是否相同

需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）。

public class Test {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }

}

4、练习

练习一：数组遍历

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

输出语句：

• System.out.println(“内容”);               输出内容并换行
• System.out.print(“内容”);                  输出内容不换行
• System.out.println();                         起到换行的作用

public class Test {
    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 (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1){
                System.out.println(arr[i] + "]");
            }else {
                System.out.print(arr[i] + ",");
            }
        }
    }
}

练习二：数组最大值

需求：设计一个方法用于获取数组中元素的最大值。

public class Test {
    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        System.out.println(getMax(nums));
    }
    public static int getMax(int[] nums){
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if(nums[i] > max){
                max = nums[i];
            }
        }
        return max;
    }
}

练习三：判断是否存在

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

public class Test {
    public static void main(String[] args) {
        int[] arr = {2, 7, 11, 15, 18};
        boolean flag = isExist(arr,7);
        System.out.println(flag);
    }
    public static boolean isExist(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number){
                return true;
            }
        }
        return false;
    }
}

练习四：复制数组

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

（回顾动态数组的定义方法）

public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] newArr = copyOfRange(arr,3,7);
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
    public static int[] copyOfRange(int[] arr,int from,int to){
        int[] newArr =new int[to - from];
        //伪造索引的思想
        for (int i = from,j = 0; i < to; i++,j++) {
            newArr[j] = arr[i];
        }
        return newArr;
    }
}

5、内存原理

（1）方法调用的基本内存原理：栈

（2）方法传递基本数据类型的内存原理

基本数据类型：整数、浮点数、布尔、字符，变量中存储的是真实的数据值。

引用数据类型：除了基本数据类型之外的类型，new出来的，变量存储的是其他空间的地址值。

示例：

public class Test {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);  //100
        change(number);
        System.out.println("调用change方法后：" + number);  //100
    }
    public static void change(int number){
        number = 200;
    }
}

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

（3）方法传递引用数据类型的内存原理

示例：

public class Test {
    public static void main(String[] args) {
        int[] arr = {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;
    }
}

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