Java基础学习 2 (选择结构,循环结构)

程序的执行流程

在一个程序执行的过程当中，各条语句的执行顺序对程序的结果是有直接影响的。
也就是说程序的流程对运行结果有直接的影响。因此，咱们必须清楚每条语句的执行流程。
并且，不少时候咱们要经过控制语句的执行顺序来实现咱们要完成的功能。
程序的执行流程分为三类：

1. 顺序结构：代码从上往下一行一行去执行。
2. 选择结构：也被称为分支结构。选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，因此产生选择，按照不一样的选择执行不一样的代码。
3. 循环结构：循环语句能够在知足循环条件的状况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，须要在合适的时候把循环判断条件修改成false，从而结束循环，不然循环将一直执行下去，造成死循环。

Scanner

Java提供的类，能够同来获取从键盘中输入的数据。
使用步骤分为如下三步：

1. 导入程序包：import java.util.Scanner;
2. 建立键盘录入对象：Scanner a = new Scanner(System.in);
3. 录入输入的数据：int b = a.nextInt();

if(选择结构)

if语句是条件选择语句，具备如下三种格式。

格式一：if

1     if(比较表达式或者是boolean类型的值) {
2         语句体;
3     }
4     /*执行流程
5     先计算比较表达式的值，看其返回值是true仍是false。
6         若是是true，就执行语句体；
7         若是是false，就不执行语句体；*/

格式二：if-else

 1   if(比较表达式) {
 2             语句体1;
 3         }else {
 4             语句体2;
 5         }
 6 
 7     //注意事项：else后面是没有比较表达式的，只有if后面有。
 8     /*执行流程
 9     首先计算比较表达式的值，看其返回值是true仍是false。
10     若是是true，就执行语句体1；
11     若是是false，就执行语句体2；*/

格式三：if-else if-else

 1  if(比较表达式1) {
 2             语句体1;
 3         }else if(比较表达式2) {
 4             语句体2;
 5         }else if(比较表达式3) {
 6             语句体3;
 7         }
 8         ...
 9         else {
10             语句体n+1;
11         }
12     //注意事项： 当只要有一个条件知足时，if语句结束。else是能够省略，可是不建议省略。
13     /*执行流程
14     首先计算比较表达式1看其返回值是true仍是false，
15     若是是true，就执行语句体1，if语句结束。
16     若是是false，接着计算比较表达式2看其返回值是true仍是false，
17     
18     若是是true，就执行语句体2，if语句结束。
19     若是是false，接着计算比较表达式3看其返回值是true仍是false，
20     ...
21     
22     若是都是false，就执行语句体n+1。*/

if和三元表达式的区别：

1. 三元表达式写出来的，if-else必定写的出来。
2. if-else写出来的，三元表达式不必定写出来。

switch case（选择结构）

switch case 语句判断一个变量与一系列值中某个值是否相等，每一个值称为一个分支。
格式以下：

 1    switch语句的格式
 2         switch(表达式){
 3             case 值1:
 4                 语句体1;
 5                 break;
 6             case 值2:
 7                 语句体2;
 8                 break;
 9             case 值3:
10                 语句体3;
11                 break;
12             ....
13             default：    
14                 语句体n+1;
15                 break;
16         }
17     /*    switch语句的格式解释
18     (1):switch表示这是switch语句
19         表达式的取值：byte,short,int,char
20         JDK5之后能够是枚举(什么是枚举，之后再讲)
21         JDK7之后能够是String
22     (2):case后面跟的是要和表达式进行比较的值
23     (3):语句体部分能够是一条或多条语句
24     (4):break表示中断，结束的意思，能够结束switch语句
25     (5):default语句表示全部状况都不匹配的时候，就执行该处的内容，和if语句的else类似*/
26     /*执行流程
27     先计算表达式的值
28     而后和case后面的匹配，若是匹配成功就执行对应的语句，遇到break就会结束,不然执行default控制的语句*/

面试题：byte能够做为switch的表达式吗?
long能够做为switch的表达式吗?
String能够做为switch的表达式吗?

switch 语句中的变量类型能够是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
因此，byte、String都可以做为switch的表达式，而long不能够做为switch的表达式。

for（循环结构）

for循环执行的次数是在执行前就肯定的。
格式以下：

 1  for(初始化表达式语句;判断条件语句;控制条件语句) {
 2         循环体语句;
 3     }
 4     //注意事项：初始化表达式语句只执行一次
 5     /*执行流程：
 6     a:执行初始化表达式语句
 7     b:执行判断条件语句,看其返回值是true仍是false
 8         若是是true，就继续执行
 9         若是是false，就结束循环
10     c:执行循环体语句;
11     d:执行控制条件语句
12     e:回到B继续。*/
13     //循环嵌套以后，外层循环控制行数，里层循环控制列数

for循环的经典算法（水仙花数，星星三角形，九九乘法表）

• 水仙花数

所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数自己。
举例：153就是一个水仙花数。
153 = 111 + 555 + 333 = 1 + 125 + 27 = 153

 1    public class FlowerNumber {
 2                 public static void main(String args[]){
 3                     int a;
 4                     int b;
 5                     int c;
 6                     for (int i = 100 ; i <= 999 ; i++){
 7                        /*for (a = 1 ; a <= 9 ; a ++){
 8                             for (b = 0 ; b <= 9 ; b++){
 9                                 for (c = 0 ; c <= 9 ; c++){
10                                     if ((a * a * a) + (b * b * b) + (c * c * c) == a * 100 + b * 10 + c && i == a * 100 + b * 10 + c){
11                                         System.out.println(a * 100 + b * 10 + c);
12                                     }
13                                 }
14                             }
15                         }*//* 方法一  循环嵌套法*/
16                        /*a = (i / 100);
17                        b = (i % 100) / 10;
18                        c = (i % 10);
19                        if ((a * a * a) + (b * b * b) + (c * c * c) == a * 100 + b * 10 + c){
20                            System.out.println(i);
21                        }*//*方法二 取位数法*/
22                     }
23                 }
24             }

• 星星三角形

用*绘制一个直角三角形（5x5）。
代码以下：

1          public class PaintStar {
2         public static void main(String args[]){
3             for (int i = 0 ; i < 5 ; i++){
4                 for (int j = 0 ; j <= i ; j++){
5                     System.out.print("*");
6                 }
7                 System.out.println();
8             }
9         } }

• 九九乘法表

绘制一个九九乘法表。
代码以下：

 public class chengfabiao {
            public static void main(String args[]){
                for (int i = 1 ; i < 10 ; i++){
                    for (int j = 1 ; j <= i ; j++){
                        System.out.print(j + "*" + i + "=" + (j * i) + "\t");
                    }
                    System.out.println();
                }
            }
        }

while（循环结构）

while是最基本的循环。
格式为：

 1      初始化条件语句;
 2             while(判断条件语句) {
 3                  循环体语句;
 4                  控制条件语句;
 5            }
 6     /*执行流程：
 7     a:执行初始化条件语句;
 8     b:执行判断条件语句,看其返回值是true仍是false
 9         若是是true，就继续执行
10         若是是false，就结束循环
11     c:执行循环体语句;
12     d:执行控制条件语句
13     e:回到b继续。*/

do while（循环结构）

对于 while 语句而言，若是不知足条件，则不能进入循环。但有时候咱们须要即便不知足条件，也至少执行一次。
do…while 循环和 while 循环类似，不一样的是，do…while 循环至少会执行一次。

 1     初始化条件语句;
 2             do {
 3                 循环体语句;
 4                 控制条件语句;
 5             }while(判断条件语句);
 6     /*执行流程：
 7     a:执行初始化条件语句;
 8     b:执行循环体语句;
 9     c:执行控制条件语句;
10     d:执行判断条件语句,看其返回值是true仍是false
11         若是是true，就继续执行
12         若是是false，就结束循环
13     e:回到b继续。*/

三种循环结构的区别

1. do…while循环至少执行一次循环体。而for,while循环必须先判断条件是否成立，而后决定是否执行循环体语句。
2. A： 若是你想在循环结束后，继续使用控制条件的那个变量，用while循环，不然用for循环。不知道用for循环。由于变量及早的从内存中消失，能够提升内存的使用效率。
3. B：建议优先考虑for循环，而后是while循环 ，最后是do…while循环。

break

中断循环。能够用在Switch语句，也能够用在for，while循环中，用来结束循环。若离开了使用场景（switch，for，while）则没有意义。若是有循环嵌套，break影响的是最近的循环.

例题：试判断输出结果

1     for (int i=0; i<3; i++) {
2     for (int j=0; j<3; j++) {
3     if (i == j) {
4     break;
5     }
6     System.out.println("i=" + i + ", j=" + j);
7     }
8     }

解：①结果：i=1, j=0
i=2, j=0
i=2, j=1
②（1）第一次外层for循环：i=0,由于0<3，因此执行内层的for循环。
第一次内层for循环：i=0,j=0，由于0 == 0，因此结束循环。
（2）第二次外层for循环：i=1,由于1<3，因此执行内层的for循环。
第一次内层for循环：i=1,j=0，由于1！=0，因此输出i=1,j=0。
第二次内层for循环：i=1,j=1，由于1 == 0，因此结束循环。
（3）第三次外层for循环：i=2,由于2<3，因此执行内层的for循环。
第一次内层for循环：i=2,j=0，由于2！=0，因此输出i=2,j=0。
第二次内层for循环：i=2,j=1，由于2！=1，因此输出i=2,j=1。
第三次内层for循环：i=2,j=2，由于2==2，因此结束循环。
（4）第四次外层for循环：i=3,由于3=3，因此结束循环。

continue

用在循环场景当中，能够跳过部分循环而不终端，离开循环场景后无心义。

例题：试判断输出结果

1 for (int i=0; i<3; i++) {
2     for (int j=0; j<3; j++) {
3     if (i == j) {
4     continue;
5     }
6     System.out.println("i=" + i + ", j=" + j);
7     }
8     }

解：①结果：i=0, j=1i=0, j=2i=1, j=0i=1, j=2i=2, j=0i=2, j=1②（1）第一次外层for循环：i=0,由于0<3，因此执行内层的for循环。第一次内层for循环：i=0,j=0，由于0 == 0，因此跳过这次循环。第二次内层for循环：i=0,j=1，由于0！=1，因此输出i=0,j=1。第三次内层for循环：i=0,j=2，由于0！=2，因此输出i=0,j=2。（2）第二次外层for循环：i=1,由于1<3，因此执行内层的for循环。第一次内层for循环：i=1,j=0，由于1！=0，因此输出i=1,j=0。第二次内层for循环：i=1,j=1，由于1 == 1，因此跳过这次循环。第三次内层for循环：i=1,j=2，由于1！=2，因此输出i=1,j=2。（3）第三次外层for循环：i=2,由于2<3，因此执行内层的for循环。第一次内层for循环：i=2,j=0，由于2！=0，因此输出i=2,j=0。第二次内层for循环：i=2,j=1，由于2！=1，因此输出i=2,j=1。第三次内层for循环：i=2,j=2，由于2==2，因此跳过这次循环。（4）第四次外层for循环：i=3,由于3=3，因此结束循环。