本小节我们将学习什么是方法、如何自定义方法，并按照分类介绍每种方法的特点，对于有参数的方法传值，会讲到基本数据类型作为方法参数和引用数据类型作为方法参数的区别。也会学习可变参数方法的定义语法和使用场景，方法重载的使用和意义也是本节的重点学习内容。

1. 什么是方法

在前面我们已经了解过方法的概念，Java 程序的入口main()就是一个方法。System.out.println();语句中println()也是一个方法。
如果你使用IntelliJ IDEA查看代码，可以使用Ctrl + 鼠标左键单击代码中的 println()方法，查看 JDK 源码中对于这个方法的定义：
1.png
上面的截图就是我们经常调用的老朋友println()方法的代码实现，我们可以将方法理解为一个命名语句块，通过其名称 + 括号运算符()可以调用。我们可以将需要重复编写的代码，封装到一个方法中。提高代码的复用性。

2. 如何定义方法

在 Java 中，定义一个方法的语法为：

  1. 访问修饰符 返回类型 方法名(参数列表) {
  2.     若干语句;
  3.     return 方法返回值;
  4. }
  • 访问修饰符有 4 种情况：public、private、protected，也可以省略（default)。由于涉及到后面的面向对象相关知识，本节统一使用public修饰方法；
  • 返回类型：可以是任何的数据类型或 void，如果方法没有返回值，返回类型设置为void；
  • 方法名：方法名的命名规范和变量相同；
  • 参数列表：参数是变量的一种类型，参数变量的作用域在方法内部；

  • 方法体：方法内部的一些语句。当方法返回值为 void时，可以省略return语句。

    3. 分类

    根据方法是否带有参数、是否有返回值，可以分为 4 类：

  • 无参无返回值方法

  • 无参带返回值方法
  • 带参数无返回值方法
  • 带参数带返回值方法

    3.1 无参无返回值方法

    无参无返回值方法，即参数列表为空，返回值为void的方法。例如，我们经常需要输出一段内容。可以将输出语句封装到方法中： ```java class MethodDemo1 { // 定义无参无返回值方法 public void printText() {
    1.   // 三条输出语句
    2.   System.out.println("你好新同学");
    3.   System.out.println("Java是就业前景最好的语言");
    } }
  1. 上面代码，在类MethodDemo1中定义了一个方法printText，其中有一些打印语句。那么如何调用这个方法，让其执行呢？<br />对于**非静态方法**（即非static关键字修饰的方法），首先要使用new关键字实例化类，生成一个对象，再通过对象名.方法名()的方式去调动方法。<br />如下是 MethodDemo1 类方法调用的实例：
  2. ```java
  3. class MethodDemo1 {
  4.     // 定义无参无返回值方法
  5.     public void printText() {
  6.         // 三条输出语句
  7.         System.out.println("你好新同学");
  8.         System.out.println("Java是就业前景最好的语言");
  9.     }
  11.     public static void main(String[] args) {
  12.         // 实例化MethodDemo1类
  13.         MethodDemo1 methodDemo1 = new MethodDemo1();
  14.         // 调用printText方法
  15.         methodDemo1.printText();
  16.     }    
  17. }
Tips：由于我们还没有学习面向对象，此处对于对象的实例化，先记住这种固定写法即可。本节的学习重点在于如何定义方法和调用方法。

3.2 无参带返回值方法

无参带返回值方法，即参数列表为空，返回值不为void的方法，方法体内部要使用return语句返回其声明的返回类型。
我们来自定义一个返回Hello World!字符串的方法：

  1. class MethodDemo2 {
  2.       // 定义无参带返回值方法
  3.       public String getHelloStr() {
  4.         // 初始化变量str
  5.           String str = "Hello World";
  6.           // 返回str
  7.           return str;
  8.     }
  10.       public static void main(String[] args) {
  11.           // 实例化MethodDemo2
  12.           MethodDemo2 methodDemo2 = new MethodDemo2();
  13.           // 调用getStr方法，并且使用result变量接收返回值
  14.           String result = methodDemo2.getHelloStr();
  15.           // 打印返回值
  16.           System.out.println(result);
  17.     }
  18. }

3.3 带参数无返回值方法

带参数无返回值方法，即带有参数列表，返回值为void的方法。
参数列表可能有一个或多个参数，多个参数使用逗号(,)隔开。定义方式为：DataType 参数名1, DataType 参数名2，DateType 为参数的类型。
下面是一个根据长和宽求长方形面积的方法实例：

  1. class MethodDemo3 {
  2.       // 定义带参数无返回值方法
  3.       public void printArea(float a, float b) {  // 此处的 a,b 为参数变量
  4.         float result = a * b;
  5.           System.out.println( "长方形面积为：" + result);
  6.     }
  8.       public static void main(String[] args) {
  9.           // 实例化MethodDemo3
  10.           MethodDemo3 methodDemo3 = new MethodDemo3();
  11.           // 初始化两个变量
  12.           float width = 12.3f;
  13.           float height = 20f;
  14.           // 调用printArea方法，并将 width、height变量作为参数传入
  15.           methodDemo3.printArea(width, height);
  16.           // 也可不提前初始化变量，直接传入浮点型字面量作为参数。
  17.           methodDemo3.printArea(10.2f, 2.5f);
  18.     }
  19. }

在调用带参数方法时，有两种传参方式：

  1. 先初始化变量，再将变量传递给方法： ```java float a = 12.3f; float b = 20f; methodDemo3.printArea(a, b);
  2. 2. 直接传入对应类型字面量：
  3. ```java
  4. methodDemo3.printArea(10.2f, 2.5f);

当调用方把参数传递给方法时，调用时传递的值会按参数位置一一绑定，这也比较符合我们正常的思维逻辑。因此，对于有多个参数的方法，一定要注意每个参数的位置。

3.4 带参数带返回值方法

带参带返回值方法，即带有参数列表，返回值不为void的方法。
下面我们来看一个实例，求从1到n的平方和：

  1. class MethodDemo4 {
  2.     // 定义带参数带返回值方法
  3.     public int getSumOfSquares(int n) {
  4.         int sum = 0;
  5.         for (int i = 1; i <=n; i++) {
  6.               // 求i的平方，并加和赋值给sum
  7.             sum += i * i;
  8.         }
  9.           // 返回计算结果
  10.         return sum;
  11.     }
  13.     public static void main(String[] args) {
  14.         // 实例化MethodDemo4
  15.         MethodDemo4 methodDemo4 = new MethodDemo4();
  16.           // 调用对象下getSumOfSquares方法，并用sumOfSquares变量接收返回结果
  17.         int sumOfSquares = methodDemo4.getSumOfSquares(5);
  18.         System.out.println("1到5的累加平方和为：" + sumOfSquares);
  19.     }
  20. }

我们也可以不定义变量接收返回结果，直接打印方法调用语句：

  1. System.out.println（"1到5的累加平方和为：" + methodDemo4.getSumOfSquares(5)）;

上面有参方法的例子，参数都是简单的基本数据类型，当参数为数组时，我们再来看一个实例：

  1. class MethodDemo5 {
  3.     /**
  4.      * 查找数组中元素是否包含指定元素
  5.      * @param arr 待查找数组
  6.      * @param element 所查找的元素
  7.      * @return boolean 查找结果,true包含; false不包含
  8.      */
  9.     public boolean contains(int[] arr, int element) {
  10.           // 定义返回结果，默认为false，即未找到element元素
  11.         boolean result = false;
  12.         for (int value : arr) {
  13.             if (value == element) {
  14.                   // 找到了element元素，将变量更新为true，并跳出循环
  15.                 result = true;
  16.                 break;
  17.             }
  18.         }
  19.         // 返回计算结果
  20.         return result;
  21.     }
  23.     public static void main(String[] args) {
  24.         // 实例化MethodDemo5
  25.         MethodDemo5 methodDemo5 = new MethodDemo5();
  26.         // 初始化一个数组
  27.         int[] intArray = {1, 3, 5, 6, 7, 9};
  28.         // 初始化待查找元素变量
  29.         int element = 10;
  30.         // 调用contains方法，并接收返回结果
  31.         boolean contains = methodDemo5.contains(intArray, element);
  32.         // 根据返回结果，输出内容
  33.         if (contains) {
  34.             System.out.println("数组intArray中包含元素" + element);
  35.         } else {
  36.             System.out.println("数组intArray中不包含元素" + element);
  37.         }
  38.     }
  39. }

代码解析：
上述代码定义了一个查找数组中是否包含指定元素的方法，它将数组和指定元素作为方法参数，并且返回了一个布尔型的结果，方法体内部首先声明了一个待返回的布尔变量，默认为false，然后对数组参数进行迭代，只要找到与元素参数相同的元素，即更新返回变量为true，跳出循环；如果数组迭代完成后依旧未找到指定的元素，那么待返回变量依然是false，最后返回这个变量。在方法调用时，以一个布尔变量来接收结果，后续代码根据这个布尔变量做了逻辑判断，以执行不同的语句块。

4. 方法传值

调用方和方法之间有参数的传递时，要注意方法传值问题。

4.1 基本类型的传值

基本类型参数的传递，是调用方值的复制。双方各自的后续修改，互不影响。简单来讲，方法内部对参数变量的任何操作，都不会影响到方法外部的变量。
我们看一个实例：

  1. class Car {
  2.     public void speedUp(int speed) {
  3.         System.out.println("小汽车加速前，速度为：" + speed);
  4.         speed ++;
  5.         System.out.println("小汽车加速后，速度为：" + speed);
  6.     }
  8.     public static void main(String[] args) {
  9.         // 定义小汽车初始速度变量
  10.         int speed = 10;
  11.         // 实例化Car类，创建一个car对象
  12.         Car car = new Car();
  13.         // 调用car对象下的speed方法
  14.         car.speedUp(speed);
  15.         // 打印调用方法后速度参数的值
  16.         System.out.println("调用speedUp方法后，调用方的speed参数为：" + speed);
  17.     }
  18. }

我们根据输出的结果验证了以上给出的结论。整型参数speed是一个基本数据类型，在speedUp方法内部进行了自增，但主方法中的speed变量的值并不会受到其影响。

4.2 引用类型的传值

引用类型参数的传递，调用方的变量，和接收方的参数变量，地址指向的是同一个对象。双方任意一方对这个对象的修改，都会影响对方。
我们来看一个实例：

  1. class NBATeam {
  2.     // 替换第一个球员方法
  3.     public void replaceFirstPlayer(String[] players, String playerName) {
  4.         // 替换第一个球员
  5.         System.out.println("将第一个球员替换：");
  6.         players[0] = playerName;
  7.     }
  9.     public static void main(String[] args) {
  10.         String[] players = {"詹姆斯", "科比", "杜兰特", "乔丹"};
  12.         System.out.println("球队中现有球员：");
  13.         for (String player : players) {
  14.             System.out.print(player + "\t");
  15.         }
  16.         System.out.println();
  18.         // 创建team对象并调用其替换球员方法
  19.         NBATeam team = new NBATeam();
  20.         team.replaceFirstPlayer(players, "皮蓬");
  22.         System.out.println("替换后球员：");
  23.         for (String player : players) {
  24.             System.out.print(player + "\t");
  25.         }
  26.     }
  27. }

由运行结果可见：方法replaceFirstPlayer的参数players是数组类型，也就是引用类型。当我们在方法内部对players进行操作，其方法外部（即主方法中）的players变量也受到了影响。不只是数组，对象也是引用类型，其参数传递同样遵循以上结论。我们在日常的编码中，请注意区分基本类型和引用类型的方法传值区别。

5. 可变参数

null我们可以使用可变参数列表声明方法的参数。可变参数列表的语法：

  1. 参数类型... 参数名

我们可以结合可变参数来实现一个求和方法sum，请阅读下面实例：

  1. class VariableParameter {
  2.     public void sum(int... n) {
  3.         int sum = 0;
  4.           // 可以对可变参数进行迭代
  5.         for (int i: n) {
  6.             sum = sum + i;
  7.         }
  8.         System.out.println("sum=" + sum);
  9.     }
  11.     public static void main(String[] args) {
  12.         // 创建对象
  13.         VariableParameter variableParameter = new VariableParameter();
  14.         // 调用方法，传递一个参数
  15.         variableParameter.sum(1);
  16.         // 调用方法，传递两个参数
  17.         variableParameter.sum(2, 3);
  18.         // 调用方法，传递三个参数
  19.         variableParameter.sum(5, 6, 7);
  20.     }
  21. }

上述实例中，在主方法中给sum方法传参时，可选择一个或多个参数传递。方法体内对可变参数n进行迭代，也可以将可变参数n改为数组：int[] n，得到的效果是相同的。
当方法的参数列表有两个或两个以上参数时，可变参数一定要放在最后，请查看如下实例：

  1. public void search(int element, int... elements) {
  2.     boolean existed  = false;
  3.     for (int e: elements) {
  4.         if (e == element) {
  5.             existed = true;
  6.             break;
  7.         }
  8.     }
  9.     if (existed) {
  10.         System.out.println("找到元素：" + element);
  11.     } else {
  12.         System.out.println("未找到元素：" + element);
  13.     }
  14. }

另外，也可以将数组传递给可变参数列表，例如，在主方法中调用上面的search方法：

  1. public class VariableParameter1 {
  2.     public void search(int element, int... elements) {
  3.         boolean existed  = false;
  4.         for (int e: elements) {
  5.             if (e == element) {
  6.                 existed = true;
  7.                 break;
  8.             }
  9.         }
  10.         if (existed) {
  11.             System.out.println("找到元素：" + element);
  12.         } else {
  13.             System.out.println("未找到元素：" + element);
  14.         }
  15.     }
  17.     public static void main(String[] args) {
  18.         // 创建对象
  19.         VariableParameter1 obj = new VariableParameter1();
  20.         // 调用方法
  21.         obj.search(2, 1,2,3,4);
  22.         // 定义数组参数
  23.         int[] arr = {1,2,3,4};
  24.         // 将数组传递给可变参数列表
  25.         obj.search(2, arr);
  26.     }
  27. }

上述两种传参方式都是合法的。

6. 方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java 编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数或参数的顺序不同的方法。

6.1 自定义方法的重载

例如，在Student类中，有多个study方法：

  1. public class Student {
  2.     public void study() {
  3.         System.out.println("同学真好学!");
  4.     }
  6.     public void study(String name) {
  7.         System.out.println(name + "同学真好学!");
  8.     }
  10.     public void study(String name, int age) {
  11.         System.out.println(name + "同学真好学!" + "他今年" + age + "岁了");
  12.     }
  14.     public static void main(String[] args) {
  15.         // 实例化学生对象
  16.         Student student = new Student();
  17.         // 调用无参数方法
  18.         student.study();
  19.         // 调用单参数方法
  20.         student.study("Colorful");
  21.         // 调用双参数方法
  22.         student.study("小欧", 20);
  23.     }
  24. }

代码中的三个study都是重载方法。通常来说，方法重载的返回值类型都是相同的。
如果我们在Student类中再增加一个方法：

  1. public String study() {
  2.     return "学习Java语言";
  3. }

注意，上述的方法不是重载方法，因为我们已经在Student类中定义了无参方法study。
判断一个方法是否是重载方法的原则：方法名相同，参数类型或参数个数不同。

6.2 JDK 中的方法重载

Java语言本身的类也定义了很多方法重载的例子，例如String类的substring方法，用于字符串截取：

  1. public String substring(int beginIndex);               
  2. // 截取并返回从beginIndex位置到结束位置的字符串
  4. public String substring(int beginIndex. int endIndex); 
  5. // 截取并返回从beginIndex位置到endIndex-1位置的字符串

如下为实际应用的实例：

  1. String hello = "Hello, Java";
  2. String substring1 = hello.substring(7);
  3. String substring2 = hello.substring(0, 5);
  4. System.out.println(substring1);
  5. System.out.println(substring2);

7. 小结

本小节我们学习了 Java 方法，内容较多，我们一起来回顾一下所学的内容：
理解方法是一个命名语句块很重要。方法提高了代码的复用性，优质的方法提供者（如 JDK 中的方法），提高了调用者的开发效率。
定义方法时，要理解返回类型、方法名、参数列表和方法体的概念。通过方法的名称 + 括号运算符()可以调用该方法。
方法内部遇到return时返回，返回类型为void表示不返回任何值。
对于方法传值问题，基本数据类型传值：方法中对参数的修改，不会影响到方法调用方传递的变量值；引用数据类型传值：方法中对参数的修改，会影响到方法调用方传递的对象。
可变参数通常用于参数数量是不确定的、可变化的方法。方法重载提高了程序的兼容性和易用性，为方法提供了多种可能性。