Java程序设计--方法（五）

---

1、方法定义、调用

方法完整的定义形式、应用

方法定义的完整格式

修饰符 返回值类型 方法名(形参表){
	方法体代码(需要执行的功能代码)
	return 返回值;
}

方法的调用格式

方法名(...)

方法格式的注意点

• 方法的修饰符:暂时都使用public static修饰。
• 方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。
• 形参列表可以有多个，甚至可以没有;如果有多个形参，多个形参必须用“，”隔开，且不能给初始化值。

方法其他的定义形式、应用

方法的其他写法

方法定义时：返回值类型、形参列表可以按照需求进行填写

修饰符 返回值类型 方法名(形参列表)

注意事项

• 如果方法不需要返回结果，返回值类型必须申明成void (无返回值)，此时方法内部不可以使用return返回数据。
• 方法如果没有参数，或者返回值类型申明为void可以称为无参数、无返回值的方法，依次类推。

---

2、方法使用的常见问题

方法常见问题

• 方法的编写顺序无所谓。
• 方法与方法之间是平级关系，不能嵌套定义
• 方法的返回值类型为void(无返回值)，方法内则不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
• return语句下面，不能编写代码，因为永远执行不到,属于无效的代码。
• 方法不调用就不执行，调用时必须严格匹配方法的参数情兄。
• 有返回值的方法调用时可以选择定义变量接收结果，或者直接输出调用，甚至直接调用;无返回值方法的调用只能直接调用。

---

3、方法案例

计算1–n的和返回

需求:定义一个方法，方法中计算出1–n的和并返回。

public class Test1 {
    public static void main(String[] args) {
        // 需求：使用方法计算1-n的和并返回
        System.out.println("1-5的和是：" + sum(5));
        System.out.println("--------------------");
        System.out.println("1-100的和是：" + sum(100));
    }

    public static int sum(int n){
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return sum;
    }
}

判断奇偶数

需求:拿一个整数，然后调用方法，把整数交给方法，在方法中输出该数为奇数还是偶数

public class Test2 {
    public static void main(String[] args) {
        // 需求：判断一个整数是奇数还是偶数 并进行结果的输出 使用方法完成
        check(11);
        System.out.println("-------------");
        check(100);
    }

    public static void check(int number) {
        if(number % 2 == 0){
            System.out.println(number + "是偶数");
        }else {
            System.out.println(number + "是奇数");
        }
    }
}

数组求最值

需求：把找出数组的最大值案例，改造成方法，可以支持返回任意整型数组的最大值数据。

public class Test3 {
    public static void main(String[] args) {
        // 需求：使用方法，支持找出任意整型数组的最大值返回。
        int[] ages = {23, 19, 25, 78, 34};
        int max = getArrayMaxData(ages);
        System.out.println("最大值数据是：" + max);

        System.out.println("-------------------");
        int[] ages1 = {31, 21, 99, 78, 34};
        int max1 = getArrayMaxData(ages1);
        System.out.println("最大值数据是：" + max1);
    }

    public static int getArrayMaxData(int[] arr){
        // 找出数组的最大值返回
        int max = arr[0];
        // 遍历数组的每个元素与最大值的数据进行比较，若较大则替换
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
}

---

4、方法调用的内存图

• 方法没有被调用的时候，在方法区中的字节码文件中存放
• 方法被调用的时候，需要进入到栈内存中运行

---

5、方法的参数传递

Java的参数传递机制:值传递

在传输实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递。

基本类型和引用类型的参数在传递的时候的不同

1. 都是值传递。
2. 基本类型的参数传输存储的数据值。引用类型的参数传输存储的地址值。

案例

打印数组内容

设计一个方法用于输出任意整型数组的内容

public class MethodTest1 {
    public static void main(String[] args) {
        // 需求：定义方法，可以打印任意整型数组的内容：[12, 32, 23]
        // 4、定义数组，再调用方法
        int[] arr = {12, 32, 23};
        printArray(arr);

        System.out.println("-----------------");
        int[] arr2 = {};
        printArray(arr2);

        System.out.println("-----------------");
        int[] arr3 = null;
        printArray(arr3);
    }

    /**
        1、定义一个方法：参数：整型数组类型的变量  返回值类型申明：void
     */
    public static void printArray(int[] arr){
        if(arr != null){
            // 2、把数组内容打印出来。
            System.out.print("[");
            // 3、开始遍历数组中的每个数据
            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(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
            System.out.println("]");
        }else {
            System.out.println("当前数组对象不存在，其地址是：null");
        }
    }

    
}

从数组中查询元素的索引返回

需求：设计一个方法可以接收整型数组，和要查询的元素值;最终要返回元素在该数组中的索引，如果数组中不存在该元素则返回-1。

public class MethodTest2 {
    public static void main(String[] args) {
        // 需求：从整型数组中查询某个数据的索引返回，不存在该数据返回-1
        // 3、定义数组，调用方法
        int[] arr = {11, 22, 33, 66, 87, 19};
        int index = searchIndex(arr, 17);
        System.out.println("您查询的数据的索引是：" + index);
    }

    /**
       1、定义一个方法：参数接收数组，要查询的数据，返回值：整型
     */
    public static int searchIndex(int[] arr, int data){
        // 2、开始找出这个数据的索引
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == data){
                return i;
            }
        }
        return -1; // 查无此元素！
    }
}

比较两个数组内容是否相等

需求：如果两个数组的类型，元素个数，元素顺序和内容是一样的我们就认为这2个数组是一模一样的。

public class MethodTest3 {
    public static void main(String[] args) {
        // 需求：比较任意2个整型数组的内容是否一样，一样返回true 反之
        int[] arr1 = {10, 20, 30};
        int[] arr2 = {10, 20, 30};
        System.out.println(compare(arr1, arr2));

        System.out.println("-------------------");
        int[] arr3 = null;
        int[] arr4 = {};
        System.out.println(compare(arr3, arr4));
    }

    /**
        1、定义一个方法：参数：接收2个整型数组，返回值类型：布尔类型
     */
    public static boolean compare(int[] arr1, int[] arr2){
        if(arr1 != null && arr2 != null){
            // 2、判断2个数组的内容是一样的呢
            if(arr1.length == arr2.length){
                for (int i = 0; i < arr1.length; i++) {
                    if(arr1[i] != arr2[i]){
                        return false;
                    }
                }
                return true; // 是一样的！
            }else {
                return false;
            }
        }else {
            return false;
        }
    }
}

---

6、方法重载

同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。

public class MethodDemo1 {
    public static void main(String[] args) {
        // 目标：识别方法重载的形式。并理解其调用流程，最后需要知道使用方法重载的好处。
        fire();
        fire("B国");
        fire("B国", 1000);
    }

    public static void fire(){
        fire("A国");
    }

    public static void fire(String location){
        fire(location, 1);
    }

    public static void fire(String location, int number){
        System.out.println("默认发射"+number+"枚武器给"+location+"~~~");
    }
}

---

7、return关键字

return; —>可以立即跳出并结束当前方法的执行;return关键字单独使用可以放在任何方法中。

public class ReturnDemo {
    public static void main(String[] args) {
        // 目标：明确return关键字的作用。
        System.out.println("main开始。。");
        chu(10 , 0);
        System.out.println("main结束。。");
    }

    public static void chu(int a, int b){
        if(b == 0){
            System.out.println("您输入的数据有问题，除数不能是0！！");
            return; // 立即跳出当前方法，并结束当前方法的执行。
        }

        int c = a / b;
        System.out.println("结果是：" + c);
    }
}

关键字	作用
return	跳出并立即结束所在方法的执行
break	跳出并结束当前所在循环的执行
continue	结束当前所在循环的当次继续，进入下一次执行

---