1. 条件判断结构
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。主要的条件判
断结构有：if 结构和 switch 结构。而 if 结构又可以分为 if 单分支结构、if-else 双分支结构、if-else if-else 多分支结构。
1.1 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("今天手气不怎么样");
} S
ystem.out.println("得了" + count + "分");
}
}
1.2 if-else 双分支结构
当布尔表达式为真时，执行语句块 1，否则，执行语句块 2。也就是 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 = 3.14* r*r;
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("周长大于面积");
}
}
}
1.3 if-else if-else 多分支结构
当布尔表达式 1 为真时，执行语句块 1；否则，判断布尔表达式 2，当布尔表达式 2 为
真时，执行语句块 2；否则，继续判断布尔表达式 3······；如果 1~n 个布尔表达式均判定为假时，则执行语句块 n+1，也就是 else 部分。
public class Test5 {
public static void main(String[ ] args) {
int age = (int) (100 * Math.random());
System.out.print("年龄是" + age + "， 属于");
//15 岁以下儿童；15-24 青年；25-44 中年；45-64 中老年；65-84 老年；85 以上老
寿星
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("老寿星， 古来稀！");
}
}
}
2 switch 语句
2.1 switch 多分支结构(多值情况)
//grade 表示大学年级
int grade = 1;
if(grade==1) {
System.out.println("大学一年级， 可以放松一下， 学着谈谈恋
爱");
}else if(grade==2){
System.out.println("大学二年级， 少玩点游戏， 不空虚， 不慌
嘛？ ");
}else if(grade==3) {
System.out.println("大学三年级， 专业课开始了， 好好学， 找
份好工作");
}else{
System.out.println("大四了，要毕业了。 因为跟着尚学堂学习，
好工作搞定！ ");
} s
witch (grade){
case 1:
System.out.println("大学一年级");
break;
case 2:
System.out.println("大学二年级");
break;
case 3:
System.out.println("大学三年级");
break;
default:
System.out.println("大四了， 要毕业了");
break;
示例2
public class TestSwitch02 {
public static void main(String[] args){
int month = 2; //1 表示 1 月， 2 表示 2 月， ....
if(month==1||month==2||month==3){
System.out.println("春季");
}else if(month==4||month==5||month==6){
System.out.println("夏季");
}else if(month==7||month==8||month==9){
System.out.println("秋季");
}else{
System.out.println("冬季");
} S
ystem.out.println("========使用 switch 改造上面的代码，switch 特别适合多值判断
=============");
switch (month){
case 1:
case 2:
case 3:
System.out.println("春季");
break;
case 4:
case 5:
case 6:
System.out.println("夏季");
break;
case 7:
case 8:
case 9:
System.out.println("秋季");
break;
default:
System.out.println("冬季");
}
}
}
3 循环结构(while)
当型：当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才
停止循环，比如：while 与 for 循环。
直到型：先执行某语句， 再判断布尔表达式，如果为 true，再执行某语句，如此反复，直到布尔表达式条件为 false 时才停止循环，比如 do-while 循环。
3.1 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++;
} S
ystem.out.println("Sum= " + sum);
}
}
3.2 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);
}
}
4 循环结构(for)
for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for 循环在
第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定
结果为 true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式
的“步进”，即执行迭代因子。
public class Test10 { public static void main(String args[ ]) { int sum = 0; //1.求 1-100 之间的累加和 for (int i = 0; i <= 100; i++) { sum += i; } S ystem.out.println("Sum= " + sum); //2.循环输出 9-1 之间的数 for(int i=9;i>0;i--){ System.out.print(i+"、"); } S ystem.out.println(); //3.输出 90-1 之间能被 3 整除的数 for(int i=90;i>0;i-=3){ System.out.print(i+"、"); } S ystem.out.println(); } }
5 嵌套循环
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();
}
}
}
6 break 语句和 continue 语句
在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循
环，不执行循环中剩余的语句。
6.1 break 语句
//产生 100 以内的随机数，直到随机数为 88 时终止循环
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.");
}
}
6.2continue 语句
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();
}
}
}
}
6.3 带标签的 break 语句和 continue 语句
goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并
未在 Java 语言中得到正式使用；Java 没有 goto 语句。然而，在 break 和 continue 这两
个关键字的身上，我们仍然能看出一些 goto 的影子—带标签的 break 和 continue。
“标签”是指后面跟一个冒号的标识符，例如：“label:”。对 Java 来说唯一用到标
签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另
一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们
就会中断到存在标签的地方。
在 “goto 有害”论中，最有问题的就是标签，而非 goto， 随着标签在一个程序里
数量的增多，产生错误的机会也越来越多。 但 Java 标签不会造成这方面的问题，因为它们
的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣
的问题：通过限制语句的能力，反而能使一项语言特性更加有用
//控制嵌套循环跳转(打印 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;
}
} S
ystem.out.print(i + " ");
}
}
}
7.方法
- 方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函(function)。
- 方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
7.1 方法的详细说明
- 形式参数：在方法声明时用于接收外界传入的数据。
- 实参：调用方法时实际传给方法的数据
- 返回值：方法在执行完毕后返还给调用它的环境的数据。
- 返回值类型：事先约定的返回值的数据类型，如无返回值，必须指定为 void。
示例：方法的声明及调用
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("北京尚学堂...");
}
}
7.2 方法的重载
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会
根据不同的参数自动匹配对应的方法。
重载的方法，实际是完全不同的方法，只是名称相同而已！
示例：
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;
}
}
8.递归结构
递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己
调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺
塔、快排等问题。
示例：使用递归求 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)!
}
}
}