方法

方法

1：方法

1.1 方法概述

**方法(method)：**就是完成特定功能的代码块

1.2 方法的定义和调用

null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
    定义格式：
        public static void 方法名() {
           //方法体
       }
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        isEvenNumber();
    }

    //需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
    public static void isEvenNumber() {
        //在方法中定义一个变量
        int number = 10;
        number = 9;

        //判断该数据是否是偶数
        if (number % 2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "不是偶数");
        }
    }
}

注意事项：

  • 方法定义完毕后，需要调用才能执行
  • 方法必须先定义后调用，否则程序将报错

1.4 练习1(输出较大值)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
    需求：设计一个方法用于打印两个数中的较大数

    分析：
        1:定义一个方法，用于打印两个数字中的较大数，例如：getMax()
        2:方法中定义两个变量，用于保存两个数字
        3:使用if语句对两个数字的大小关系进行处理
        4:在main()方法中调用定义好的方法
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
        int max = getMax(10, 20); //.var的使用，它能够帮我们自动补齐左边的内容
        System.out.println(max); //max.sout，能够把max变量放到输出语句中

        System.out.println(getMax(10,20));
    }
    //定义一个方法，用于获取两个数字中的较大数，例如：getMax()
    public static int getMax(int a,int b) {
        //使用if语句对两个数字的大小关系进行处理
        //根据题设分别设置两种情况下对应的返回结果
        if(a >= b) {
            return a;
        } else {
            return b;
        }
    }
}

1.5 带参数方法的定义和调用

格式：

1640093895684

范例：

1640093914623

1640093937633

注意事项：

  • 带参方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
  • 带参方法定义时，多个参数之间使用逗号(,)分隔
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
    带参数方法的定义和调用

    定义格式：
        public static void 方法名(参数) { … … }
 */
public class MethodDemo {
    public static void main(String[] args) {
        //字面量值调用
        isEvenNumber(10);
        isEvenNumber(9);

        //变量的调用
        int number = 11;
        isEvenNumber(number);
        number = 12;
        isEvenNumber(number);
    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
    public static void isEvenNumber(int number) {
        if (number % 2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
}

参数方法的调用和注意事项：

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

1.6 形参和实参

基本数据类型作为方法参数

参数传递概念:

​ 形式参数:

​ 在定义方法时,()中定义的变量,称为形式参数,定义时必须不能有值,方法被调用时,才会有值

​ 实际参数:

​ 在调用方法时,()中给定的参数(常量/变量),称为实际参数,如果是变量,则必须要有值

​ 特点: 形式参数的改变,不会影响实际参数

​ 原因:

​ 基本类型作为参数,传递的是具体的数据值

​ 每个方法都有自己的内存空间,所以每个方法内部的变量也有自己的内存空间,

​ 即便是不同的方法内部定义了同名的变量,他们的内存空间不同,它们之间互不影响,互不干扰

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Demo03BaseVar {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("ms..a="+a);//10
        System.out.println("ms..b="+b);//20

        //调用方法
        change( a, b );//调用方法时,()中给出的参数,称为实际参数

        System.out.println("me..a="+a);//10
        System.out.println("me..b="+b);//20
    }

    //定义方法
    public static void change(int a, int b) {//方法定义时,()中定义的变量,称为形式参数
        System.out.println("cs..a="+a);//10
        System.out.println("cs..b="+b);//20
        a = a * 10;
        b = b * 10;
        System.out.println("ce..a="+a);//100
        System.out.println("ce..b="+b);//200

        return ;//结束方法,返回到调用处
    }
}
1
2
3
4
5
6
7
8
9
10
11
需求：比较两个int类型的数组是否一样，返回true或者false
分析：
    1.方法是否需要接收数据进行处理？
        因为，方法中需要两个int数组比较，但是需求并不明确是哪两个数组；
        所以，需要接收两个int类型的数组，形参声明为：int[] arr1，int[] arr2 

     2.方法是否需要返回数据？
         因为,方法最终的结果需要true或者false;
        所以，返回值类型是boolean
         
    1. 方法内部的业务：判断两个数组内容是否一样。

代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class MethodTest4 {
    public static void main(String[] args) {
        // 目标：完成判断两个int类型的数组是否一样。
        int[] arr1 = {10, 20, 30};
        int[] arr2 = {10, 20, 30};
        System.out.println(equals(arr1, arr2));
    }

    /*
        参数：
            int[] arr1, 参与比较的第一个int数组
            int[] arr2  参与比较的第二个int数组
        返回值:
            返回比较的结果true或者false
    */
    public static boolean equals(int[] arr1, int[] arr2){
        // 1、判断arr1和arr2是否都是null.
        if(arr1 == null && arr2 == null){
            return true; // 相等的
        }

        // 2、判断arr1是null，或者arr2是null.
        if(arr1 == null || arr2 == null) {
            return false; // 不相等
        }

        // 3、判断2个数组的长度是否一样，如果长度不一样，直接返回false.
        if(arr1.length != arr2.length){
            return false; // 不相等
        }

        // 4、两个数组的长度是一样的，接着比较它们的内容是否一样。
        // arr1 = [10, 20, 30]
        // arr2 = [10, 20, 30]
        for (int i = 0; i < arr1.length; i++) {
            // 判断当前位置2个数组的元素是否不一样，不一样直接返回false
            if(arr1[i] != arr2[i]){
                return false; // 不相等的
            }
        }
        return true; // 两个数组是一样的。
    }
}

1.7 练习2(输出较大值)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
    需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数

    分析：
        1:定义一个方法，用于打印两个数字中的较大数，例如：getMax()
        2:为方法定义两个参数，用于接收两个数字
        3:使用if语句对两个数字的大小关系进行处理
        4:在main()方法中调用定义好的方法（使用字面量）
        5:在main()方法中调用定义好的方法（使用变量）
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用字面量）
        getMax(10,20);
//        getMax(a:10,b:20); //idea的智能提示，不要手动的去写a,b
//        getMax(30);
//        getMax(10.0,20,0);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型，你就给什么类型

        //在main()方法中调用定义好的方法（使用变量）
//        int a = 10;
//        int b = 20;
//        getMax(a,b);
        int x = 10;
        int y = 20;
        getMax(x,y);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如：getMax()
    //为方法定义两个参数，用于接收两个数字
    public static void getMax(int a, int b) {
        //使用if语句对两个数字的大小关系进行处理
        if(a >= b) {
            System.out.println("较大的数是：" + a);
        }else {
            System.out.println("较大的数是：" + b);
        }
    }
}

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

下面呢我们来学习带返回值方法的定义和调用。

格式：

1640094498444

范例：

1640094510376

1640094527616

注意事项：

  • 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
    带返回值方法的定义和调用

    定义格式：
        public static 数据类型 方法名(参数) {
           return 数据;
       }
 */
public class MethodDemo {
    public static void main(String[] args) {
//        isEvenNumber(10);
//        //true;

        boolean flag = isEvenNumber(10);
        //boolean flag = true;
        System.out.println(flag);

//        if(flag) {
//            System.out.println("是偶数就输出这句话");
//        }
    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
    public static boolean isEvenNumber(int number) {
        if (number % 2 == 0) {
            return true;
        } else {
            return false;
        }
    }
}

调用和注意事项：

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

1.9 练习3(输出较大值)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
    需求：设计一个方法可以获取两个数的较大值，数据来自于参数

    分析：
        1:定义一个方法，用于获取两个数字中的较大数，例如：getMax()
        2:使用if语句对两个数字的大小关系进行处理
        3:根据题设分别设置两种情况下对应的返回结果
        4:在main()方法中调用定义好的方法并使用变量保存
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
//        int max = getMax(10,20);
//        System.out.println(max);

        int max = getMax(10, 20); //.var的使用，它能够帮我们自动补齐左边的内容
        System.out.println(max); //max.sout，能够把max变量放到输出语句中

        System.out.println(getMax(10,20));
        System.out.println(getMax(10, 20));
    }

    //定义一个方法，用于获取两个数字中的较大数，例如：getMax()
    public static int getMax(int a,int b) {
        //使用if语句对两个数字的大小关系进行处理
        //根据题设分别设置两种情况下对应的返回结果
        if(a >= b) {
            return a;
        } else {
            return b;
        }
    }
}

1.10 方法的注意事项

Java的方法是在哪个内存区域中执行呢？

答案是栈内存。

每次调用方法，方法都会进栈执行；执行完后，又会弹栈出去。

我们讲解两个注意事项：

  1. 方法不能嵌套定义

    1640094861339

  2. void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

    1640094884063

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
方法不能嵌套定义
public static void methodOne() {
		public static void methodTwo() {
       		// 这里会引发编译错误!!!
    	}
    }

返回值类型，必须要和return语句返回的类型相同，否则编译失败
// 返回值类型要求是int
public static int getSum() {
    return 5;// 正确，int类型
    return 1.2;// 错误，类型不匹配
    return true;// 错误，类型不匹配
}

不能在return 后面写代码,属于无效代码。
public static int getSum(int a,int b) {
  	return a + b;
  	System.out.println("Hello");// 错误，return已经结束，这里不会执行，无效代码
}

void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
public static void methodTwo() {
        //return 100; 编译错误，因为没有具体返回值类型
        return;	
        //System.out.println(100);  return语句后面不能跟数据或代码
}

定义方法,判断一个字符是否是字母
        char c = 'A';
        boolean flag = isChar(c);
        System.out.println(flag);
    public static boolean isChar(char ch) {
        if((ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z')) {
            return true;
        }
        return false;
    }

2：方法的通用格式

2.1 格式

方法定义只有一种格式，这里我们来看一下方法定义的通用格式：

格式：

1640095031496

定义方法时，要做到两个明确

  • 明确返回值类型： 主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
  • 明确参数： 主要是明确参数的类型和数量

而在调用方法时，我们要知道下面两种不同返回值类型的方法调用：

  • void类型的方法，直接调用即可
  • 非void类型的方法，推荐用变量接收调用

2.2 练习1(求和)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
    需求：设计一个方法用于求1-n之间的数据和(n>1)，返回求和结果。调用方法，把结果在控制台输出。
 */
public class MethodTest01 {
    public static void main(String[] args) {
        int result = sum(5);
        System.out.println("1-5的和是：" + result);

        result = sum(100);
        System.out.println("1-100的和是：" + result);
    }

    /*
       使用两个明确分析该方法的参数和返回值
        参数：int n
        返回值类型：int
     */
    public static int sum(int n) {
        int sum = 0;

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

2.3 练习2(比较相等)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*
    需求：设计一个方法用于比较两个整数是否相等，调用方法，把结果在控制台输出。
 */
public class MethodTest02 {
    public static void main(String[] args) {
        boolean flag = compare(10, 20);
        System.out.println("10和20相等吗：" + flag);

        flag = compare(10,10);
        System.out.println("10和10相等吗：" + flag);
    }

    /*
        使用两个明确分析该方法的参数和返回值
        参数：int a,int b
        返回值类型：boolean
     */
    public static boolean compare(int a,int b) {
        //比较两个整数是否相等
//        if(a == b) {
//            return true;
//        } else {
//            return false;
//        }

//        boolean flag = (a == b) ? true : false;
//        return flag;

//        boolean flag = (a == b);
//        return flag;

        return a == b;
    }
}

2.4 练习3(较大值)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
    需求：设计一个方法用于获取两个整数较大值，调用方法，把结果在控制台输出。
 */
public class MethodTest03 {
    public static void main(String[] args) {
        int max = getMax(10, 20);
        System.out.println("最大值：" + max);
        System.out.println("main...end...");
    }

    /*
        使用两个明确分析该方法的参数和返回值
        参数：int a,int b
        返回值类型：int
     */
    public static int getMax(int a, int b) {
        int result = a > b ? a : b;
        return result;
    }
}

1747301094594

2.5 练习4(判断偶数)

1
2
3
4
5
6
7
8
9
public static boolean isOu(int num) {
    boolean result = (num % 2 == 0) ? true : false;
    return result;//把结果数据result返回给调用这
}

int num = 100;
//调用方法isOu,传递num,获取结果保存到boolean变量result中
boolean result = isOu( num );
System.out.println(num + " 是偶数? " + result);

1747301822574

2.6 案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//定义int长度为3的数组采用动态初始化
        int[] arr = new int[3];
        printArray(arr); //调用方法输出数组内容
        fillArray(10, arr); //调用方法,把数组元素填充为10
        printArray(arr);//调用方法输出数组内容

    public static void printArray(int[] array) {
        if (array == null) { 
            System.out.println("null");//数组为null,直接输出null
            return;
        }
        int maxIndex = array.length - 1;        //获取数组的最大索引
        //数组长度为0,直接输出[]
        if (maxIndex == -1) {//说明array.length的值为0,数组没有元素
            System.out.println("[]");
            return;
        }
        System.out.print("[");

        for (int i = 0; i <= maxIndex; i++) {
            //2.1输出当前元素,不换行
            System.out.print(array[i]);
            //2.2判断如果当前元素不是最后一个元素,输出", "
            if (i != maxIndex) {
                System.out.print(", ");
            }
        }
        //3.输出]
        System.out.println("]");
    }

    public static void fillArray(int value, int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        for (int i = 0; i < array.length; i++) {
            array[i] = value;
        }
    }