JAVA控制语句

转至：

https://blog.csdn.net/from_heat/article/details/82289626

目录

1. 控制语句
2. 选择结构
3. if单选择结构
4. if-else双选择结构
5. if-else if-else多选择结构
6. switch多选择结构
7. 循环结构
8. while循环
9. do-while循环
10. for循环
11. 嵌套循环
12. break语句和continue语句
13. 带标签的break和continue
14. 语句块
15. 方法
16. 方法的重载(overload)
17. 递归结构
18. 总结

---

控制语句

       本篇文章开始我们要学习流程控制语句，流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。

      “顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；

      “选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；

      “循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次； 如果没找到喜欢的人，则再继续找。

      前面两篇文章讲解的程序都是顺序结构，即按照书写顺序执行每一条语句，这并不是我们的重点，因此本篇文章研究的重点是“选择结构”和“循环结构”。

      很神奇的是，三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。实际上，任何软件和程序，小到一个练习，大到一个操作系统，本质上都是由“变量、选择语句、循环语句”组成。

      这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。上述两种结构组成的程序可以解决全部的问题，所以任何一种高级语言都具备上述两种结构。

      因此，本篇文章是大家真正跨入编程界的“门槛”，是成为“程序猿”的“门票”。

---

选择结构

       在还没有知道Java选择结构的时候，我们编写的程序总是从程序入口开始，顺序执行每一条语句直到执行完最后一条语句结束，但是生活中经常需要进行条件判断，根据判断结果决定是否做一件事情，这就需要选择结构。

      选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。

      主要的选择结构有：if选择结构和switch多选择结构：

1.     if单选择结构

2.    if-else双选择结构

3.    if-else if-else多选择结构

4.    switch结构

---

if单选择结构

语法结构:

1. if(布尔表达式){

2. 语句块

3. }

   if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。

if单选择结构流程图：  

1. //if单选择结构

2. public class Test1 {

3. public static void main(String[] args) {

4. //通过掷三个骰子看看今天的手气如何？

5. int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数

6. int j = (int)(6 * Math.random()) + 1;

7. int k = (int)(6 * Math.random()) + 1;

8. int count = i + j + k;

9. //如果三个骰子之和大于15，则手气不错

10. if(count > 15) {

11. System.out.println("今天手气不错");

12. }

13. //如果三个骰子之和在10到15之间，则手气一般

14. if(count >= 10 && count <= 15) { //错误写法：10<=count<=15

15. System.out.println("今天手气很一般");

16. }

17. //如果三个骰子之和小于10，则手气不怎么样

18. if(count < 10) {

19. System.out.println("今天手气不怎么样");

20. }

21. System.out.println("得了" + count + "分");

22. }

23. }

运行效果图：

Math类的使用

      1.java.lang包中的Math类提供了一些用于数学计算的方法。

      2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。

int i = (int) (6 * Math.random());  //产生：[0，5]之间的随机整数

1.如果if语句不写{}，则只能作用于后面的第一条语句。 

2.强烈建议，任何时候都写上{}，即使里面只有一句话！

---

if-else双选择结构

语法结构:

1. ​//当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。

2. if(布尔表达式){

3. 语句块1

4. }else{

5. 语句块2

6. }

 if-else双选择结构流程图：   

1. //if-else结构

2. public class Test2 {

3. public static void main(String[] args) {

4. //随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长

5. double r = 4 * Math.random();

6. //Math.pow(r, 2)求半径r的平方

7. double area = Math.PI * Math.pow(r, 2);

8. double circle = 2 * Math.PI * r;

9. System.out.println("半径为： " + r);

10. System.out.println("面积为： " + area);

11. System.out.println("周长为： " + circle);

12. //如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积

13. if(area >= circle) {

14. System.out.println("面积大于等于周长");

15. } else {

16. System.out.println("周长大于面积");

17. }

18. }

19. }

运行效果图：

条件运算符有时候可用于代替if-else： 

1. //使用if-else

2. public class Test3 {

3. public static void main(String[] args) {

4. int a=2;

5. int b=3;

6. if (a

7. System.out.println(a);

8. } else {

9. System.out.println(b);

10. }

11. }

12. }

 运行效果图：

1. //使用条件运算符

2. public class Test4 {

3. public static void main(String[] args) {

4. int a=2;

5. int b=3;

6. System.out.println((a

7. }

8. }

运行效果图： 

在Java中有一种特殊的运算叫做三元运算，它和if-else语句类似：

判断条件 ？ 表达式1 ： 表达式2

三元运算通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。

1. ​//if - else条件判断

2. int x = 0;

3. int y = 1;

4. int max;

5. if (x > y) {

6. max = x;

7. } else {

8. max = y;

9. }

10.  

11. //​三元运算符

12. int x = 0;

13. int y = 1;

14. int max = x > y ? x : y; //1

---

if-else if-else多选择结构

语法结构：

1. if(布尔表达式1) {

2. 语句块1;

3. } else if(布尔表达式2) {

4. 语句块2;

5. }……

6. else if(布尔表达式n){

7. 语句块n;

8. } else {

9. 语句块n+1;

10. }

       当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。

 if-else if-else多选择结构流程图：

 对多个条件进行判断，进行不同的处理。

1. //if-else if-else多选择结构

2. public class Test5 {

3. public static void main(String[] args) {

4. int age = (int) (100 * Math.random());

5. System.out.print("年龄是" + age + "， 属于");

6. if (age < 15) {

7. System.out.println("儿童， 喜欢玩！");

8. } else if (age < 25) {

9. System.out.println("青年， 要学习！");

10. } else if (age < 45) {

11. System.out.println("中年， 要工作！");

12. } else if (age < 65) {

13. System.out.println("中老年， 要补钙！");

14. } else if (age < 85) {

15. System.out.println("老年， 多运动！");

16. } else {

17. System.out.println("老寿星， 古来稀！");

18. }

19. }

20. }

运行效果图：

---

switch多选择结构

语法结构：

1. ​switch (表达式) {

2. case 目标值1:

3. 语句序列1;

4. break;

5. case 目标值2:

6. 语句序列2;

7. break;

8. … … … … …

9.  

10. case 目标值n:

11. 语句序列n;

12. break;

13. default:

14. 默认语句;

15. break;

16. }

       switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。

      根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(byte、short、char、int、enum。long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。

      大家要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。

 switch多选择结构流程图：

1. //switch结构

2. public class Test6 {

3. public static void main(String[] args) {

4. char c = 'a';

5. int rand = (int) (26 * Math.random());

6. char c2 = (char) (c + rand);

7. System.out.print(c2 + ": ");

8. switch (c2) {

9. case 'a':

10. case 'e':

11. case 'i':

12. case 'o':

13. case 'u':

14. System.out.println("元音");

15. break;

16. case 'y':

17. case 'w':

18. System.out.println("半元音");

19. break;

20. default:

21. System.out.println("辅音");

22. }

23. }

24. }

 运行效果图：

---

循环结构

循环结构分两大类，一类是当型，一类是直到型。

当型：

      当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。

 直到型：

      先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。

---

while循环

语法结构：

1. while (布尔表达式) {

2. 循环体;

3. }

       在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。while语句会反复地进行条件判断，直到条件不成立，while循环结束。

      语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

while流程图：

1. //while循环结构：求1到100之间的累加和

2. public class Test7 {

3. public static void main(String[] args) {

4. int i = 0;

5. int sum = 0;

6. // 1+2+3+…+100=?

7. while (i <= 100) {

8. sum += i; //相当于sum = sum+i;

9. i++;

10. }

11. System.out.println("Sum= " + sum);

12. }

13. }

运行效果图：

---

 do-while循环

语法结构：

1. do {

2. 循环体;

3. } while(布尔表达式) ;

       do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。

do-while流程图：

1. //do-while循环结构：1-100之间的累加和

2. public class Test8 {

3. public static void main(String[] args) {

4. int i = 0;

5. int sum = 0;

6. do {

7. sum += i; // sum = sum + i

8. i++;

9. } while (i <= 100); //此处的；不能省略

10. System.out.println("Sum= " + sum);

11. }

12. }

运行效果图：

while与do-while的区别：

1. public class Test9 {

2. public static void main(String[] args) {

3. //while循环：先判断再执行

4. int a = 0;

5. while (a < 0) {

6. System.out.println(a);

7. a++;

8. }

9. System.out.println("-----");

10. //do-while循环：先执行再判断

11. a = 0;

12. do {

13. System.out.println(a);

14. a++;

15. } while (a < 0);

16. }

17. }

运行效果图：

从运行效图中可以看出do-while总是保证循环体至少会被执行一次!

---

for循环

语法结构：

1. for (初始表达式; 布尔表达式; 迭代因子) {

2. 循环体;

3. }

       for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构，也是最常用的循环语句，一般用在循环次数已知的情况下。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

      A. 初始化部分设置循环变量的初值

      B. 条件判断部分为任意布尔表达式

      C. 迭代因子控制循环变量的增减

      for循环在执行条件判断后，先执行的循环体部分，再执行步进。

for循环流程图：

1. //for循环　　

2. public class Test10 {

3. public static void main(String args[]) {

4. int sum = 0;

5. //1.求1-100之间的累加和

6. for (int i = 0; i <= 100; i++) {

7. sum += i;

8. }

9. System.out.println("Sum= " + sum);

10. //2.循环输出9-1之间的数

11. for(int i=9;i>0;i--){

12. System.out.print(i+"、");

13. }

14. System.out.println();

15. //3.输出90-1之间能被3整除的数

16. for(int i=90;i>0;i-=3){

17. System.out.print(i+"、");

18. }

19. System.out.println();

20. }

21. }

运行效果图：

       Java里能用到逗号运算符的地方屈指可数，其中一处就是for循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些表达式均会独立执行。

逗号运算符：

1. public class Test11 {

2. public static void main(String[] args) {

3. for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {

4. System.out.println("i= " + i + " j= " + j);

5. }

6. }

7. }

运行效果图：

1. 无论在初始化还是在步进部分，语句都是顺序执行的。

2. 尽管初始化部分可设置任意数量的定义，但都属于同一类型。

3. 约定:只在for语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。

初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开：

无限循环：

1. public class Test12 {

2. public static void main(String[] args) {

3. for ( ; ; ) { // 无限循环: 相当于 while(true)

4. System.out.println("北京尚学堂");

5. }

6. }

7. }

编译器将while(true)与for(  ;  ;  )看作同一回事，都指的是无限循环。

在for语句的初始化部分声明的变量，其作用域为整个for循环体，不能在循环外部使用该变量：

初始化变量的作用域：

---

嵌套循环

       在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环：

1. //嵌套循环　

2. public class Test14 {

3. public static void main(String args[]) {

4. for (int i=1; i <=5; i++) {

5. for(int j=1; j<=5; j++){

6. System.out.print(i+" ");

7. }

8. System.out.println();

9. }

10. }

11. }

运行效果图：

使用嵌套循环实现九九乘法表：

1. public class Test15 {

2. public static void main(String args[]) {

3. for (int i = 1; i < 10; i++) { // i是一个乘数

4. for (int j = 1; j <= i; j++) { // j是另一个乘数

5. System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");

6. }

7. System.out.println();

8. }

9. }

10. }

运行效果图：

---

break语句和continue语句

跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句。

在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。

break语句：在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。 

1. public class Test16 {

2. public static void main(String[] args) {

3. int total = 0; //定义计数器

4. System.out.println("Begin");

5. while (true) {

6. total++; //每循环一次计数器加1

7. int i = (int) Math.round(100 * Math.random());

8. //当i等于88时，退出循环

9. if (i == 88) {

10. break;

11. }

12. }

13. //输出循环的次数

14. System.out.println("Game over， used " + total + " times.");

15. }

16. }

运行效果图：

       continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

1. continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。

2. continue用在for循环中，跳到for循环的迭代因子部分。

1. //continue语句：把100~150之间不能被3整除的数输出，并且每行输出5个

2. public class Test17 {

3. public static void main(String[] args) {

4. int count = 0; //定义计数器

5. for (int i = 100; i < 150; i++) {

6. //如果是3的倍数，则跳过本次循环，继续进行下一次循环

7. if (i % 3 == 0){

8. continue;

9. }

10. //否则（不是3的倍数），输出该数

11. System.out.print(i + "、");

12. count++; //没输出一个数，计数器加1

13. //根据计数器判断每行是否已经输出了5个数

14. if (count % 5 == 0) {

15. System.out.println();

16. }

17. }

18. }

19. }

运行效果图：

---

带标签的break和continue

      goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在Java语言中得到正式使用;Java没有goto语句。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子---带标签的break和continue。

      “标签”是指后面跟一个冒号的标识符，例如：“label:”。对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

      在 “goto有害”论中，最有问题的就是标签，而非goto， 随着标签在一个程序里数量的增多，产生错误的机会也越来越多。 但Java标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。

1. //带标签break和continue：控制嵌套循环跳转(打印101-150之间所有的质数)

2. public class Test18 {

3. public static void main(String args[]) {

4. outer: for (int i = 101; i < 150; i++) {

5. for (int j = 2; j < i / 2; j++) {

6. if (i % j == 0){

7. continue outer;

8. }

9. }

10. System.out.print(i + " ");

11. }

12. }

13. }

运行效果图：

---

语句块

       语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

1. //语句块　

2. public class Test19 {

3. public static void main(String[] args) {

4. int n;

5. int a;

6. {

7. int k;

8. int n; //编译错误：不能重复定义变量n

9. } //变量k的作用域到此为止

10. }

11. }

---

方法

       方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。

      方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

1. [修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表) {

2. Java语句；

3. … … …

4. return 返回值；

5. }

方法的调用方式：

      对象名.方法名(实参列表)

      方法的详细说明：

      1. 形式参数：在方法声明时用于接收外界传入的数据，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。格式：（参数类型  实参1，参数类型  实参2，……）。

      2. 实参：调用方法时实际传给方法的数据。参数类型：用于限定调用方法时传入参数的数据类型。

      3. 返回值：方法在执行完毕后被return语句返还给调用它的环境的数据。

      4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void，方法中return语句可以省略。                          return关键字：用于结束方法以及返回方法指定类型的值。

      5. 修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等。

方法的声明及调用：

1. public class Test20 {

2. /** main方法：程序的入口 */

3. public static void main(String[] args) {

4. int num1 = 10;

5. int num2 = 20;

6. //调用求和的方法：将num1与num2的值传给add方法中的n1与n2

7. // 求完和后将结果返回，用sum接收结果

8. int sum = add(num1, num2);

9. System.out.println("sum = " + sum); //输出：sum = 30

10. //调用打印的方法：该方法没有返回值

11. print();

12. }

13. /** 求和的方法 */

14. public static int add(int n1, int n2) {

15. int sum = n1 + n2;

16. return sum; //使用return返回计算的结果

17. }

18. /** 打印的方法 */

19. public static void print() {

20. System.out.println("北京欢迎你...");

21. }

22. }

运行效果图：

1. //打印三个长宽不同的矩形。

2. public class Example19 {

3. public static void main(String[] args) {

4. //下面的循环是使用*打印一个宽为5、高为3的矩形

5. for(int i = 0; i < 3; i++) {

6. for(int j = 0; j < 5; j++) {

7. System.out.print("*");

8. }

9. System.out.print("\n");

10. }

11. System.out.print("\n");

12. //下面的循环是使用*打印一个宽为4、高为2的矩形

13. for(int i = 0; i < 2; i++) {

14. for(int j = 0; j < 4; j++) {

15. System.out.print("*");

16. }

17. System.out.print("\n");

18. }

19. System.out.print("\n");

20. //下面的循环是使用*打印一个宽为10、高为6的矩形

21. for(int i = 0; i < 6; i++) {

22. for(int j = 0; j < 10; j++) {

23. System.out.print("*");

24. }

25. System.out.print("\n");

26. }

27. System.out.print("\n");

28. }

29. }

30.  

31. //将使用“*”打印矩形的功能定义为方法，在程序中调用三次。

32. public class Example20 {

33. public static void main(String[] args) {

34. printRectangle(3, 5); //调用printRectangle()方法实现打印矩形

35. printRectangle(2, 4);

36. printRectangle(6, 10);

37. }

38.  

39. public static void printRectangle(int height, int width) {

40. //下面使用嵌套for循环实现*打印矩形

41. for(int i = 0; i < height; i++) {

42. for(int j = 0; j < width; j++) {

43. System.out.print("*");

44. }

45. System.out.print("\n");

46. }

47. System.out.print("\n");

48. }

49. }

1. public class Example21{

2. public static void main(String[] args) {

3. int area = getArea(3, 5); //调用getArea方法

4. System.out.println(" The area is " + area);

5. }

6. //下面定义了一个矩形面积的方法，接收两个参数，其中x为高，y为宽

7. private static int getArea(int x, int y) {

8. int temp = x * y; //试一下变量temp记住运算结果

9. return temp; //将变量temp的值返回

10. }

11. }

 

1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。

2. return 语句终止方法的运行并指定要返回的数据。

3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：

4. 基本类型传递的是该数据值的copy值。

5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。

---

方法的重载(overload)

       方法的重载是指一个类中可以定义多个方法名相同，但参数类型或个数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

重载的方法，实际是完全不同的方法，只是名称相同而已!

构成方法重载的条件：

1.不同的含义：形参类型、形参个数、形参顺序不同

2.只有返回值不同不构成方法的重载

int a(String str){} 与 void a(String str){}  //不构成方法重载

3.只有形参的名称不同，不构成方法的重载

int a(String str){} 与 int a(String s){}  //不构成方法重载

 

方法重载：

1. public class Test21 {

2. public static void main(String[] args) {

3. System.out.println(add(3, 5)); // 8

4. System.out.println(add(3, 5, 10)); // 18

5. System.out.println(add(3.0, 5)); // 8.0

6. System.out.println(add(3, 5.0)); // 8.0

7. // 我们已经见过的方法的重载

8. System.out.println(); // 0个参数

9. System.out.println(1); // 参数是1个int

10. System.out.println(3.0); // 参数是1个double

11. }

12. /** 求和的方法 */

13. public static int add(int n1, int n2) {

14. int sum = n1 + n2;

15. return sum;

16. }

17. // 方法名相同，参数个数不同，构成重载

18. public static int add(int n1, int n2, int n3) {

19. int sum = n1 + n2 + n3;

20. return sum;

21. }

22. // 方法名相同，参数类型不同，构成重载

23. public static double add(double n1, int n2) {

24. double sum = n1 + n2;

25. return sum;

26. }

27. // 方法名相同，参数顺序不同，构成重载

28. public static double add(int n1, double n2) {

29. double sum = n1 + n2;

30. return sum;

31. }

32. //编译错误：只有返回值不同，不构成方法的重载

33. public static double add(int n1, int n2) {

34. double sum = n1 + n2;

35. return sum;

36. }

37. //编译错误：只有参数名称不同，不构成方法的重载

38. public static int add(int n2, int n1) {

39. double sum = n1 + n2;

40. return sum;

41. }

42. }

43.  
44.  

---

递归结构

       递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

      利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。

      递归结构包括两个部分：

      1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。

      2.递归体。解答：什么时候需要调用自身方法。

1. //递归：计算n!　　

2. public class Test22 {

3. public static void main(String[] args) {

4. long d1 = System.currentTimeMillis();

5. System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));

6. long d2 = System.currentTimeMillis();

7. System.out.printf("递归费时：%s%n", d2-d1); //耗时：32ms

8. }

9. /** 求阶乘的方法*/

10. static long factorial(int n){

11. if(n==1){ //递归头

12. return 1;

13. }else{ //递归体

14. return n*factorial(n-1);//n! = n * (n-1)!

15. }

16. }

17. }

运行效果图：

递归原理分析图：

1. public class Example24{

2. public static void main(String[] args) {

3. int sum = getSum(4); //调用递归方法，获得1～4的和

4. System.out.println("sum = " + sum);

5. }

6. //使用递归实现求1～n的和

7. private static int getSum(int n) {

8. if (n == 1) {

9. //满足条件，递归结束

10. return 1;

11. }

12. int temp = getSum(n - 1);

13. return temp + n;

14. }

15. }

 运行效果图：

递归原理分析图：

递归的缺陷：

       简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

比如上面的递归耗时558ms。但是用普通循环的话快得多。

1. //使用循环求n!　

2. public class Test23 {

3. public static void main(String[] args) {

4. long d3 = System.currentTimeMillis();

5. int a = 10;

6. int result = 1;

7. while (a > 1) {

8. result *= a * (a - 1);

9. a -= 2;

10. }

11. long d4 = System.currentTimeMillis();

12. System.out.println(result);

13. System.out.printf("普通循环费时：%s%n", d4 - d3);

14. }

15. }

运行效果图：

       任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归;

      在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

---

总结

       1.从结构化程序设计角度出发，程序有三种结构：顺序结构、选择结构和循环结构。

　　2.选择结构

　    （1）if单选择结构 if-else双选择结构 if-else if-else多选择结构。

　    （2）switch多选择结构。

　　3.多选择结构与switch的关系：当布尔表达式是等值判断的情况，可使用多重选择结构或switch结构，如果布尔表达式区间判断的情况，则只能使用多重选择结构。

　　   （1）循环结构

　　   （2）当型：while与for

　　   （3）直到型:do-while

　　4.while与do-while的区别，在布尔表达式的值为false时while的循环体一次也不执行，而do-while至少执行一次。

　　5.break可以在switch与循环结构中使用，而continue只能在循环结构中使用。

　　6.方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。

　　7.方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

　　8.任何能用递归解决的问题也能使用迭代解决。在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。