JavaSE 第三章 流程控制语句&方法定义 笔记

3.1 语句

程序的功能是由语句来完成的，语句分为单语句和复合语句。

单语句又分为：
（1）空语句，什么功能都没有。它就是单独的一个分号；（ 需要避免 ）
（2）表达式语句，就是表达式后面加分号;

• new表达式;
• 方法调用表达式;
• 计算表达式中的赋值表达式、自增自减表达式

复合语句分为：
（1）分支语句：if...else，switch...case
（2）循环语句：for,while,do...while
（3）跳转语句：break,continue,return,throw
（4）try语句：try...catch...finally
（5）同步语句：synchronized

3.2 顺序结构

顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

代码示例：

public class StatementTest {
    public static void main(String[] args) {
        int x = 2 ;
        int y = 4 ;
        x ++ ;
        y -- ;
        System.out.println("x=" + x);
        System.out.println("y=" + y);
    }
}

3.3 输入输出语句

3.3.1 常见的输出语句

• 换行输出语句：输出内容后进行换行

System.out.println("输出内容") ;

• 不换行输出语句：输出内容后后不换行

System.out.print(输出内容);

public class PrintlnAndPrintTest {
    public static void main(String[] args) {
        String str = "万般皆下品，唯有读书高。" ;
        int i = 21 ;
        System.out.println(str);
        System.out.println(i);
        System.out.println();
        System.out.print(str);
        System.out.print(i);
    }
}

换行输出语句，括号内可以什么都不写，只做换行处理
不换行输出语句，括号内什么都不写的话，编译报错

3.3.2 输入语句

• 键盘输入代码的四个步骤：

• 导包
  • 格式：import java.util.Scanner;
  • 位置：在class上面
• 创建键盘录入对象
  • 格式：Scanner scan = new Scanner(System.in);
  • new 关键字，创建一个引用数据类型的对象
• 通过对象获取数据
  • 格式：int x = scan.nextInt();
• 释放资源
  • 格式：scan.close();

各种类型的数据输入

import java.util.Scanner ;  // 导包

public class ScannerTest {
    public static void main(String[] args) {
        // 创建输入对象
        Scanner scan = new Scanner(System.in) ;

        System.out.print("请输入一个byte类型的整数：");
        byte b = scan.nextByte() ;

        System.out.print("请输入一个short类型的整数：");
        short s = scan.nextShort() ;

        System.out.print("请输入一个int类型的整数：");
        int i = scan.nextInt() ;

        System.out.print("请输入一个long类型的整数：");
        long l = scan.nextLong() ;

        System.out.print("请输入一个float类型的浮点数：");
        float f = scan.nextFloat() ;

        System.out.print("请输入一个double类型的浮点数：");
        double d = scan.nextDouble() ;

        System.out.print("请输入一个boolean类型的值：");
        boolean b1 = scan.nextBoolean() ;

        System.out.print("请输入一个字符串：");
        String str1 = scan.next() ;
        System.out.print("请输入一个字符串：");
        String str2 = scan.nextLine() ;
		
        scan.close();
    }
}

• next()与nextLine()

next()：是不可以录入空格的。它会自动忽略有效字符之前的空格，当遇到有效字符后开始录入，在遇到空格/tab键时停止录入，只录入空格前面的东西，空格后面的东西（包括分隔的空格都会保留在缓存区域），遇到回车键会结束录入

nextLine()：可以录入空格。录入遇到回车键之前的所有字符，回车键表示结束录入

示例

import java.util.Scanner ;  // 导包

public class ScannerTest {
    public static void main(String[] args) {
        // 创建输入对象
        Scanner scan = new Scanner(System.in) ;

        System.out.print("nextLine():请输入一个字符串：");
        String str1 = scan.nextLine() ;
        System.out.print("next():请输入一个字符串：");
        String str2 = scan.next() ;

        System.out.println("nextLine() : " + str1);
        System.out.println("next() : " + str2);

        scan.close();
    }
}

3.4 分支语句

3.4.1单分支条件判断：if

• if语句第一种格式：if

if(条件表达式) {
	语句体	// 关系表达式返回值为true才会执行
}

执行流程：

1. 首先判断条件表达式看其结果是true还是false

2. 如果是true，则执行语句体

3. 如果是false就不执行语句体

案例：输入考试成绩，成绩大于90分奖励100元，然后结束；成绩不大于90，直接结束

import java.util.Scanner;

public class IfTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in) ;
        System.out.print("考试分数：");
        int i = scanner.nextInt();

        if(i >= 90) {
            System.out.println("奖励100元钱");
        }

        System.out.println("结束");
        scanner.close();
    }
}

3.4.2 双分支条件判断：if…else

• if语句的第二种格式：if...else

if(关系表达式) { 
  	语句体1;// 关系表达式返回值为true 执行语句体1
}else {
  	语句体2;// 关系表达式返回值为false 执行语句体2
}

* 执行流程

	1. 首先判断关系表达式看其结果是true还是false

	2. 如果是true就执行语句体1

	3. 如果是false就执行语句体2

案例：从键盘输入一个数，判断其是奇数还是偶数

import java.util.Scanner;

public class IfElseTest {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in) ;
        System.out.print("请输入一个数字：");
        int i = s.nextInt();

        if(i % 2 == 0) {
            System.out.println(i + "是偶数");
        } else {
            System.out.println(i + "是奇数");
        }
        System.out.println("结束");
      	
      	s.close();
    }
}

3.4.3 多分支条件判断：if…else if

• if语句第三种格式： if...else if ...else

if (判断条件1) {
  	执行语句1;
} else if (判断条件2) {
  	执行语句2;
}
...
}else if (判断条件n) {
 	执行语句n;
} else {
  	执行语句n+1;// 以上条件全不满足,则执行else语句
}

* 执行流程

	1. 首先判断关系表达式1看其结果是true还是false

	2. 如果是true就执行语句体1，然后结束当前多分支

	3. 如果是false就继续判断关系表达式2看其结果是true还是false

	4. 如果是true就执行语句体2，然后结束当前多分支

	5. 如果是false就继续判断关系表达式…看其结果是true还是false

	6. …

	7. 如果没有任何关系表达式为true，就执行语句体n+1，然后结束当前多分支。

案例：通过指定考试成绩，判断学生等级，成绩范围[0,100]

• 90-100 优秀

• 80-89 好

• 70-79 良

• 60-69 及格

• 60以下 不及格

import java.util.Scanner;

public class IfElseIfTest {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in) ;

        System.out.print("请输入考试成绩：");
        int score = s.nextInt();

        if(score < 0 || score > 100) {
            System.out.println("成绩错误");
        } else if(score >= 90 && score <= 100) {
            System.out.println("你的成绩属于A");
        }else if(score>=80 && score<90){
            System.out.println("你的成绩属于B");
        }else if(score>=70 && score<80){
            System.out.println("你的成绩属于C");
        }else if(score>=60 && score<70){
            System.out.println("你的成绩属于D");
        }else {
            System.out.println("你的成绩属于E");
        }
        s.close();
        System.out.println("结束");
    }
}

import java.util.Scanner;

public class IfElseIfTest {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in) ;

        System.out.print("请输入考试成绩：");
        int score = s.nextInt();

        if(score < 0 || score > 100) {
            System.out.println("成绩错误");
        } else if(score >= 90 && score <= 100) {
            System.out.println("你的成绩属于A");
        }else if(score>=80 && score<90){
            System.out.println("你的成绩属于B");
        }else if(score>=70 && score<80){
            System.out.println("你的成绩属于C");
        }else if(score>=60 && score<70){
            System.out.println("你的成绩属于D");
        }else {
            System.out.println("你的成绩属于E");
        }
        s.close();
        System.out.println("结束");
    }
}

上面的两种方式都能达到指定的效果，第一种方式各个条件之间没有交集，各个顺序可以调换（除else语句），第二种方式各个范围存在交集，顺序不能调换，范围小的在上，范围大的在下

3.4.4 if…else嵌套

在if的语句块中，或者是在else语句块中， 又包含了另外一个条件判断（可以是单分支、双分支、多分支）
执行的特点：
（1）如果是嵌套在if语句块中的 只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的 只有当外部的if条件不满足，进入else后，才会去判断内部的条件

案例：获取三个数据中的最大值

public class IfIfTest {
    public static void main(String[] args) {
        int a = 10 ;
        int b = 20 ;
        int c = 30 ;

        if(a > b) {
            if(a > c) {
                System.out.println(a + "是最大值");
            } else {
                System.out.println(c + "是最大值");
            }
        } else {
            if(b > c) {
                System.out.println(b + "是最大值");
            } else {
                System.out.println(c + "是最大值");
            }
        }
    }
}

3.4.5 switch…case多分支选择结构

• 语法格式：

[]中括号代表可省略

switch(表达式){
    case 常量值1:
        语句块1;
        [break;]// 遇到break,结束当前case语句 
    case 常量值2:
        语句块2;
        [break;]   
    ...
   [default:
        语句块n+1;//如果上述的常量值与case均不匹配，则执行本代码
        [break;]
   ]
}

switch表达式的取值：byte,short,char,int
JDK5以后可以是枚举
JDK7以后可以是String

• switch表示这是switch语句
  表达式的取值：byte,short,char,int
  JDK5以后可以是枚举
  JDK7以后可以是String
• case后面跟的是要和表达式进行比较的值
• 语句体部分可以是一条或多条语句
• break表示中断，结束的意思，可以结束switch语句
• default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

执行过程：

先计算表达式的值，
然后和case后面的匹配，
如果有就执行对应的语句，否则执行default控制的语句
直到遇到break或者右大括号｝，结束switch语句。

• 案例：从键盘输入星期的整数值，输出星期的英文单词

import java.util.Scanner;

public class SwitchTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in) ;
        System.out.print("请输入星期值：");
        int weekday = scanner.nextInt();

        // switch语句
        switch (weekday) {
            case 1 :
                System.out.println("Monday");
                break;
            case 2 :
                System.out.println("Tuesday");
                break;
            case 3 :
                System.out.println("Wednesday");
                break ;
            case 4 :
                System.out.println("Thursday");
                break ;
            case 5 :
                System.out.println("Friday");
                break;
            case 6 :
                System.out.println("Saturday");
                break;
            case 7 :
                System.out.println("Sunday");
                break;
            default :
                System.out.println("输入错误");
                break;
        }
        scanner.close();
    }
}

• case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，switch语句执行终止。

示例：

import java.util.Scanner;

public class SwitchTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in) ;
        System.out.print("请输入星期值：");
        int weekday = scanner.nextInt();

        // switch语句
        switch (weekday) {
            case 1 :
                System.out.println("Monday");
            case 2 :
                System.out.println("Tuesday");
            case 3 :
                System.out.println("Wednesday");
            case 4 :
                System.out.println("Thursday");
            case 5 :
                System.out.println("Friday");
            case 6 :
                System.out.println("Saturday");
            case 7 :
                System.out.println("Sunday");
            default :
                System.out.println("输入错误");
        }
        scanner.close();
    }
}

• 利用case的穿透性

案例：根据指定的月份输出对应的季节

import java.util.Scanner;

public class SwitchTest1 {
    public static void main(String[] args) {
        /*
        根据指定的月份输出对应的季节
        3、4、5  春季
        6、7、8  夏季
        9、10、11 秋季
        12、1、2  冬季
        */

        Scanner sc = new Scanner(System.in) ;
        System.out.print("请输入月份：");
        int mouth = sc.nextInt();

        switch (mouth) {
            case 1 :
                System.out.println(mouth + "月份是冬季");
                break;
            case 2 :
                System.out.println(mouth + "月份是冬季");
                break;
            case 3 :
                System.out.println(mouth + "月份是春季");
                break;
            case 4 :
                System.out.println(mouth + "月份是春季");
                break;
            case 5 :
                System.out.println(mouth + "月份是春季");
                break;
            case 6 :
                System.out.println(mouth + "月份是夏季");
                break;
            case 7 :
                System.out.println(mouth + "月份是夏季");
                break;
            case 8 :
                System.out.println(mouth + "月份是夏季");
                break;
            case 9 :
                System.out.println(mouth + "月份是秋季");
                break;
            case 10 :
                System.out.println(mouth + "月份是秋季");
                break;
            case 11 :
                System.out.println(mouth + "月份是秋季");
                break;
            case 12 :
                System.out.println(mouth + "月份是冬季");
                break;
            default:
                System.out.println("月份有误");
                break;
        }
		sc.close();
    }
}

改进：

import java.util.Scanner;

public class SwitchTest1 {
    public static void main(String[] args) {
        /*
        根据指定的月份输出对应的季节
        3、4、5  春季
        6、7、8  夏季
        9、10、11 秋季
        12、1、2  冬季
        */

        Scanner sc = new Scanner(System.in) ;
        System.out.print("请输入月份：");
        int mouth = sc.nextInt();

        switch (mouth) {
            case 12 :
            case 1 :
            case 2 :
                System.out.println(mouth + "是冬季");
                break;
            case 3 :
            case 4 :
            case 5:
                System.out.println(mouth + "是春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println(mouth + "是夏季");
                break;
            case 9 :
            case 10 :
            case 11 :
                System.out.println(mouth + "是秋季");
                break;
            default:
                System.out.println("月份输入有误");
                break;
        }
        sc.close();
    }
}

* 选择结构switch语句的注意事项

1. case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的。

2. default可以省略。但是不建议省略。因为它的作用是对不正确的情况给出提示。除非判断的值是固定的。

3. break可以省略，但一般不建议。省略case会出现case穿透。一般不省略，根据需求判断是否需要省略

4. default的位置不一定要在最后，可以出现在switch语句任意位置。但是建议在最后。

5.switch语句的结束条件：

	* 遇到break

	* 执行到程序的末尾，即执行到switch的右大括号就结束了

if语句与switch语句比较

if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。

* switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。

* 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。当条件是区间范围的判断时，只能使用if语句。

* 另外，使用switch可以利用穿透性，同时执行多个分支，而if...else没有穿透性。

案例：用year、month、day分别存储今天的年、月、日值，然后输出今天是这一年的第几天。

public class Test1 {
    public static void main(String[] args) {
        /*
        用year、month、day分别存储今天的年、月、日值，
        然后输出今天是这一年的第几天。
         */
        int year = 2022 ;
        int mouth = 7 ;
        int day = 20 ;

        int days = 0 ;

        switch (mouth) {
            case 12 :
                days += 30 ; // 11月份满月的天数
            case 11 :
                days += 31 ;
            case 10 :
                days += 30 ;
            case 9 :
                days += 31 ;
            case 8 :
                days += 31 ;
            case 7 :
                days += 30 ;
            case 6 :
                days += 31 ;
            case 5 :
                days += 30 ;
            case 4 :
                days += 31 ;
            case 3 :
                if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                    days += 29 ;
                } else {
                    days += 28 ;
                }
            case 2 :
                days += 31 ;
            case 1 :
                days += day ;
        }

        System.out.println(year + "年的" + mouth + "月的第" + day + "天是该年的第" + days + "天");
    }
}

3.5 循环语句

• 循环语句

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要通过修改循环变量使得循环判断条件为false，从而结束循环，否则循环将一直执行下去，形成死循环。

循环语句的组成

    1.初始化语句：

		* 一条或者多条语句，这些语句完成一些初始化操作。

    2.判断条件语句：

		* 这是一个boolean 表达式，这个表达式能决定是否执行循环体。

	3. 循环体语句：


		* 这个部分是循环体语句，也就是我们要多次做的事情。

	4. 控制条件语句：

		* 这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

3.5.1 循环语句的分类

• for
• while
• do…while

3.5.2 循环结构for语句的格式和基本使用

• for循环语句格式：

for(初始化语句①; 循环条件语句②; 循环控制条件语句④){
	循环体语句③
}

注意：
（1）for(;;)中的两个；是不能多也不能少
（2）循环条件必须是boolean类型

执行流程：

第一步：执行初始化语句①，完成循环变量的初始化；

第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
- 如果是true，执行第三步；
- 如果是false，循环语句中止，循环不再执行。

第三步：执行循环体语句③

第四步：执行循环控制条件语句④，针对循环变量重新赋值

第五步：根据循环变量的新值，重新从第二步开始再执行一遍

• 案例：使用for循环输出10遍"HelloWorld"

public class ForTest {
    public static void main(String[] args) {
        for(int i = 0 ; i < 10 ; i ++) {
            System.out.println("HelloWorld");
        }
    }
}

• 案例：求1-100的累加和

public class ForTest {
    public static void main(String[] args) {
        int num = 0 ;
        for(int i = 1 ; i <= 100 ; i ++) {
            num += i ;
        }
        System.out.println("1-100的累加和为：" + num);
    }
}

• 案例：求100-999的水仙花数

水仙花数就是个位、十位、百位的三次方的和相加等于该数
如：153 = 111 + 555 + 333 = 1 + 125 + 27 = 153

public class ForTest {
    public static void main(String[] args) {
        
        // 求100-999之间的水仙花数
        int bits ;
        int ten ;
        int hundredth ;

        for (int i = 100 ; i <= 999 ; i ++) {
            bits = i % 10 ;
            ten = i / 10 % 10 ;
            hundredth = i / 100 ;

            if(bits * bits * bits + ten * ten * ten + hundredth * hundredth * hundredth == i) {
                System.out.println(i + "是水仙花数");
            }
        }
    }
}

3.5.3 循环结构while语句的格式和基本使用

• while循环语句基本格式：

while(①判断条件语句) {
	②循环体语句;
	控制条件语句;
}

// while()中的循环条件不能为空

执行流程：
第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；
	* 如果是true，执行第二步；
	* 如果是false，循环语句中止，循环不再执行。

第二步：执行循环体语句②；

第三步：循环体语句执行完后，然后重新从第一步开始再执行一遍

• 案例：在控制台输出数据1-10

public class WhileTest {
    public static void main(String[] args) {
        int i = 1 ;
        while (i <= 10) {
            System.out.println(i);
            i ++ ;
        }
    }
}

3.5.4 循环结构do…while语句的格式和基本使用

• 基本格式

do {
    循环体语句①；
} while (循环条件语句②)；

• 完整格式

初始化语句;
do {
	循环体语句;
	控制条件语句;
}while(判断条件语句);

注意：
（1）while(循环条件)中循环条件必须是boolean类型
（2）do{}while();最后有一个分号
（3）do...while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

执行流程
- 第一步：执行循环体语句①；

- 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
	如果是true，执行第三步；
	如果是false，循环语句终止，循环不再执行。
	
- 第三步：循环条件语句执行完后，重新从第一步开始再执行一遍

• 案例：输出1-10

public class DoWhileTest {
    public static void main(String[] args) {
        int i = 1 ;
        do {
            System.out.println(i);
            i ++ ;
        }while (i <= 10) ;
    }
}

3.5.5 循环结构三种循环语句的区别

* 从循环次数角度分析

	* do...while循环至少执行一次循环体语句

	* for和while循环先循环条件语句是否成立，然后决定是否执行循环体语句

* 如何选择

	* 遍历有明显的循环次数（范围）的需求，选择for循环

	* 遍历没有明显的循环次数（范围）的需求，循环while循环

	* 如果循环体语句块至少执行一次，可以考虑使用do...while循环

	* 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

3.5.6 循环结构之死循环

• 两种最简单的死循环格式

for(;;){...}
while(true){...}

• for的三种死循环

for(;;) {
    System.out.println(1);
}


for(;2>1;) {
    System.out.println(1);
}



for(int i = 0 ; i <= 10 ;) {
     System.out.println(1);
}

• while/do…while死循环

while (true) {
     System.out.println(1);
}


do {
   System.out.println(1);
}while (true) ;

3.5.6 循环嵌套

• 嵌套循环

两个for嵌套循环格式

for(初始化语句①; 循环条件语句②; 控制语句⑦) {
    for(初始化语句③; 循环条件语句④; 控制语句⑥) {
      	循环体语句⑤;
    }
}

• 案例：打印5行‘*’符拼成直角三角形

public class ForForTest {
    public static void main(String[] args) {
        for(int i = 1 ; i <= 5 ; i ++) {
            for(int j = 1 ; j <= i ; j ++) {
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

• 案例：输出99乘法表

public class ForForTest {
    public static void main(String[] args) {

        for(int i = 1 ; i <= 9 ; i ++) {
            for(int j = 1 ; j <= i ; j ++) {
                System.out.print(j + " * " + i + " = " + i * j + "\t");
            }
            System.out.println();
        }
    }
}

3.5.7 控制跳转语句 break

• break含义：退出、结束

• 使用场景
  • switch语句中
  • 循环语句中

• 案例：在for循环中使用，当第四次循环时结束

public class ForTest {
    public static void main(String[] args) {
        for (int i = 0 ; i < 10 ; i ++) {
            if(i == 4) {
                break;
            }
            System.out.println(i);
        }
    }
}

3.5.8 控制跳转语句 continue

• continue含义：退出本次循环，继续下次循环

案例：在for循环中跳出第四次循环

public class ForTest {
    public static void main(String[] args) {
        for (int i = 0 ; i < 10 ; i ++) {
            if(i == 4) {
                continue;
            }
            System.out.println(i);
        }
    }
}

3.5.8 控制跳转语句 return

• return

  • 返回(如果方法有返回值,结束的时候讲返回值传递给调用者)
  • 用于方法的结束

• return和break以及continue的区别?

  • return是结束方法
  • break是跳出循环
  • continue是终止本次循环继续下次循环

案例：

public class ForTest {
    public static void main(String[] args) {
        for (int i = 0 ; i < 10 ; i ++) {
            if(i == 4) {
                return;
            }
            System.out.println(i);
        }
        System.out.println("结束");
    }
}

3.6 方法的定义和使用

3.6.1 方法的作用

提高代码的复用性

3.6.2 什么是方法？

方法就是用来完成特定功能的代码块
方法也叫函数，是一组代码语句的封装，从而实现代码的重用，减少代码冗余。

3.6.3 方法的格式

没有参数的方法：

修饰符 返回值类型 方法名() {
	方法体语句;
}


有参数的方法：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2) {
	方法体语句;
    return 返回值;
}

• 方法声明的位置：方法必须声明在类体内方法体外，不能在一个方法中定义另外一个方法中。

3.6.4 方法的格式说明

* 修饰符：
    修饰符是可选的，当前所学的就只有public static public表示访问权限，static表示这个方法是静态的，其在类加载时将和类一起加载进内存。

* 返回值类型：
   -  没有返回值设置返回值类型位 void
   -  有返回值则设置返回值类型为 基本数据类型/引用数据类型

* 方法名
    方法名的命名规则：除第一个单词的首字母小写外，其余单纯首字母大写，驼峰命名法。做到见名知意

* 参数列表
    - 形式参数：在定义方法时方法名后面括号中声明的变量称为形式参数（形参），用于接收实际参数。
    - 实际参数：调用方法时方法名后面括号中传递的值/变量/表达式 称为实际参数（实参），就是实际参与方法运算的值。

一个方法无论是否有参数，声明和调用时括号 () 都不能丢弃，多个参数之间用逗号 , 隔开

• 参数类型：参数的数据类型

• 参数名：参数的变量名

• 方法体：为完成指定工能的代码块

• return：表示结束方法

• 返回值：返回方法执行后的结果，由return带个调用者

  • 如果被调用的的方法的返回值类型是void，没有返回值，不需要也不能处理和接收返回值结果。

  • 如果被调用的的方法的返回值类型不是void，有返回值

    • 返回结果可以作为赋值表达式的值
    • 返回结果可以作为计算表达式的一个操作数
    • 返回结果可以作为另一个方法调用的实参

  • 对于方法调用表达式的结果可以不接受和处理，直接在后面加分号 ; 成为一个独立的语句，这种情况属于返回值丢失。

3.6.5 方法的定义和调用

- 定义方法需要明确的内容
    * 明确返回值类型
    * 明确参数列表

案例：定义一个方法，求两个整数之和

public class MethodTest {
    public static void main(String[] args) {
        // 调用twoNumAdd()方法，并将其返回值赋给num
        int num = twoNumAdd(5 , 9) ;
        System.out.println(num);
    }

    /**
     * 求两个整数的和
     * @param a 参数a
     * @param b 参数b
     * @return  返回a和b的和
     */
    public static int twoNumAdd(int a , int b) {
        return a + b;
    }
}

• 方法的执行流程
  

  • 注意事项：

      - 方法不调用不执行
    
      - 方法与方法是平级关系，不能嵌套定义
    
      - 定义方法时，多个参数之间使用逗号隔开
    
      - 方法调用时传递参数不用再传递数据类型
    
      - 如果方法有明确的返回值，一定要使用return带回一个值
    

• 案例：键盘输入两个数据，返回两个数中的较大值

import java.util.Scanner;

public class MethodTest1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in) ;
        System.out.print("请输入第一个数：");
        int a = sc.nextInt();
        System.out.print("请输入第二个数：");
        int b = sc.nextInt();
        // 调用max()方法
        int max = max(a, b);

        System.out.println(max);
        sc.close();
    }

    /**
     * 比较两个数的大小，并返回较大的一个数的值
     * @param a
     * @param b
     * @return  返回较大值
     */
    public static int max(int a , int b) {

        /*int max ;
        if(a > b) {
            max = a ;
        } else {
            max = b ;
        }
        return max ;*/

        if(a > b) {
            return a ;
        } else {
            return b ;
        }

        // return (a > b) ? a : b ;

    }
}

3.6.6 方法重载概述和基本使用

重载：在同一个类中，方法名必须相同，参数列表必须不同，与返回值类型无关

* 参数列表不同的表现

	* 参数的个数不同
	* 参数的类型不同
	* 参数的顺序不同（实际开发中不用）


* 重载方法调用：JVM通过方法的参数列表，调用匹配的方法

	* 先找到个数、类型最匹配的
	* 再找个数和类型都可以兼容的

我们在之前的学习中，经常用到重载方法println()

案例：
* 定义一个方法求两个整数的和
* 定义一个方法求两个浮点数的和
* 定义一个方法求三个整数的和

public class MethodReloadTest {
    public static void main(String[] args) {
        System.out.println(add(1 , 3));
        System.out.println(add(3.14 , 5.3));
        System.out.println(add(1 , 2 , 3));
    }

    /**
     * 两个整数之和
     * @param a
     * @param b
     * @return
     */
    public static int add(int a , int b) {
        return a + b;
    }

    /**
     * 两个浮点数之和
     * @param a
     * @param b
     * @return
     */
    public static double add(double a , double b) {
        return a + b ;
    }

    /**
     * 三个整数之和
     * @param a
     * @param b
     * @param c
     * @return
     */
    public static int add(int a , int b , int c) {
        return a + b + c ;
    }

}

3.6.7 方法的递归调用

• 方法的递归
  • 方法自己调用自己的现象称为递归

从前有座山,山上有座庙,庙里有个老和尚喜欢给小和尚讲故事,故事的内容是从前有座山,山上有座庙,庙里有个老和尚喜欢给小和尚讲故事,故事的内容是…

• 递归的分类：
  • 直接递归：方法自己调用自己
  • 间接递归：A调用B，B调用C，C调用A

注意事项：

• 递归一定要有条件限制，保证递归能够在一定条件下停止，否则会报错（栈内存溢出）

• 在递归中虽然有限定条件，但是递归深度不能太深，否则效率低下，或者也会发生栈内存溢出。

案例：计算出10的阶乘

public class RecursionTest {
    public static void main(String[] args) {
        System.out.println(fun(5));
    }

    private static int fun(int a) {
        if(a == 1) {
            return 1 ;
        } else {
            return a * fun(a - 1) ;
        }
    }
}

fun(5) = 
  5 * fun(4) = 
  5 * 4 * fun(3) = 
  5 * 4 * 3 * fun(2) = 
  5 * 4 * 3 * 2 * fun(1) = 
  5 * 4 * 3 * 2 * 1