200-Java语言基础-Java编程入门-005 | Java方法定义及使用

一、方法概述和格式说明

为什么要用方法：

• 提高代码的复用性

什么是方法：

• 完成特定功能的代码块

方法的格式：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {

    方法体语句;

    return 返回值;

}

方法的格式说明：

• 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
• 返回值类型：就是功能结果的数据类型。
• 方法名：符合命名规则即可。方便我们的调用。
• 参数：
• 实际参数：就是实际参与运算的。
• 形式参数；就是方法定义上的，用于接收实际参数的。
• 参数类型：就是参数的数据类型
• 参数名：就是变量名
• 方法体语句：就是完成功能的代码。
• return：结束方法的。
• 返回值：就是功能的结果，由return带给调用者。

 

二、方法之求和案例及其调用

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:如何写一个方法
 5        * 1,明确返回值类型
 6        * 2,明确参数列表
 7      * B:案例演示
 8        * 需求：求两个数据之和的案例
 9      * C:方法调用图解
10      */
11     System.out.println("两数之和为：" + sum(10, 20));
12   }
13   /*
14    * 求两个整数的和
15    */
16   public static int sum(int i, int j) {
17     return i + j;
18   }
19 }

方法的注意事项

• 方法调用(有具体返回值)
• 单独调用,一般来说没有意义，所以不推荐。
• 输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
• 赋值调用,推荐方案。
• 方法不调用不执行
• 方法与方法是平级关系，不能嵌套定义
• 方法定义的时候参数之间用逗号隔开
• 方法调用的时候不用在传递数据类型
• 如果方法有明确的返回值，一定要有return带回一个值

/*

* A:案例演示

  * 需求：根据键盘录入的行数和列数，在控制台输出星形

* B:方法调用：

  * 单独调用

  * 输出调用(错误)

  * 赋值调用(错误)

*/

 1 import java.util.Scanner;
 2 class JavaDemo {
 3   public static void main(String[] args) {
 4     Scanner sc = new Scanner(System.in);      //创建键盘录入对象
 5     System.out.println("请输入行数:");
 6     int row = sc.nextInt();             //将键盘录入的行数存储在row中
 7     System.out.println("请输入列数:");
 8     int column = sc.nextInt();            //将键盘录入的列数存储在column中
 9
10     //System.out.println(print(row,column));    //错误: 此处不允许使用 '空' 类型,返回值是void的方法不能输出调用
11     //返回值是void的方法只能单独调用
12     print(row,column);
13   }
14   /*
15   在控制台输出矩形星形
16   1,明确返回值类型,经分析没有具体的返回值类型,void
17   2,明确参数列表int a,int b
18   */
19   public static void print(int a,int b) {
20     for (int i = 1;i <= a ;i++ ) {          //行数
21       for (int j = 1;j <= b ;j++ ) {        //列数
22         System.out.print("*");
23       }
24       System.out.println();
25     }
26     //return ;                    //如果返回值类型是void,return可以省略,即使省略系统也会默认给加上,形式是return;
27   }
28 }
29
30 /*
31 * A:案例演示
32   * 需求：根据键盘录入的数据输出对应的乘法表
33 */
34 import java.util.Scanner;
35 class JavaDemo {
36   public static void main(String[] args) {
37     Scanner sc = new Scanner(System.in);      //创建键盘录入对象
38     System.out.println("请输入一个整数，范围在1~9之间");
39     int num = sc.nextInt();             //将键盘录入的行数存储在num中
40     print99(num);
41   }
42   /*
43   打印99乘法表
44   1,返回值类型为空void
45   2,明确参数列表int a
46   */
47   public static void print99(int a) {
48     for (int i = 1;i <= a ;i++ ) {          //行数
49       for (int j = 1;j <= i ;j++ ) {        //列数
50         System.out.print(j + "*" + i + " = " + (i * j) + "\t");
51       }
52       System.out.println();
53     }
54     //return ;                    //如果返回值类型是void,return可以省略,即使省略系统也会默认给加上,形式是return;
55   }
56 }

三、方法重载概述和基本使用

方法重载：

• 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
• 参数列表不同：
• 参数个数不同
• 参数类型不同：
• 参数的顺序不同(算重载,但是在开发中不用)

/*

* 重载：方法名相同，参数列表不同，与返回值类型无关

* 重载的分类：

  * 参数个数不同

  * 参数类型不同：

  *   顺序不同

*/

 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     double sum = add(10.3, 29);
 4     System.out.println("两数之和：" + sum);
 5     int sum1 = add(10, 29, 22);
 6     System.out.println("三数之和：" + sum1);
 7
 8     double sum3 = add(10.11, 29);
 9     System.out.println("两个小数之和：" + sum3);
10   }
11   /*
12     求两个数之和
13   1,返回值类型为int
14   2,明确参数列表int a， int b
15   */
16   public static double add(int a, double b) {
17     return a + b;
18   }
19
20   /*
21    求三个数之和
22   1,返回值类型为int
23   2,明确参数列表int a， int b，int c
24   */
25   public static int add(int a, int b, int c) {
26     return a + b + c;
27   }
28
29   /*
30     求两个小数之和
31   1,返回值类型为double
32   2,明确参数列表double a， double b
33   */
34   public static double add(double a, int b) {
35     return a + b;
36   }
37 }

1 public static 返回值类型 方法名称([参数类型 变量.....]) {
2     // 该方法要执行的代码
3     [return[返回值];]
4 }

    对于返回值而言就可以使用Java中定义的数据类型（基本数据类型、引用数据类型），在方法之中可以进行返回数据的处理；如果要返回数据则可以使用return来描述，return所返回的数据类型与方法的返回值类型相同，如果不返回数据，则该方法可以使用void进行申明

    关于方法名称与变量的定义命名要求：

• 在进行方法名称定义的要求第一个单词的字母小写，而后每个单词的首字母大写
• 在进行变量名称定义的要求第一个单词的字母小写，而后每个单词的首字母大写

 1 // 定义一个无参无返回值的方法
 2 public class JavaDemo {
 3   public static void main(String[] args) {
 4     printMessage( );
 5     printMessage( );
 6   }
 7   public static void printMessage( ) {
 8     System.out.println("*********************");
 9     System.out.println("***** welcome to *****");
10     System.out.println("*********************");
11   }
12 }
13     方法的本质就是方便使用者进行重复调用，并且所有的程序一定都是通过主方法开始执行的
14 // 定义一个有参数有返回值的方法
15 public class JavaDemo {
16   public static void main(String[] args) {
17     System.out.println(login("admin"));
18     System.out.println(login("123"));
19     System.out.println(login("1234"));
20   }
21   public static String login(String user) {
22     if (user == "admin") {
23       return "输入用户名正确：" + user;
24     } else if (user == "123") {
25       return "输入密码正确：" + user;
26     } else {
27       return "用户名密码错误：" + user;
28     }
29   }
30 }
31     方法定义的时候，如果方法的返回值类型为void，可以利用rerun来结束调用
32 public class JavaDemo {
33   public static void main(String[] args) {
34     getMessage(3);
35     getMessage(-3);
36   }
37   public static void getMessage( int print) {
38     if (print < 0) {
39       return;
40     }
41     for (int i = 0; i <= 3; i++) {
42       System.out.println("打印：" + i + "次");
43     }
44   }
45 }

四、方法重载

    方法重载的定义：当方法名称相同，参数类型或个数不同的时候就称为方法重载。

 1 // 定义该方法可以接收两个int变量，三个int变量、两个double变量的加法处理
 2 // 采用方法重载定义
 3 public class JavaDemo {
 4   public static void main(String[] args) {
 5     int resultA = sum(10, 24);
 6     int resultB = sum(10, 20,30);
 7     double resultC = sum(11.1, 113.2);
 8     System.out.println("计算结果为：" + resultA);
 9     System.out.println("计算结果为：" + resultB);
10     System.out.println("计算结果为：" + resultC);
11   }
12
13   public static int sum(int x, int y) {
14     return x + y;
15   }
16
17   public static int sum(int x, int y, int z) {
18     return x + y + z;
19   }
20
21   public static double sum(double x, double y) {
22     return x + y;
23   }
24 }

    同一个方法名称可以根据调用时传递的不同参数的类型或个数实现不同方法体的调用，这就实现了方法重载的定义

    方法的重载与方法的返回值类型没有任何的关系，它只跟参数有关系

五、可变参数（不定项参数）

• JDK1.5，java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后面加一个省略号（...）
• 一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数必须在它之前声明

 1 package com.sujian.operator;
 2 public class JavaDemo {
 3   public static void main(String[] args) {
 4     // 调用可变参数方法
 5     printMax(11, 22, 33, 44, 55);
 6     printMax();
 7   }
 8   public static void printMax(int... nums) {
 9     if (nums.length == 0) {
10       System.out.println("参数空");
11       return;
12     }
13     int  result = nums[0];
14     // 排序
15     for (int i = 0; i < nums.length; i++) {
16       if (nums[i] > nums[0]) {
17         result = nums[i];
18       }
19     }
20     System.out.println("最大值是：" + result);
21   }
22 }

六、方法的递归调用

    方法的递归调用指的是一个方法自己调用自己的情况，使用方法递归调用的时候一般需要考虑如下几点：

• 一定要设置方法递归调用的结束条件；
• 每一次调用的过程之中一定要修改传递的参数条件

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3    System.out.println(sum(100));
 4   }
 5
 6   public static int sum(int num) {
 7     if (num == 1) {
 8       return 1;
 9     }
10     return num + sum(num - 1); // 递归调用
11   }
12 }
13 对以上代码进行分析处理：
14 【第1次执行sum()、主方法执行】return 100 + sum(99);
15 【第2次执行sum()、sum()递归调用】return 99 + sum(98);
16 ... ... ... ....
17 【第99次执行sum()、sum()递归调用】return 2 + sum(1);
18 【第100次执行sum()、sum()递归调用】return 1;
19 整体形式为：return 100 + 99 + 98 + .... .... + 2 + 1;
20
21 package com.sujian.method;
22 public class JavaDemo {
23   public static void main(String[] args) {
24     System.out.println(f(5));
25   }
26   /**
27    * 阶乘递归调用
28    * @param n
29    * @return
30    */
31   public static int f(int n) {
32     if (n == 1) {
33       return 1;
34     } else {
35       return n * f(n - 1);
36     }
37   }
38 }