一、控制语句分类（3类）

1. 选择语句
2. 循环语句
3. 转向语句

二、选择语句（分支语句）

1. if语句
2. switch语句

1.if语句

1.1语法格式：

第一种写法：
	int a = 100;
	int b = 200;
	if(布尔表达式){
		java语句;
		java语句;
	}
	
	这里的一个大括号{} 叫做一个分支。
	该语法的执行原理是：
		如果布尔表达式的结果是true，则执行大括
		号中的程序，否则大括号中代码不执行。

第二种写法：
	if(布尔表达式){  // 分支1
		java语句;     
	}else{            // 分支2
		java语句;
	}
	
	执行原理：如果布尔表达式的结果是true，则执行分支1，分支2不执行。
			 如果布尔表达式的结果是false，分支1不执行，执行分支2.
			 以上的这个语句可以保证一定会有一个分支执行。
			 else表示其它。

第三种写法：
	if(布尔表达式1){ // 分支1
		java语句;
	}else if(布尔表达式2){ // 分支2
		java语句;
	}else if(布尔表达式3){
		java语句;
	}else if(布尔表达式4){
		java语句;
	}....
	
	以上if语句的执行原理：
		先判断“布尔表达式1”，如果“布尔表达式1”为true，则执行分支1，然后if语句结束了。
		当“布尔表达式1”结果是false，那么会继续判断布尔表达式2的结果，
		如果布尔表达式2的结果是true，则执行分支2，然后整个if就结束了。
		
		从上往下依次判断，主要看第一个true发生在哪个分支上。
		第一个true对应的分支执行，只要一个分支执行，整个if结束。

第四种写法：
	if(布尔表达式1){ // 分支1
		java语句;
	}else if(布尔表达式2){ // 分支2
		java语句;
	}else if(布尔表达式3){
		java语句;
	}else if(布尔表达式4){
		java语句;
	}else{
		java语句; // 以上条件没有一个成立的。这个else就执行了。
	}

注：

1. 对于if语句来说，在任何情况下只能有1个分支执行，不可能 存在2个或者更多个分支执行。if语句中只要有1个分支执行了， 整个if语句就结束了。（对于1个完整的if语句来说的。）
2. 以上4种语法机制中，凡是带有else分支的，一定可以保证会有 一个分支执行。
   以上4种当中，第一种和第三种没有else分支，这样的语句可能会导致最后一个分支都不执行。
   第二种和第四种肯定会有 1个分支执行。
3. 当分支当中“java语句;”只有1条，那么大括号{}可以省略，但为了 可读性，最好不要省略。（有的程序员在编写代码的时候，可能会故意 将大括号{}省略，你能看懂就行。）

小知识点：

	if(sex)
		System.out.println("男");
		System.out.println("HelloWorld!"); // 以上的这3行代码没有问题，合乎语法。
	/*
	else // 这一行编译报错，因为else缺少if
		System.out.println("女");
	*/

	以上代码编译器会自动转换为：
			if(sex){
				System.out.println("男");
			}
			System.out.println("HelloWorld!"); 
			else// 这一行编译报错，因为else缺少if
				System.out.println("女");

        int aa=10, bb = 10;
        if (a = b){//语法错误
		
        }
        if (1){//c/c++可以,Java不行

        }
        if (aa){//c/c++可以,Java不行，Java要boolean变量才行

        }

2.switch语句

2.1语法格式

	switch(值){
	case 值1:
		java语句;
		java语句;...
		break;
	case 值2:
		java语句;
		java语句;...
		break;
	case 值3:
		java语句;
		java语句;...
		break;
	default:
		java语句;
	}

以上是一个完整的switch语句：
其中：break;语句不是必须的。default分支也不是必须的。

2.2执行原理

拿“值”与“值1”进行比较，如果相同，则执行该分支中的java语句，
然后遇到"break;"语句，switch语句就结束了。
如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，如果相同，
则执行该分支中的java语句，然后遇到break;语句，switch结束。
注意：如果分支执行了，但是分支最后没有“break;”，此时会发生case 穿透现象。
所有的case都没有匹配成功，那么最后default分支会执行。

2.3switch语句支持的值

支持int类型以及String类型。

switch语句本质上是只支持int和String，
但是byte,short,char也可以
使用在switch语句当中，因为byte short char可以进行自动类型转换。

switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。

2.4 case合并、case穿透

        switch (score) {
            case 10:
            case 9:
                ans = "优";
                break;
            case 8:
                ans = "良";
                //break;
            case 7:
                ans = "中";
                break;
            case 6:
                ans = "及格";
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                ans = "不及格";
                break;
            default:
                ans = "输入的成绩有误";
        }

• case10、case9 和 case 5、case 4、 case 3、case 2、 case 1、case 0都是属于case合并
• 比如进入case8由于case8没有break会case穿透到case7才结束

三、选择语句

1. for循环
2. while循环
3. do…while…循环

1.for循环

1.1语法格式

	for(初始化表达式; 条件表达式; 更新表达式){
		循环体; // 循环体由java语句构成
		java语句;
		java语句;
		java语句;
		java语句;
		....
	}

1.2执行原理

先执行初始化表达式，并且初始化表达式只执行1次。
然后判断条件表达式的结果，如果条件表达式结果为true，则执行循环体。
循环体结束之后，执行更新表达式。
更新完之后，再判断条件表达式的结果，
如果还是true，继续执行循环体。

直到更新表达式执行结束之后，再次判断条件时，条件为false，for循环终止。

更新表达式的作用是：控制循环的次数；换句话说，更新表达式会更新
某个变量的值，这样条件表达式的结果才有可能从true变成false，从而
终止for循环的执行，反之，很有可能会导致死循环。

2.while循环

2.1语法格式

	while(布尔表达式){
		循环体;
	}

2.2执行原理

判断布尔表达式的结果，如果为true就执行循环体，
循环体结束之后，再次判断布尔表达式的结果，
如果还是true，继续执行循环体，
直到布尔表达式结果为false，while循环结束。

2.3for与while互相转换

	for(初始化表达式; 布尔表达式; 更新表达式){
		循环体;
	}
	
	初始化表达式;
	while(布尔表达式){
		循环体;
		更新表达式;
	}

2.4 执行次数

while循环的循环次数是：0 ~ n次。

3.do…while…循环

3.1语法格式

	do {
		循环体;
	}while(布尔表达式);

注：while后有分号！！
因为while后是()结尾不是{}结尾！！

3.2执行原理

先执行循环体当中的代码，执行一次循环体之后，
判断布尔表达式的结果，如果为true，则继续执行
循环体，如果为false循环结束。

2.3 执行次数

对于do…while循环来说循环体至少执行1次。循环体的执行次数是：1 ~ n 次

注意与while循环次数的差别！
对于while循环来说，循环体执行次数是：0~n次。

四、选择语句

1. break
2. continue
3. return

1.break

1. break;语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。另外：continue也是这样，他俩都是一个单词成为一条语句。
2. break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离它最近的那个循环语句。

1.1适用范围及作用

1. 第一个位置：switch语句当中，用来终止switch语句的执行。 用在switch语句当中，防止case穿透现象，用来终止switch。

2. 第二个位置：break;语句用在循环语句当中，用来终止循环的执行。 用在for当中 用在while当中
   用在do…while…当中。

1.2 使用break跳出指定的循环

第一步：你需要给循环起一个名字，例如：
	a: for(){
		b:for(){
			if(条件表达式) break a;
				code1;
				code2;
				code3;
		}
	}
第二步：终止：break a;

2.continue

2.1适用范围及作用

用在循环语句中！
终止当前"本次"循环，直接进入下一次循环继续执行。

注：一但执行到continue，continue以下代码不执行，直接执行更新表达式，进入下一次循环。

2.2 使用continue跳过指定循环

	a:for(;;更新表达式1){
			b:for(;;更新表达式2){
				if(条件表达式){
					continue a;
				}
				code1;
				code2;
				code3;
			}
		}

3.return

目录

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单选择结构

语法结构:

if(布尔表达式){
    语句块
}

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

if单选择结构流程图：  

//if单选择结构
public class Test1 {
    public static void main(String[] args) {
        //通过掷三个骰子看看今天的手气如何？
        int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数
        int j = (int)(6 * Math.random()) + 1;
        int k = (int)(6 * Math.random()) + 1;
        int count = i + j + k;
        //如果三个骰子之和大于15，则手气不错
        if(count > 15) {
            System.out.println("今天手气不错");
        }
        //如果三个骰子之和在10到15之间，则手气一般
        if(count >= 10 && count <= 15) { //错误写法：10<=count<=15
            System.out.println("今天手气很一般");
        }
        //如果三个骰子之和小于10，则手气不怎么样
        if(count < 10) {
            System.out.println("今天手气不怎么样");
        }
        System.out.println("得了" + count + "分");
    }
}

运行效果图：

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，否则，执行语句块2。也就是else部分。
if(布尔表达式){
    语句块1
}else{
    语句块2
}

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

//if-else结构
public class Test2 {
    public static void main(String[] args) {
        //随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
        double r = 4 * Math.random();
        //Math.pow(r, 2)求半径r的平方
        double area = Math.PI * Math.pow(r, 2);
        double circle = 2 * Math.PI * r;
        System.out.println("半径为： " + r);
        System.out.println("面积为： " + area);
        System.out.println("周长为： " + circle);
        //如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积
        if(area >= circle) {
            System.out.println("面积大于等于周长");
        } else {
            System.out.println("周长大于面积");
        }
    }
}

运行效果图：

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

//使用if-else
public class Test3 {
    public static void main(String[] args) {
        int a=2; 
        int b=3;
        if (a<b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

 运行效果图：

//使用条件运算符
public class Test4 {
    public static void main(String[] args) {
        int a=2;
        int b=3;
        System.out.println((a<b)?a:b);
    }
}

运行效果图： 

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

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

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

​//if - else条件判断
int x = 0;
int y = 1;
int max;
if (x > y) {
    max = x;
} else {
    max = y;
}

//​三元运算符
int x = 0;
int y = 1;
int max = x > y ? x : y;  //1

---

if-else if-else多选择结构

语法结构：

if(布尔表达式1) {
    语句块1;
} else if(布尔表达式2) {
    语句块2;
}……
else if(布尔表达式n){
    语句块n;
} else {
    语句块n+1;
}

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

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

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

//if-else if-else多选择结构
public class Test5 {
    public static void main(String[] args) {
        int age = (int) (100 * Math.random());
        System.out.print("年龄是" + age + "， 属于");
        if (age < 15) {
            System.out.println("儿童， 喜欢玩！");
        } else if (age < 25) {
            System.out.println("青年， 要学习！");
        } else if (age < 45) {
            System.out.println("中年， 要工作！");
        } else if (age < 65) {
            System.out.println("中老年， 要补钙！");
        } else if (age < 85) {
            System.out.println("老年， 多运动！");
        } else {
            System.out.println("老寿星， 古来稀！");
        }
    }
}

运行效果图：

---

switch多选择结构

语法结构：

​switch (表达式) {
    case 目标值1: 
         语句序列1;
         break;
    case 目标值2:
         语句序列2;
         break;
    … … … … …

    case 目标值n:
         语句序列n;
         break;
    default:
         默认语句;
         break;
}

       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多选择结构流程图：

//switch结构
public class Test6 {
    public static void main(String[] args) {
        char c = 'a';
        int rand = (int) (26 * Math.random());
        char c2 = (char) (c + rand);
        System.out.print(c2 + ": ");
        switch (c2) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            System.out.println("元音");
            break;
        case 'y':
        case 'w':
            System.out.println("半元音");
            break;
        default:
            System.out.println("辅音");
        }
    }
}

 运行效果图：

---

循环结构

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

当型：

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

 直到型：

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

---

while循环

语法结构：

while (布尔表达式) {
    循环体;
}

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

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

while流程图：

//while循环结构：求1到100之间的累加和
public class Test7 {
    public static void main(String[] args) {
        int  i = 0;
        int  sum = 0;
        // 1+2+3+…+100=?
        while (i <= 100) {
            sum += i;  //相当于sum = sum+i;
            i++;
        }
        System.out.println("Sum= " + sum);
    }
}

运行效果图：

---

 do-while循环

语法结构：

do {
    循环体;
    } while(布尔表达式) ;

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

do-while流程图：

//do-while循环结构：1-100之间的累加和
public class Test8 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum += i;  // sum = sum + i
            i++;
        } while (i <= 100);  //此处的；不能省略
        System.out.println("Sum= " + sum);
    }
}

运行效果图：

while与do-while的区别：

public class Test9 {
    public static void main(String[] args) {
        //while循环：先判断再执行
        int a = 0;
        while (a < 0) {
            System.out.println(a);
            a++;
        }
        System.out.println("-----");
        //do-while循环：先执行再判断
        a = 0;
        do {
            System.out.println(a);
            a++;
        } while (a < 0);
    }
}

运行效果图：

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

---

for循环

语法结构：

for (初始表达式; 布尔表达式; 迭代因子) {
      循环体;
}

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

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

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

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

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

for循环流程图：

//for循环　　
public class Test10 {
    public static void main(String args[]) {
        int sum = 0;
        //1.求1-100之间的累加和
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);
        //2.循环输出9-1之间的数
        for(int i=9;i>0;i--){
            System.out.print(i+"、");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for(int i=90;i>0;i-=3){
            System.out.print(i+"、");
        }
        System.out.println();
    }
}

运行效果图：

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

逗号运算符：

public class Test11 {
    public static void main(String[] args) { 
        for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
            System.out.println("i= " + i + " j= " + j); 
        } 
    }
}

运行效果图：

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

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

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

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

无限循环：

public class Test12 {
    public static void main(String[] args) { 
        for ( ; ; ) {    // 无限循环: 相当于 while(true)
            System.out.println("北京尚学堂");
        }
    }
}

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

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

初始化变量的作用域：

---

嵌套循环

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

//嵌套循环　
public class Test14 {
    public static void main(String args[]) {
        for (int i=1; i <=5; i++) {
            for(int j=1; j<=5; j++){
                System.out.print(i+"  ");
            }
            System.out.println();
        }
    }
}

运行效果图：

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

public class Test15 {
    public static void main(String args[]) {
        for (int i = 1; i < 10; i++) {  // i是一个乘数
            for (int j = 1; j <= i; j++) {  // j是另一个乘数
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + "  ");
            }
            System.out.println();
        }
    }
}

运行效果图：

---

break语句和continue语句

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

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

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

public class Test16 {
    public static void main(String[] args) {
        int total = 0;  //定义计数器
        System.out.println("Begin");
        while (true) {
            total++;  //每循环一次计数器加1
            int i = (int) Math.round(100 * Math.random());
            //当i等于88时，退出循环
            if (i == 88) {
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over， used " + total + " times.");
    }
}

运行效果图：

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

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

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

//continue语句：把100~150之间不能被3整除的数输出，并且每行输出5个
public class Test17 {
    public static void main(String[] args) {
        int count = 0;  //定义计数器
        for (int i = 100; i < 150; i++) {
            //如果是3的倍数，则跳过本次循环，继续进行下一次循环
            if (i % 3 == 0){
                continue;
            }
            //否则（不是3的倍数），输出该数
            System.out.print(i + "、");
            count++;  //没输出一个数，计数器加1
            //根据计数器判断每行是否已经输出了5个数
            if (count % 5 == 0) {
                System.out.println();
            }
        }
    }
}

运行效果图：

---

带标签的break和continue

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

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

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

//带标签break和continue：控制嵌套循环跳转(打印101-150之间所有的质数)
public class Test18 {
    public static void main(String args[]) {
        outer: for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.print(i + "  ");
        }
    }
}

运行效果图：

---

语句块

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

//语句块　
public class Test19 {
    public static void main(String[] args) {
        int n;
        int a;
        {
            int k;
            int n;  //编译错误：不能重复定义变量n
        }  //变量k的作用域到此为止
    }
}

---

方法

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

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

方法声明格式：

[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表) {
    Java语句；
    … … …
    return 返回值；
 }

方法的调用方式：

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

      方法的详细说明：

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

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

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

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

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

方法的声明及调用：

public class Test20 {
    /** main方法：程序的入口 */
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        //调用求和的方法：将num1与num2的值传给add方法中的n1与n2
        // 求完和后将结果返回，用sum接收结果
        int sum = add(num1, num2);
        System.out.println("sum = " + sum);  //输出：sum = 30
        //调用打印的方法：该方法没有返回值
        print();
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;  //使用return返回计算的结果
    }
    /** 打印的方法 */
    public static void print() {
        System.out.println("北京欢迎你...");
    }
}

运行效果图：

//打印三个长宽不同的矩形。
public class Example19 {
	public static void main(String[] args) {
		//下面的循环是使用*打印一个宽为5、高为3的矩形
		for(int i = 0; i < 3; i++) {
			for(int j = 0; j < 5; j++) {
				System.out.print("*");
			}
			System.out.print("\n");
		}
		System.out.print("\n");
		//下面的循环是使用*打印一个宽为4、高为2的矩形
		for(int i = 0; i < 2; i++) {
			for(int j = 0; j < 4; j++) {
				System.out.print("*");
			}
			System.out.print("\n");
		}
		System.out.print("\n");
		//下面的循环是使用*打印一个宽为10、高为6的矩形
		for(int i = 0; i < 6; i++) {
			for(int j = 0; j < 10; j++) {
				System.out.print("*");
			}
			System.out.print("\n");
		}
		System.out.print("\n");
	}
}

//将使用“*”打印矩形的功能定义为方法，在程序中调用三次。
public class Example20 {
	public static void main(String[] args) {
		printRectangle(3, 5);  //调用printRectangle()方法实现打印矩形
		printRectangle(2, 4);
		printRectangle(6, 10);
	}
	
	public static void printRectangle(int height, int width) {
		//下面使用嵌套for循环实现*打印矩形
		for(int i = 0; i < height; i++) {
			for(int j = 0; j < width; j++) {
				System.out.print("*");
			}
			System.out.print("\n");
		}
		System.out.print("\n");
	}
}

public class Example21{
	public static void main(String[] args) {
		int area = getArea(3, 5);  //调用getArea方法
		System.out.println(" The area is " + area);
	}
	//下面定义了一个矩形面积的方法，接收两个参数，其中x为高，y为宽
	private static int getArea(int x, int y) {
		int temp = x * y;  //试一下变量temp记住运算结果
		return temp;  //将变量temp的值返回
	}
}

 

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){}  //不构成方法重载

 

方法重载：

public class Test21 {
    public static void main(String[] args) {
        System.out.println(add(3, 5));  // 8
        System.out.println(add(3, 5, 10));  // 18
        System.out.println(add(3.0, 5));  // 8.0
        System.out.println(add(3, 5.0));  // 8.0
        // 我们已经见过的方法的重载
        System.out.println();  // 0个参数
        System.out.println(1);  // 参数是1个int
        System.out.println(3.0);  // 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

---

递归结构

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

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

      递归结构包括两个部分：

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

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

//递归：计算n!　　
public class Test22 {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();  
        System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n", d2-d1);  //耗时：32ms
    }
    /** 求阶乘的方法*/
    static long  factorial(int n){
        if(n==1){  //递归头
            return 1;
        }else{  //递归体
            return n*factorial(n-1);//n! = n * (n-1)!
        }
    }
}

运行效果图：

递归原理分析图：

public class Example24{
	public static void main(String[] args) {
		int sum = getSum(4);  //调用递归方法，获得1～4的和
		System.out.println("sum = " + sum);
	}
	//使用递归实现求1～n的和
	private static int getSum(int n) {
		if (n == 1) {
			//满足条件，递归结束
			return 1;
		}
		int temp = getSum(n - 1);
		return temp + n;
	}
}

 运行效果图：

递归原理分析图：

递归的缺陷：

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

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

//使用循环求n!　
public class Test23 {
    public static void main(String[] args) {
        long d3 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1) {
            result *= a * (a - 1);
            a -= 2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf("普通循环费时：%s%n", d4 - d3);
    }
}

运行效果图：

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

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

---

总结

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

转载自http://www.sxt.cn/Java_jQuery_in_action/openketang-Summery.html