Java控制语句
目录
- 控制语句
- 选择结构
- if单选择结构
- if-else双选择结构
- if-else if-else多选择结构
- switch多选择结构
- 循环结构
- while循环
- do-while循环
- for循环
- 嵌套循环
- break语句和continue语句
- 带标签的break和continue
- 语句块
- 方法
- 方法的重载(overload)
- 递归结构
- 总结
控制语句
本篇文章开始我们要学习流程控制语句，流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。
“顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；
“选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；
“循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次； 如果没找到喜欢的人，则再继续找。
前面两篇文章讲解的程序都是顺序结构，即按照书写顺序执行每一条语句，这并不是我们的重点，因此本篇文章研究的重点是“选择结构”和“循环结构”。
很神奇的是，三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。实际上，任何软件和程序，小到一个练习，大到一个操作系统，本质上都是由“变量、选择语句、循环语句”组成。
这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。上述两种结构组成的程序可以解决全部的问题，所以任何一种高级语言都具备上述两种结构。
因此，本篇文章是大家真正跨入编程界的“门槛”，是成为“程序猿”的“门票”。
选择结构
在还没有知道Java选择结构的时候，我们编写的程序总是从程序入口开始，顺序执行每一条语句直到执行完最后一条语句结束，但是生活中经常需要进行条件判断，根据判断结果决定是否做一件事情，这就需要选择结构。
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。
主要的选择结构有：if选择结构和switch多选择结构：
-
if单选择结构
-
if-else双选择结构
-
if-else if-else多选择结构
-
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 运行效果图：
//使用条件运算符
public class Test4 {
public static void main(String[] args) {
int a=2;
int b=3;
System.out.println((a运行效果图： 
在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; //1if-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