[2篇] JAVA基础系列 - 第6篇: 方法

原创

mb5fe947dd062d3 2021-01-28 12:25:52 ©著作权

文章标签 java 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mb5fe947dd062d3的原创作品，请联系作者获取转载授权，否则将追究法律责任

上篇回顾

上篇的内容不知道小伙伴们学习的怎样，我这里出几个问题帮助下大家巩固一下，大家看看能不能直接回答出来。

数组的特点是什么？
数组的两种初始化格式？
数组索引的特点是什么？
如何访问数组元素？如何获取数组长度？
数组元素的默认初始化值？

学习目标

方法

内容

1 方法的概述

1.1 什么是方法？

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

1.2 方法的两个注意：

方法必须先定义才能使用。（方法定义）
方法定义后不会自动运行，需要手动调用才能执行方法的功能。（方法调用）

2 方法的定义和调用

2.1 方法的定义格式1

定义格式：

访问修饰符 [非访问修饰符] void 方法名(){
    //需要在方法内完成的代码
}

调用格式：

方法名();

示例代码：

/**
 * 方法定义和调用案例代码
 */
public class MethodDemo {
    public static void main(String[] args) {
        //在main方法中调用方法
        printHelloWorld();
    }
    
    /**
     * 定义方法，打印5句HelloWorld
     */
    public static void printHelloWorld(){
        for (int i = 1; i <= 5; i++) {
            System.out.println("HelloWorld"+i);
        }
    }
}

2.2 方法调用图解

方法在栈中的调用执行过程：

1、栈是方法运行的内存区域。
2、栈是先进后出的结构，先调用的方法先入栈，后调用的方法后入栈，后入栈的方法先执行完毕，并在栈内存中消失。
3、所有方法执行完毕后，程序会回到main方法中继续执行，执行完毕后从栈内存中消失。

总结：

方法的执行，一定是main方法最先开始执行，最后从栈内存中消失。

2.3 带参数的方法

定义格式：

访问修饰符 [非访问修饰符] void 方法名( 参数类型1 参数名1, 参数类型2 参数名2, ...){
    方法体代码; 
}

注意：
 方法的参数，可以是一个，也可以是多个，如果是多个，中间需要以逗号分隔。

调用格式：

在main方法中，通过方法名调用，并传入对应的参数值

方法名(参数值);

调用带参方法的注意事项

调用带参方法，传入方法括号里的参数，无论个数和类型，都必须和方法定义时的个数和类型匹配。
传入方法的参数，可以是变量，也可以是常量。

示例代码：

/**
 * 需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
 */
public class MethodDemo {
    public static void main(String[] args) {
        //常量值的调用
        isEvenNumber(10);

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

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

}

2.4 形参和实参

形参，也叫形式参数，指的是定义方法的时候，方法小括号中定义的参数。
实参，也叫实际参数，指的是调用方法的时候，传入小括号中的常量或变量。

2.5 带参数方法练习

示例代码：

/**
 * 需求：
 *       设计一个方法，方法可以接收两个整数，在方法内进行逻辑判断，
 *       打印出两个数中的较大值。
 */
public class MethodTest {
    public static void main(String[] args) {
        //调用方式1：实际参数为常量
        getMax(10,20);
       
        //调用方式2：实际参数为变量
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

 /**
  * 定义方法，打印两个整数的较大值
  */
    public static void getMax(int a, int b) {
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

思考：sum方法计算出的两个整数的和，能否返回给调用者继续使用？

2.6 带返回值的方法

定义格式：

访问修饰符 [非访问修饰符] 数据类型 方法名(参数列表){
 方法体代码;
 return 数据值;
}

1) 格式要求

有返回值类型，就必须要有return语句
返回值必须和返回值类型相匹配

2) return语句的作用？

return语句用于将方法的运算结果返回给调用者。
return语句一旦执行，方法的调用就结束了。

3）有返回值的方法是否一定要接收返回结果？

举例：

超市买东西，付钱后给的小票，可以拿也可以不要。如果把付钱的功能定义成一个方法，付钱后给的小票可以理解为方法执行后返回的数据，返回的数据可以接收也可以不接收（相当于小票可以拿走也可以不要）。

结论：

调用有返回值的方法时，方法的返回值可以接收也可以不接收，根据实际需要确定。如果不接收，该返回值就会丢失。大部分情况下，需要接收返回结果的。

4）有返回值的方法调用方式

1. 直接调用：该方式会丢失返回值数据。
 方法名(参数值);

2. 输出调用：在输出语句中调用，直接使用结果。
 System.out.println( 方法名(参数值) );

3. 赋值调用：调用方法，并定义变量接收返回值。 （使用最多的方式）
 数据类型  变量名 =  方法名(参数值);

示例代码：

//需求：定义方法计算并返回两个整数的和
public class MethodDemo {
    /**
     *   两个明确：
     *       明确参数：两个整数变量
     *       明确返回值：有返回值，类型是int
     */
    public static int sum(int a, int b){
        return  a + b;
    }

    public static void main(String[] args) {
        //有返回值的方法调用
        // 1、直接调用
        sum(10,20); //丢失方法了返回值

        // 2、输出调用
        // 直接将返回结果在控制台输出
        System.out.println( sum(10,20) );

        // 3、赋值调用（最常用的方式）
        int result = sum(10,20);

        //赋值调用的好处：拿到返回值后可以同时做多种操作
        //操作1：打印结果
        System.out.println(result); 
        //操作2：计算平均值
        System.out.println( result/2 );
    }
}

2.7 方法使用注意事项

1）方法与方法之间是平级关系，不允许嵌套定义。

2）方法有明确返回值类型时，必须要有return语句返回对应的数据。

3）返回值类型为void，则代表无返回值，可以省略return语句，也可以单独使用return关键字，

用于结束方法，但是return后面不能跟任何数值。

4）方法有形参时，调用时必须传递实参，传递的实参个数和类型必须和形参匹配。

5） return语句后面不能直接跟其他代码。

3 方法重载

3.1 什么是方法重载

同一个类中，出现了多个同名的方法，叫做方法重载。

3.2 构成方法重载的条件

1. 多个方法在同一个类中。
2. 多个方法名称相同。
3. 多个方法的参数列表不同（个数或者类型不同）。

注意：
 方法重载与返回值和参数名称无关。
 
简单总结： 
 同一类中，方法名称相同，参数列表不同，即构成方法重载。

3.3 方法重载的作用

方便程序员对参数不同，但是功能相同或相似的方法进行统一的命名和调用。

3.4 调用重载的方法

调用时，虚拟机会根据参数列表的不同来区分调用对应的重载方法。

正确范例：

/*
 方法名相同，参数类型不同，构成方法重载
*/
public class MethodDemo {
 public static void fn(int a) {
     //方法体
    }
    public static int fn(double a) {
     //方法体
    }
}


/**
 * 同一类中，方法名fn相同，参数列表不同（个数不同），构成方法重载
 */
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) {
        //方法体
    }
}

练习案例1：

/*
    方法重载的条件：
        1. 多个方法在同一个类中。
        2. 多个方法名称相同。
        3. 多个方法的参数列表不同（个数或者类型不同）。
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        int result = sum(10,20);
        System.out.println(result);

        double result2 = sum(10.0,20.0);
        System.out.println(result2);

        int result3 = sum(10,20,30);
        System.out.println(result3);
    }

    //1. 定义sum方法返回两个int整数的和
    public static int sum(int a, int b) {
        return a + b;
    }

    //2. 定义重载的sum方法返回两个double浮点数的和
    public static double sum(double a, double b) {
        return a + b;
    }

    //3. 定义重载的sum方法返回三个整数的和
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

}

练习案例2：

/*
 * 定义重载的方法 分别比较 两个byte数、两个short数、两个int数、两个long数 是否相等
 */
public class MethodOverLoad {
 // 方法1：判断两个byte数是否相等
 public static boolean compare(byte a, byte b) {
  System.out.println("byte");
  return a == b;
 }
 // 方法2：判断两个short数是否相等
 public static boolean compare(short a, short b) {
  System.out.println("short");
  return a == b;
 }
 // 方法3：判断两个int数是否相等
 public static boolean compare(int a, int b) {
  System.out.println("int");
  return a == b;
 }
 // 方法4：判断两个long数是否相等
 public static boolean compare(long a, long b) {
  System.out.println("long");
  return a == b;
 }
 //测试方法重载的调用
 public static void main(String[] args) {
  //输出调用
  System.out.println( compare(10, 20) );//整数默认是int类型，所以会调用int参数的重载方法
  System.out.println( compare((byte)10, (byte)20) ); //byte
  System.out.println( compare((short)10, (short)20) ); //short
  System.out.println( compare(10L, 20L) );//long
 }
 
}

4 方法参数传递

4.1 方法参数传递基本类型

方法参数为基本数据类型时，参数为值传递，形式参数的改变不影响实际参数

代码：

/*
参数传递为基本数据类型
*/
public class MethodDemo4 {
    public static void main(String[] args) {
        int num  = 5;
        add(num);
        System.out.println(num);
    }

    //方法形参为基本数据类型
    public static void add(int num){
        num+=10; //num = 15;
    }
}

图解：

[2篇] JAVA基础系列 - 第6篇: 方法_java

//分析以下程序的输出结果？
public static void main(String[] args) {
  int a = 10;
  int b =20;
  
  System.out.println(a);  //10
  System.out.println(b);  //20
  
  sum(a,b);
  
  System.out.println(a); //10
  System.out.println(b);  //20
 }
 
 public static void sum(int a, int b){  //a = 10; b= 20;
  a = b ; //a =20   b= 20;
  b = a+b; //b= 20+20 = 40
  
  System.out.println(a); //20
  System.out.println(b); //40
 }

4.2 方法参数传递引用类型

什么是引用类型数据？

在堆内存中创建，并产生了一个地址值的数据。（数组、对象，接口）

方法参数为引用数据类型时，参数为地址传递，形式参数的改变会影响实际参数。

代码：

/*
参数传递为引用类型
*/
public class MethodDemo5 {
    public static void main(String[] args) {

        int[] arr = {10,20,30};
        System.out.println("调用前："+arr[0]); //10

        change(arr);

        System.out.println("调用后："+arr[0]); //100
    }

    //方法形参为引用类型
    public static void change(int[] arr) {
        arr[0] = 100;
    }
}