java学习笔记day05-方法

Day05

方法

• 定义：方法就是一段具有独立功能的代码块，不调用就不执行。

• 好处：提高代码的复用性

方法使用前提须知

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

方法定义

• 格式：

public static void 方法名(){
	//方法体
}
范例：
public static void eat(){
	//方法体
}   

方法调用

• 格式：方法名();
• 范例：eat();

注意：方法与方法之间是平级关系，不能嵌套定义。

方法调用过程

• 方法没有被调用的时候，都在方法区中的字节码文件(.class)中存储
• 方法被调用的时候，需要进入到栈内存中运行，先进后出

/*
	调用过程：
	main()开始，main()调用eat(),eat()执行输出"吃饭",eat()调
	用study(),study()执行输出"学习",study()执行完毕,study()
	退出,eat()执行完毕,eat()退出,main()执行完毕,main()退出。
*/
public class MethodTest1 {
    public static void main(String[] args) {
        eat();
    }
    public static void eat(){
        System.out.println("吃饭");
        study();
    }
    public static void study(){
        System.out.println("学习");
    }
}

结果：

带参数方法的定义和调用

• 定义格式：

单个参数：
public static void 方法名(数据类型 变量名){...}
范例：
public static void method(int number){...}

多个参数:
public static void 方法名(数据类型 变量名1,数据类型 变量名2,...){...}
范例:
public static void method(int number1,int number2,...){...}

• 注意：

  • 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
  • 方法定义时，多个参数之间使用“,”分隔。

• 调用格式：

单个参数：
方法名(变量名/常量值);
范例：
method(5);

多个参数：
方法名(变量名1/常量值1,变量名2/常量值2,);
范例：
getMax(5,6);

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

案例：奇偶数判断

public class MethodTest1 {
    public static void main(String[] args) {
        method(5);  //调用method(int i)并传递参数使i=5
    }
    public static void method(int i){  //参数为i
        if(i%2==0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }
}

形参和实参

• 形参：形式参数，指方法定义中的参数；
• 实参：实际参数，方法调用中的参数。

案例：求n~m间的所有偶数

public class MethodTest1 {
    public static void main(String[] args) {
        print(27,68);  //调用print方法，传入两个实际参数
    }
    public static void print(int n,int m){  //定义方法名称为print，带有两个int形参，接受调用者传来的实参  
        System.out.println("n~m间的所有偶数为：");
        for(int i=n;i<=m;i++){
            if(i%2==0){
                System.out.print(i+" ");
            }
        }
    }
}

结果：

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

• 定义

格式：
public static 数据类型 方法名(参数){
	return 数据;
}
范例：
public static boolean isEvenNumber(int number){
	return true;
}

• 注意

  • 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
  • return语句只能带回一个结果

• 调用

格式1：
方法名(参数);
范例：isEvenNumber(5);

格式2：
数据类型 变量名 = 方法名(参数);
范例：boolean flag = isEvenNumber(5);

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

案例：求两个小数和

public class MethodTest1 {
    public static void main(String[] args) {
        double sum = he(2.7,6.8);  //调用he方法并将所得结果赋值给sum
        System.out.println("sum="+sum);
    }
    public static double he(double a,double b){
        return a+b;  //将结果返回给调用者
    }
}

方法通用格式

• 格式

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

public static	修饰符
返回值类型		 方法操作完毕之后返回的结果数据，所对应的数据类型
				 如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名			  调用方法时候使用的标识
参数			   由数据类型和变量名组成，多个参数直接用逗号隔开
方法体			  完成功能的代码块
return 			如果方法操作完毕，有数据返回，用于把数据返回给调用者

• 定义方法时，要做到两个明确
  • 明确参数：主要是明确参数的类型和数量；
  • 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型；
• 调用方法时
  • void类型的方法直接调用即可；
  • 非 void类型的方法，推荐用变量接收调用

编写方法的注意事项

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

方法重载

概述

​ 在同一个类中，定义了多个同名的方法，但每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系

简单记：

​ 同一个类中，方法名相同，参数不同的方法；参数不同：个数不同、类型不同、顺序不同

注意：

​ 识别方法之间是否有重载关系，只看方法名和参数，跟返回值无关；

​ 如果方法调用的时候，找不到合适类型的参数的方法，会自动将实参的数据类型提升，然后再次匹配；

示例：

public class MethodTest1 {
    public static void main(String[] args) {
        int c = 1;
        int d = 2;
        getMax(c,d);
        getMax(3,4);
        double a = 10.1;
        double b = 10.5;
        getMax(a,b);
        getMax(2.7,6.8);
        float e = 3.65f;
        float f = 6.64f;
        getMax(e,f);
        getMax(4.56f,7.89f);
    }
    public static void getMax(int a,int b){
        if (a>b){
            System.out.println("int："+a);
        }else{
            System.out.println("int："+b);
        }
    }
    public static void getMax(double a,double b){
        if (a>b){
            System.out.println("double："+a);
        }else{
            System.out.println("double："+b);
        }
    }
    public static void getMax(float a,float b){
        if (a>b){
            System.out.println("float："+a);
        }else{
            System.out.println("float："+b);
        }
    }
}

结果：

方法参数传递为基本数据类型

public class MethodTest1 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前："+number);
        change(number);  //传递的是number这个变量记录的数据值100
        System.out.println("调用change方法后："+number);
    }
    public static void change(int number){
        /*
            这里修改的仅仅是这个change方法内的变
            量，当这个方法执行完的时候，这个方法
            中的变量也会随之死去；
        * */
        number = 200;
    }
}

结果：

方法参数传递为引用数据类型

public class MethodTest1 {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        System.out.println("调用change方法前："+arr[1]);
        change(arr);  //传递的是数组arr保存的地址值
        System.out.println("调用change方法后："+arr[1]);
    }
    public static void change(int[] arr){
        /*
            根据main方法传递进来的地址值，找到那个数组的
            索引位置的元素，并修改为200；当这个方法执行
            完的时候，仅仅是这个方法的arr死去了，堆内存
            的数组已经改变了！
        * */
        arr[1] = 200;
    }
}

结果：

案例：数组遍历

需求：要求遍历的结果在一行上，格式如：[11, 22, 33, 44, 55]

/*
	1.定义一个数组并初始化
	2.定义一个方法对数组进行遍历
	3.遍历打印的时候，数据不换行
	4.调用遍历方法
*/
public class MethodTest1 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        printArray(arr);
    }
    public static void printArray(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] + ", ");
            }
        }
    }
}

结果：

案例：获取数组的最大值和最小值

public class MethodTest1 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};  //定义要遍历的数组并初始化
        int[] result = printMaxAndMin(arr);  //调用求最值方法并接收返回结果
        System.out.println("最大值为："+result[0]);
        System.out.println("最小值为："+result[1]);
    }
    public static int[] printMaxAndMin(int[] arr){  //定义一个参数为整型数组的方法，返回值也为整形数组
        int max = arr[0];
        int min = arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
            if(min>arr[i]){
                min=arr[i];
            }
        }
        int[] maxandmin = {max,min};  //上面得出最大值和最小值，由于return只能返回一个变量，所以将两最值存入数组
        return maxandmin;  //通过数组将两最值返回给调用者
    }
}

结果:

练习1

​ 设计一个方法，用于比较两个数组{10,20,30,11}和{10,20,31,11}是否相同。在main方法中调用该方法测试功能；数组内容相同，指的是元素个数相同，元素值相同，并且元素顺序相同，条件缺一不可。

public class MethodTest1 {
    public static void main(String[] args) {
        //定义两个数组
        int[] arr1 = {10,20,30,11};
        int[] arr2 = {10,20,31,11};
        than(arr1,arr2);  //最后调用than方法
    }
    public static void than(int[] arr1,int[] arr2){
        //先比较两个数组的长度，若相等再进行内容的比较，否则两数组不等
        if (arr1.length==arr2.length){
            //两数组长度相同，对两数组中的数逐个进行对比
            for(int i=0;i<arr1.length;i++){
                //遍历中若存在数不相等，则两数组不同，程序结束，不再进行比较
                if(arr1[i]!=arr2[i]){
                    System.out.println("两数组的第"+(i+1)+"个数不同，所以两数组不相同！");
                    return;
                }
            }
            //遍历结束，不存在数不相等，则两数组相同
            System.out.println("两数组相同！");
        }else{
            System.out.println("两数组的长度不同，所以两数组不相同！");
        }
    }
}

结果：

练习2

​ 创建长度为5的数组，键盘录入数组数据，创建一个方法，让数组最大元素与数组最小元素交换，最后返回整理好的数组。

import java.util.Scanner;
public class MethodTest1 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[5];
        //调用exchange方法并接收返回的数组
        int[] arr1 = exchange(arr);  //调用方法结束后，原数组已在方法中修改，所以方法不需要再返回数组，在main方法中可以直接遍历原数组，不用再新建数组去接收数据
        System.out.println("改变后的数组为：");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
    //编写一个exchange方法实现数据交换
    public static int[] exchange(int[] arr){
        Scanner sc = new Scanner(System.in);
        //键盘录入数据给数组
        for(int i=0;i<arr.length;i++){
            System.out.print("请录入数组第"+(i+1)+"个元素：");
            arr[i]=sc.nextInt();
        }
        //遍历数组，找出最大值和最小值及其下标
        int max = arr[0];
        int min = arr[0];
        int a = 0;  //记录数组中最大值的下标
        int b = 0;  //记录数组中最小值的下标
        System.out.println("你输入的数组为:");
        for (int i = 0; i < arr.length; i++) {
            if(max<arr[i]){
                max = arr[i];
                a=i;  //每次max的值改变，a的值都会重置为给max赋值的数的小标，最终a的值即为数组中最大值的下标
            }
            if(min>arr[i]){
                min = arr[i];
                b = i;  //每次min的值改变，b的值都会重置为给min赋值的数的小标，最终b的值即为数组中最小值的下标
            }
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        //交换数组中最大值和最小值的位置
        int temp = arr[a];  //此处由于最值已经求出，可以直接arr(a)=min,arr(b)=max,即可将两最值位置交换
        arr[a] = arr[b];
        arr[b] = temp;
        return arr;
    }
}

结果：

练习3

​ 键盘录入的两个整数，如果第一个整数比第二个整数小，定义一个方法，接受两个整数，返回这两个整数之间的所有的偶数的和；如果第一个整数比第二个整数大，提示“录入数据不合法”。

import java.util.Scanner;
public class MethodTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true){  //将输入写入死循环，使得录入不合法时能够重新录入
            System.out.print("请录入第一个数据：");
            int a = sc.nextInt();
            System.out.print("请录入第二个数据：");
            int b = sc.nextInt();
            if(a<b){
                int sum = sum(a,b);  //录入符合规范，调用sum方法并接收其返回值
                System.out.println("两数之间的偶数和为："+sum);
                break;  //方法执行完毕，终止循环
            }else{
                System.out.println("录入数据不合法，请重新输入并是第一个数小");
            }
        }
    }
    public static int sum(int a,int b){
        int sum = 0;
        for(int i=a;i<=b;i++){
            if(i%2==0){  //求出两数间的偶数
                sum += i;  //得出两数间的所有偶数的和
            }
        }
        return sum;
    }
}

结果：