java基础:方法的定义和调用详细介绍,方法同时获取数组最大值和最小值,比较两个数组,数组交换最大最小值,附练习案列

2021-12-11 02:05:51

1. 方法概述

1.1 方法的概念

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

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

2. 方法的定义和调用

2.1 无参数方法定义和调用

定义格式：

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

范例：

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

调用格式：
```
方法名();
```
范例：
```
method();
```
注意：

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

2.2 方法的调用过程

总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。

2.3 方法练习-奇偶数判断

需求：判断一个数是奇数还是偶数
代码：

public class Demo1Method {
    /*

        带参数方法的定义格式:
                public static void 方法名  ( 参数 )  { … … }
                public static void 方法名  ( 数据类型 变量名 )  { … … }

        带参数方法的调用格式:
                方法名 ( 参数 ) ;
                方法名 ( 变量名/常量值 ) ;

        tips: 参数可以是一个, 也可以是多个.

        需求: 判断一个数是奇数还是偶数
     */
    public static void main(String[] args) {
        isEvenNumber(10);
    }

    public static void isEvenNumber(int num){
        if(num % 2 == 0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }
}

3. 带参数方法的定义和调用

3.1 带参数方法定义和调用

定义格式：

参数：由数据类型和变量名组成 - 数据类型变量名

参数范例：int a

public static void 方法名 (参数1) {
    方法体;
}

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

范例：

public static void isEvenNumber(int number){
    ...
}
public static void getMax(int num1, int num2){
    ...
}

注意：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
```
方法定义时，多个参数之间使用逗号( ，)分隔
```

调用格式：

方法名(参数)；

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

范例：
```
isEvenNumber(10);

getMax(10,20);
```
- 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

3.2 形参和实参

形参：方法定义中的参数

等同于变量定义格式，例如：int number

实参：方法调用中的参数

等同于使用变量或常量，例如： 10 number

3.3 带参数方法的练习-打印n-m之间所有的奇数

需求：设计一个方法（print）用于打印 n 到 m 之间所有的奇数
思路：

1：定义方法，名称为print 2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参 3：方法中设计for循环，循环从n开始，到m结束 4：循环中加入if判断，是奇数，则打印 5：main方法中调用print方法，传入两个实际参数
代码：

package com.itheima.method2;

public class Demo2Method {
    public static void main(String[] args) {
        // 5：main方法中调用print方法，传入两个实际参数
        print(20,10);
    }

    //1：定义方法，名称为print
    // 2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
    public static void print(int n, int m){
        System.out.println(n + "到" + m + "之间的奇数为:");
        // 3：方法中设计for循环，循环从n开始，到m结束
        for(int i = 20; i <= 10; i++){
            // 4：循环中加入if判断，是奇数，则打印
            if(i % 2 == 1){
                System.out.println(i);
            }
        }
    }

}

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

4.1 带返回值方法定义和调用（掌握）

定义格式

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

范例

public static boolean isEvenNumber( int number ) {           
    return true ;
}
public static int getMax( int a, int b ) {
    return  100 ;
}

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

调用格式

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

范例
```
isEvenNumber ( 5 ) ;
boolean  flag =  isEvenNumber ( 5 ); 
```
- 注意：
  - 方法的返回值通常会使用变量接收，否则该返回值将无意义

4.2 带返回值方法的练习-求两个数的最大值(应用)

需求：设计一个方法可以获取两个数的较大值，数据来自于参数
思路：
1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回
2. 使用 if 语句得出 a 和 b 之间的最大值，根据情况return具体结果
3. 在main()方法中调用定义好的方法并使用【变量保存】

代码：

 /*
        需求：设计一个方法可以获取两个数的较大值，数据来自于参数

        1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回
        2. 使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果
        3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
     */
    public static void main(String[] args) {
        // 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
        System.out.println(getMax(10,20));  // 输出调用

        int result = getMax(10,20);
        System.out.println(result);

        for(int i = 1; i <= result; i++){
            System.out.println("HelloWorld");
        }

    }

    // 方法可以获取两个数的较大值
    public static int getMax(int a, int b){
        if(a > b){
            return a;
        }else{
            return b;
        }
    }

}

5. 方法的注意事项

5.1 方法的通用格式（掌握）

格式：

public static 返回值类型 方法名(参数) {

   方法体;

   return 数据 ;

}

解释：
- public static 修饰符，目前先记住这个格式
  
  返回值类型方法操作完毕之后返回的数据的数据类型
  
  如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
  
  方法名调用方法时候使用的标识
  
  参数由数据类型和变量名组成，多个参数之间用逗号隔开
  
  方法体完成功能的代码块
  
  return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
定义方法时，要做到两个明确
- 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
- 明确参数：主要是明确参数的类型和数量
调用方法时的注意：
- void类型的方法，直接调用即可
- 非void类型的方法，推荐用变量接收调用

5.2 方法的注意事项

方法不能嵌套定义

示例代码：

public class MethodDemo {

    public static void main(String[] args) {

    }

    public static void methodOne() {

		public static void methodTwo() {

       		// 这里会引发编译错误!!!

    	}

    }

}

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

示例代码：

public class MethodDemo {

    public static void main(String[] args) {

    }

    public static void methodTwo() {

        //return 100; 编译错误，因为没有具体返回值类型

        return;

        //System.out.println(100); return语句后面不能跟数据或代码

    }

}

6. 方法重载

6.1 方法重载

方法重载概念

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不相同，类型不同或者数量不同
注意：
- 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
- 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

正确范例：

public class MethodDemo {

	public static void fn(int a) {

    	//方法体

    }

    public static int fn(double a) {

    	//方法体

    }

}

public class MethodDemo {

	public static float fn(int a) {

    	//方法体

    }

    public static int fn(int a , int b) {

    	//方法体

    }

}

错误范例：

public class MethodDemo {

	public static void fn(int a) {

    	//方法体

    }

    public static int fn(int a) { 	/*错误原因：重载与返回值无关*/

    	//方法体

    }

}

public class MethodDemo01 {

    public static void fn(int a) {

        //方法体

    }

}

public class MethodDemo02 {

    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/

        //方法体

    }

}

6.2 方法重载练习

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

①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数

②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数

③定义所有的重载方法，两个byte类型与两个short类型参数

④完成方法的调用，测试运行结果

代码：

public class MethodTest {

    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;

    }

}

7. 方法的参数传递

7.1 方法参数传递基本类型（理解）

测试代码：

package com.itheima.param;

public class Test1 {

    /*

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

                传入方法中的, 是具体的数值.

     */

    public static void main(String[] args) {

        int number = 100;

        System.out.println("调用change方法前:" + number);

        change(number);

        System.out.println("调用change方法后:" + number);

    }

    public static void change(int number) {

        number = 200;

    }

}

结论：
- 基本数据类型的参数，形式参数的改变，不影响实际参数
结论依据：
- 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

7.2 方法参数传递引用类型

测试代码：

package com.itheima.param;

public class Test2 {

    /*

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

                传入方法中的, 是内存地址.

     */

    public static void main(String[] args) {

        int[] arr = {10, 20, 30};

        System.out.println("调用change方法前:" + arr[1]);

        change(arr);

        System.out.println("调用change方法后:" + arr[1]);

    }

    public static void change(int[] arr) {

        arr[1] = 200;

    }

}

结论：
- 对于引用类型的参数，形式参数的改变，影响实际参数的值
结论依据：
- 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

7.3 数组遍历

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
思路：
- 因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
  
  System.out.println(“内容”); 输出内容并换行
  
  System.out.print(“内容”); 输出内容不换行
  
  System.out.println(); 起到换行的作用
- 定义一个数组，用静态初始化完成数组元素初始化
- 定义一个方法，用数组遍历通用格式对数组进行遍历
- 用新的输出语句修改遍历操作
- 调用遍历方法

代码：

package com.itheima.test;

public class Test1 {
    /*
        需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
        思路：
            1.定义一个数组，用静态初始化完成数组元素初始化
            2.定义一个方法，对数组进行遍历
            3.遍历打印的时候，数据不换行
            4.调用遍历方法
     */
    public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44, 55};
        // 4.调用遍历方法
        printArray(arr);

        System.out.println("另外一段代码逻辑 ");
    }

    /*
        2.定义一个方法，对数组进行遍历

        1, 参数           int[] arr
        2, 返回值类型      void
     */
    public static void printArray(int[] arr){

        System.out.print("[");

        for (int i = 0; i < arr.length; i++) {

            if(i == arr.length -1){
                // 如果满足条件, 说明是最后一个元素, 最后一个元素, 特殊处理
                System.out.println(arr[i] + "]");
            }else{
                // 3.遍历打印的时候，数据不换行
                System.out.print(arr[i] + ", ");
            }


        }
    }
}

7.4 数组最大值

需求：设计一个方法用于获取数组中元素的最大值
思路：
- ①定义一个数组，用静态初始化完成数组元素初始化
- ②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了
- ③调用获取最大值方法，用变量接收返回结果
- ④把结果输出在控制台

代码：

package com.itheima.test;

public class Test2 {
    /*
        需求：设计一个方法用于获取数组中元素的最大值

        思路：
            1.定义一个数组，用静态初始化完成数组元素初始化
            2.定义一个方法，用来获取数组中的最大值
            3.调用获取最大值方法，用变量接收返回结果
            4.把结果输出在控制台
     */
    public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 55, 22, 44, 33};
        // 3.调用获取最大值方法，用变量接收返回结果
        int max = getMax(arr);
        //  4.把结果输出在控制台
        System.out.println(max);
    }

    /*
        2.定义一个方法，用来获取数组中的最大值

        1, 参数       int[] arr
        2, 返回值类型  int
     */
    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
}

7.5 方法同时获取数组最大值和最小值

需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值
注意: return语句, 只能带回一个结果.

代码：

public class Test3 {
    /*
        需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值

        注意: return语句, 只能带回一个结果.
     */
    public static void main(String[] args) {

        int[] arr = {11,55,33,22,44};

        int[] maxAndMin = getMaxAndMin(arr);

        System.out.println(maxAndMin[0]);
        System.out.println(maxAndMin[1]);

    }

    public static int[] getMaxAndMin(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }

        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }

        int[] maxAndMin = {min, max};

        return maxAndMin;
    }
}

day05课后作业题

代码题

1．训练案例1

1.1．训练描述

设计一个方法，用于比较两个数组{10,20,30,11}和{10,20,30,13}是否相同。在main方法中调用该方法测试功能

数组内容相同，指的是元素个数相同，元素值相同，并且元素顺序相同，条件缺一不可。

1.2．操作步骤描述

定义两个数组
创建方法，比较两个数组是否相同，
main方法中调用创建的方法

根据返回值打印不同的内容

package com.heima.meiri.day5;

public class mrb1Yuan {
    public static void main(String[] args) {
        int[]arr1={99,88,77,66};
        int[]arr2={99,88,77,6};
        boolean c=duibi(arr1,arr2);
        if (c==true){
            System.out.println("相同");
        }else {
            System.out.println("不同");
        }
    }
    public static boolean duibi(int[]a,int[]b){
        for (int i = 0; i < a.length; i++) {
            if (a.length!=b.length){
                return false;
            }
            if (a[i]!=b[i]){
                return false;
            }
        }return true;
    }
}

运行效果

2．训练案例2

2.1．训练描述

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

输入格式

请录入数组第1个元素
10
请录入数组第2个元素
20
请录入数组第3个元素
43
请录入数组第4个元素
3
请录入数组第5个元素
18

输出格式

您输入的数组为:
10 20 43 3 18 
改变后的数组为:
10 20 3 43 18

2.2．操作步骤描述

创建长度为5的数组
使用循环进行5此键盘录入，录入数组的元素
使用循环，输出原数组元素
调用方法，完成数组最大元素和最小元素交换
输出改变后的数组元素

package com.heima.meiri.day5;

import java.util.Scanner;

public class mrb2 {
    public static void main(String[] args) {
    /*    创建长度为5的数组，键盘录入数组数据
    ，创建一个方法，让数组最大元素与数组最小元素交换
    ，最后返回整理好的数组。
    */
        int[] arr = new int[5];//定义一个数组
        Scanner sc=new Scanner(System.in);//调用键盘录入方法
        System.out.println("请输入五个数值:");//给出输入提示
        for (int i = 0; i < arr.length; i++) {//循环遍历数组
            arr[i]=sc.nextInt();//将键盘录入的值赋给数组
        }
        System.out.println("你输入的数组为:");//给出输出提示
        for (int i = 0; i < arr.length; i++) {//遍历键盘录入存入到数组中的数据
            System.out.println(arr[i]);
        }
        System.out.println("-------");
        int[]arr2=maxAndmin(arr);//调用交换方法
        System.out.println("改变后:");//给出新数组输出提示
        for (int i = 0; i < arr2.length; i++) {//遍历修改后的数组
            System.out.println(arr2[i]);
        }


    }
    public static int[] maxAndmin(int[]arr){//创建交换最大最小值方法,返回值为数组类型
        int max=arr[0];//定义最大值
        int min=arr[0];//定义最小值
        int maxidex=0;//定义最大值索引
        int minidex=0;//定义最小值索引
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]){//求出原数组最大值
                max=arr[i];
                maxidex=i;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            if (min>arr[i]){//求出原数组最小值
                min=arr[i];
                minidex=i;
            }
        }
        int a=arr[maxidex];//交换最大最小值
        arr[maxidex] =arr[minidex];
        arr[minidex]=a;




        return arr;//返还数据,数据类型为数组

    }
}

运行效果

day05课后扩展作业题

单选题

1.要想使如下代码运行结果是：我是黑马程序员,则横线处应该填写的正确代码是（C ）

public static void main(String[] args){

   ________________________________

}

public static void method(){

    System.out.println("我是黑马程序员");

}

A:method;

B:void v = method();

C:method();

D:method("我是黑马程序员");

2.请观察以下代码，分别为1,2处选出正确选项，保证可以在控制台上输出 wo ai java(B)

public class Test08 {

    public static void main(String[] args){

           _____①_____

    }



    public _____②_____ print() {    

        System.out.println("wo ai java");

    }

}

A:① void v = print(); ② static void

B:① print(); ② static void

C:① int v = print(); ② static int

D:① print(); ② static

3:下列方法定义格式正确的是（B ）

public static void method1(){

    public static void method2(){

    }

}

public static void method1(){

}

public static void method1(){

   return 10;

}

public static boolean method1(int n){    

    if(n < 10){ 

        return false;

    }else if(n >= 10){

             return true;

    }
}

4:观察以下代码，请选出方法调用过程的正确顺序（D）

public static void main(String[] args) {

    System.out.println("开始执行");           //1

    int a = print(10);                //2

    System.out.println(a);                     //3

}

public static int print(int n){            //4

    n += 10;                         //5

    return n;                                 //6

}

A:1，2，3，4，5，6

B:1，2，4，6，5，3

C:1，4，5，6，2，3

D:1，2，4，5，6，3

5:以下选项中，方法定义的注意事项描述不正确的是（B）

A: 方法定义的位置，在类中方法外

B: 方法的参数的数据类型要和返回值类型一致，否则编译失败

C: 方法的返回值类型，必须要和return语句中返回值的数据类型匹配，否则编译失败

D: 不能在return后面写代码,return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码

多选题

6:下面关于方法的概述描述，正确的是（ABD）

A:方法定义的先后顺序无所谓

B:方法的定义不能产生嵌套包含关系。

C:方法可以让程序的执行效率更高

D:方法定义好了之后，不会执行的，如果要想执行，一定要进行方法的调用

7:以下选项中，关于方法定义的参数或返回值描述正确的是（ ABD）

A:方法的参数可以有，可以没有，也可以有多个

B:方法的参数就是定义一些变量，当方法被调用的时候，用来接收数据使用的

C:一个方法执行完成之后可以有一个返回值 ,也可以有多个返回值

D:方法的返回值是方法执行完成之后得到的结果

8:以下选项中，关于方法的调用过程描述正确的是 (ACD)

A: 由java虚拟机调用main方法，main方法先执行

B:在main方法执行中，会定义a和b变量，并分别赋值10和20，然后先调用isEquals方法，再调用getSum方法并输出结果

C:调用getSum方法时，要先传入两个整数，否则编译失败。然后执行getSum方法内的代码，执行完成之后，将结果返回赋值给int类型的变量sum

D: 调用isEquals方法时，要先传入两个整数，否则编译失败。然后执行isEquals方法内的代码，执行完成之后，没有结果返回

代码题

1．训练案例1

1.1．训练描述

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

效果演示：

请录入第一个整数
6
请录入第二个整数
30
6和30之间所有的偶数的和：234

1.2．操作步骤描述

创建键盘录入
获取用户录入的两个整数，判断两个整数的大小
定义一个int类型返回值,有参数的方法。
如果第一个整数比第二个整数小，调用方法获取这两个整数之间所有偶数的和，并返回
如果第一个整数比第二个整数大，提示“录入数据不合法”。

package com.heima.meiri.day5;

import java.util.Scanner;

public class kz {
   /*
1. 创建键盘录入
2. 获取用户录入的两个整数，判断两个整数的大小
3. 定义一个int类型返回值,有参数的方法。
4. 如果第一个整数比第二个整数小，调用方法获取这两个整数之间所有偶数的和，并返回
5. 如果第一个整数比第二个整数大，提示“录入数据不合法”。
6. 在主方法中调用这个方法
*/

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入第一个数据:");
        int a=sc.nextInt();
        System.out.println("请录入第二个数据:");
        int b=sc.nextInt();
        int c=ouHe(a,b);
        System.out.println(a+"到"+b+"之间的偶数和为:"+c);
    }
    public static int ouHe(int a,int b){
        int sum=0;
        if (a<=b){
            for (int i=a;i<=b;i++){
                if (i%2==0){
                    sum+=i;
                }
            }
        }else{
            System.out.println("数据不合法!");
        }return sum;
    }
}

运行效果:

码农公寓

1. 方法概述

1.1 方法的概念

2. 方法的定义和调用

2.1 无参数方法定义和调用

2.2 方法的调用过程

2.3 方法练习-奇偶数判断

3. 带参数方法的定义和调用

3.1 带参数方法定义和调用

3.2 形参和实参

3.3 带参数方法的练习-打印n-m之间所有的奇数

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

4.1 带返回值方法定义和调用（掌握）

4.2 带返回值方法的练习-求两个数的最大值(应用)

5. 方法的注意事项

5.1 方法的通用格式（掌握）

5.2 方法的注意事项

6. 方法重载

6.1 方法重载

6.2 方法重载练习

7. 方法的参数传递

7.1 方法参数传递基本类型（理解）

7.2 方法参数传递引用类型

7.3 数组遍历

7.4 数组最大值

7.5 方法同时获取数组最大值和最小值

day05课后作业题

代码题

1． 训练案例1

1.1． 训练描述

1.2． 操作步骤描述

运行效果​

2． 训练案例2

2.1． 训练描述

2.2． 操作步骤描述

运行效果

day05课后扩展作业题

单选题

多选题

代码题

1． 训练案例1

1.1． 训练描述

1.2． 操作步骤描述

相关文章

1．训练案例1

1.1．训练描述

1.2．操作步骤描述

运行效果

2．训练案例2

2.1．训练描述

2.2．操作步骤描述

1．训练案例1

1.1．训练描述

1.2．操作步骤描述