JavaSE 03 Java基础语法（二）

1、流程控制结构

流程控制结构：控制程序执行的顺序。

分类：
⑴ 顺序结构：程序从上往下一次执行。
⑵ 分支结构：程序从两条或多条路径中选择一条去执行。
⑶ 循环结构：程序在满足一定条件基础上重复执行一段代码。
⑷ 跳转结构：改变正常程序控制流的一种结构。

2、顺序结构

Java中定义成员变量时采用合法的前向引用（先声明、赋值，后引用）。

3、分支结构

特点：⑴ 条件必须为boolean类型的值。
⑵ if 和 else 后的大括号都可以省略，默认执行第一句。

分类：⑴ 单分支 【if(){}】
语法：if (条件){
语句
}
执行顺序：如果条件成立，则执行语句；否则什么也不执行。

     ⑵ 双分支 【if(){}else{}】       语法：if (条件) {                语句1             } else {                语句2             }     执行顺序：如果条件成立，则执行语句1；否则执行语句2。     ⑶ 多重分支 【if(){}else if{}else if{}else{}】        语法：if (条件1) {                 语句1              } else if (条件2) {                 语句2              } else if (条件3) {                  语句3              } else {                  语句n              }    执行顺序：如果条件1，则执行语句1；否则判断条件2，如果成立，则执行语句2；如果不成立判断条件3，依此类推。    直到最后一个条件仍不成立，则执行语句n。

注意：⑴ else 语句块可以省略。
⑵ else if 语句块可以有多个，多个 else if 语句块可以调换顺序，语法上没有错误，但可能会影响效果。
⑶ 多重 if 和 多个单分支语句的区别：
① 多重if，可能只选择一条执行。
if () {
} else if () {
} …{
} else {
}
② 多个单分支结构，可能会有多个语句执行。
if () {
}
if () {
}
if () {
}
if () {
}
…

4、嵌套分支

一个完整的分支结构中又嵌套了定一个完整的分支结构。

if (条件) {
if (条件) {
…
} else {
…
}
} else {
…
}

执行顺序：先判断外层条件，再判断内层条件。

5、switch结构

switch (变量或表达式) {
case 常量值1:
语句1;
break;
case 常量值2:
语句2;
break;
case 常量值3:
语句3;
break;
default :
语句n;
break;
}

⒈ 执行顺序：
⑴ 先判断变量或表达式的值，从上往下依次判断各个case后的常量值，如果其中有匹配的case项，则执行后面对应的语句，直到遇见break为止。
⑵ 如果没有匹配的case项，则执行default后的语句，直到遇见break为止。
⑶ 如果没有匹配的case项，也没有default，则什么也不执行。

⒉ 语法注意事项：
⑴ default 语句块可以省略，位置也可以提前，但只能有一个，有可能影响效果。
⑵ break 可以省略，但有可能影响效果。
⑶ switch 后的变量或表达式类型只能是 byte、short、int、char、枚举、String [JDK1.7及以上版本]。
⑷ case 后只能放常量值。
⑸ case 后的常量值不能重复。

⒊ if结构 和 switch结构的对比
⑴ 凡是能用switch结构解决的，都能用if结构解决；但用if结构解决的，不一定能用switch结构解决。
⑵ if结构能够解决任何类型的分支题目。
⑶ switch结构需要满足下面的条件才能使用：
① 必须为等值判断。
② 判断的变量或表达式类型必须为 byte、short、int、char、枚举、String。
⑷ 最好是多重分支。
⑸ 同一个题目，用switch的效率比用if的效率要高。

7、输入

import java.util.Scanner; // 1.导入Scanner类多属的位置（相当于找到了卖打印机的厂家）

public class InputTest{  public static void main(String[] args){  Scanner input = new Scanner(); // 2.创建Scanner对象（相当于买了一个打印机）  String name = input.next(); // 3.调用Scanner中的某个方法（相当于使用打印机的扫描功能）String类型，保存姓名  int age = input.nextInt(); // int类型，保存年龄【必须输入有效数字】  double height = input.nextDouble(); // double类型，保存身高【必须输入有效数字】  char sex = input.next().charAt(0); // char类型，保存性别}}

8、equals 和 ==

⑴ ==
① 判断基本数据类型，相当于判断的就是左右两边的值是否相等。
② 判断引用数据类型，如String，判断的就不再是左右两边的值，而是内存地址值。
⑵ equals
判断引用数据类型，如String，用于比较两个字符串的内容是否相同。
语法：字符串1.equals(字符串2) 结果为true或false。

9、循环结构

特点：⑴ 必须具备循环条件。⑵ 必须具备循环操作。
概念：在满足一定条件的基础上，重复执行循环操作。
好处：⑴ 代码实现了重用，代码简洁。⑵ 提高了代码的维护性（代码易修改）。

10、while循环

语法：
[循环变量初始化] ①
while(循环条件){ ②
循环操作 ③
[循环变量更新] ④
}

执行顺序：先执行变量初始化【①】；然后判断循环条件【②】；如果满足条件，则执行循环操作【③】；再执行循环变量更新【④】。然后再判断循环条件【②】、【③】、【④】，直到循环条件不满足为止。

实现循环的步骤：
⑴ 情况一：直到循环的次数或者知道循环条件的范围。
① 循环模版框架：
int i = 初始值; // 初始化循环变量
while(i <= 终止值【或次数】){
// 循环操作
i++; // 循环变量更新
}
② 再去找循环操作（需要找规律）。
③ 检查循环是否能够正常的执行。

⑵ 情况二：不知道循环的次数，也没有所谓的区间
① 先去找循环操作。
② 再通过循环操作分析循环条件。
③ 套循环语法。
④ 检查能否正常运行（检查语法，如检查是否死循环）。

11、do while循环

语法：
[循环变量初始化] ①
do{
循环操作 ②
[循环变量更新] ③
}while(循环条件); ④

执行顺序：先执行循环变量初始化【①】；再执行循环操作【②】；以及循环变量更新【③】；最后判断循环条件【④】，如果条件满足，则继续执行【②】，直到不满足循环条件为止。

12、while 和 do while的对比

⑴ 相同点：
① while 和 do while都可以解决任何循环问题。
② 都具备四要素：循环变量初始化、循环操作、循环变量更新、循环条件。
③ 当第一次循环使，如果循环条件满足时，则while 和 do while的循环执行的次数一样。
⑵ 不同点：
① 语法不同。
② 执行顺序不同：
while 先判断，后执行。
do while 先执行，后判断。
③ 执行效果不同：
while 当第一次循环时，如果循环条件不满足，则不会执行。
do while 当第一次循环时，不管循环条件是否满足，都会执行循环操作。
所以：在相同的循环条件下，while 和 do while的区别是，while的循环变量的值会比do while的循环变量的值多1或者少1。
④ do while 的效率高于 while。

13、for循环

作用：简化while循环。
                              ①                    ②                    ④
语法： for(循环变量初始化；循环条件；循环变量更新){
循环操作 ③
}
执行顺序：①②③④，②③④… （和while相同）

注意：⑴ 三个表达式（①,②,④）都可以省略，但有可能造成死循环。
⑵ 两个分号必不可少。
⑶ 表达式① 和 表达式③ 可以由多个语句组成，但用逗号隔开。
⑷ 表达式①中，多条循环变量初始化的变量类型必须为同一个，且数据类型的声明只在最前面有一个。

14、while、do while、for三种循环对比

⑴ 相同点：
① 都能解决任何类型的循环题目。
② 都具备循环四要素。
⑵ 不同点：
① 是否知道次数
⒈ 知道次数
优先考虑for循环。
⒉ 不知道次数
先看是先判断还是先执行，
先判断是while，先执行是do while。
② 效率上，do while的效率最高。

15、嵌套循环

语法：
while(){
  for(;;){
  }
}

for(;;){
  do {
  } while();
}

Tip：如果外层循环的次数为m次，内层为n次，则内层实际上会执行m×n次。

16、嵌套for循环

示例 ⑴【行数和列数一样】:

模版：
for(int i = 1; i <= 行数; i++){ // 控制行数
for(int j = 1; j <= 列数; j++){ // 控制列数
System.out.print(“”); // 注意：这里不要换行
}
System.out.println(); // 注意：这里需要换行
}

示例：
int count = 5; // 行数和列数
for (int i = 1; i <= count; i++) {
for (int j = 1; j <= count; j++) {
System.out.print(“*”);
}
System.out.println();
}
打印效果：
*****
*****
*****
*****
*****

示例 ⑵【直角三角形】:

模版：
for(int i = 1; i <= 行数; i++){
for(int j = 1; j <= 每行的空格数; j++){
System.out.print(” “); // 注意：不要换行
}
for(int k = 1; k <= 每行的符号数; k++){
System.out.print(“符号”); // 注意：不要换行
}
System.out.println(); // 注意：要换行
}

示例：
int count = 5; // 行数和列数
for (int i = 1; i <= count; i++) {
for (int j = 1; j <= count - i; j++) { // 若不加j循环，则打印效果如②所示 【空格:行数减1，再倒着输出】
System.out.print(” “); // 为了美观，这里可以在后面再加一个空格
}
for (int k = 1; k <= i; k++) { // 【符号数：每行的符号数和行数相同】
System.out.print(“* “); // 同理，可以在最后追加一个空格
}
System.out.println();
}
打印效果①：
         *
       * *
     * * *
   * * * *
* * * * *
打印效果②：
*
* *
* * *
* * * *
* * * * *

示例 ⑶【金子塔】：

模版：同模版⑵，不同的是内层j循环。

示例 ①：
int count = 5; // 行数和列数
for (int i = 1; i <= count; i++) {
for (int j = 1; j <= count - i; j++) { // 【行数减1，再倒着输出】
System.out.print(” “); // 这里就是不同支出（少了一个空格）
}
for (int k = 1; k <= i; k++) { // 【每行的符号数和行数相同】
System.out.print(“* “);
}
System.out.println();
}
打印效果：
    *
   * *
  * * *
 * * * *
* * * * *

示例 ②：
int count = 5; // 行数和列数
for (int i = 1; i <= count; i++) {
for (int j = 1; j <= count - i; j++) { // 【行数减1，再倒着输出】
System.out.print(” “);
}
for (int k = 1; k <= 2 * i - 1; k++) { // 【每行的符号数等于2倍的行数再减1】
System.out.print(“* “);
}
System.out.println();
}
打印效果：
        *
      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *

示例 ⑷【倒金字塔】：

模版：
for(int i = 1; i <= 行数; i++){
for(int j = 1 ; j <= 行数 - i; j++){
System.out.print(” “);
}
for(int k = 2 * (行数 - i) + 1; k >= 1; k–){
System.out.print(“* “);
}
System.out.println();
}

示例：    int rows = 5; // 行数    for (int i = 1; i <= rows; i++) {      for (int j = 1; j <= i - 1; j++) { // 【行数减1，再倒着输出】        System.out.print("  ");      }      for (int k = 2 * (rows - i) + 1; k >= 1; k--) { // 【每行的符号数等于2倍的（行数减1），再加1】        System.out.print("* ");      }      System.out.println();    }

打印效果：
* * * * * * * * *
  * * * * * * *
     * * * * *
       * * *
          *

⑸ 总结：

① 首先分析要输出的行数。外层for循环控制行数，变量初始化值为1，循环条件为 <= 行数，循环变量更新为 迭代加1。
② 再分析是从小到大输出还是从大到小输出。内层for循环控制列数。这其中包含了符号的输出 和 空格的输出。
㈠ 如果有空格，则其输出，包含了两种情况：
⒈空格在符号的位置：在符号的左边，包含了空格，则需要在内层的符号for循环的，上边，加上空格符号for循环；在符号的右边，包含了空格，则需要在内层的符号for循环的，下边，加上空格符号for循环。
⒉空格在每行的输出量：要看每行的符号输出的量，若每行符号输出的量为从小到大，则空格的输出为从大到小，循环变量初始化为：<= 总行数 - 当前行数，循环条件为 >= 1；若每行符号输出的量为从大到小，则空格的输出为从小到大，循环变量初始化为1，循环条件为：<= 当前行数 - 1。
㈡ 符号的输出，包含了两种情况：
⒈从小到大输出，则内层的符号for循环的循环变量初始化为1。循环条件，一般为和外层for循环的循环变量值相等（即等于当前行数）；若每行列数为奇数（1、3、5…）输出，则循环条件为：<= 2 * 当前行数 - 1；若每行列数为偶数（2、4、6…）输出，则循环条件为：<= 2 * 当前行数。
⒉从大到小输出，若每行为奇数输出，则内层的符号for循环的循环条件为：>= 1。循环变量初始值：2 * (总行数 - 当前行数) + 1； 若每行为偶数输出，则循环变量初始值：2 * (总行数 - 当前行数) + 2，循环条件为：>= 1。

⑹ 做题示例：

① 打印效果：
        *
      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *
  * * * * * * *
     * * * * *
        * * *
          *

    分析：① 这是一个正金字塔下面一个倒金字塔。以正金字塔4行，倒金字塔5行为例。所以需要两个嵌套for循环。上头的嵌套for循环的外层的循环条件为 <= 4，下头的嵌套for循环的外层的循环条件为 <= 5;          for(int i = 1; i <= 4; i++){ // 【上头的正金字塔】          }          for(int a = 1; a <= 5; a++){ // 【下头的倒金字塔】          }          ② 分析:行数、空格数、符号数     行数      空格数     符号数      1          4           1      2          3           3             【正金字塔】      3          2           5      4          1           7      ------------------------      1          0           9      2          1           7      3          2           5              【倒金字塔】      4          3           3      5          4           1         这两个金字塔都在符号的左边包含空格，所以需要上头一个for循环打印空格，下头一个for循环打印符号。         正金字塔的空格是从大到小输出，所以循环变量初始化为 总行数 - 当前行数（这里需要再加1），循环条件为 >= 1；符号数是从小到大输出，且为奇数，所以循环变量初始化为 1，循环条件为 <= 2 * 当前行数 - 1。         倒金字塔的空格是从小到大输出，所以循环变量初始化为1，循环条件为 <= 当前行数 - 1；符号数是从大到小输出，所以循环变量初始化为 2  * (总行数 + 1 - 当前行数) + 1，循环条件为 >= 1。          ③ 写出for循环           int rows = 4;           for(int i = 1; i <= rows; i++){             for(int j = rows - i + 1; j >= 1; j--){               System.out.print("  ");             }             for(int k = 1; k <= 2 * i - 1; k++){               System.out.print("* ");             }             System.out.println();           }            for(int a = 1; a <= rows + 1; a++){              for(int b = 1; b <= a - 1; b++){                System.out.print("  ");              }              for(int c = 2 * (rows + 1 - a) + 1; c >= 1; c--){                System.out.print("* ");              }              System.out.println();            }

17、跳转控制结构

改变正常的程序流程。

分类：break continue return

⑴ break

中断或跳出所在的语句块，一般用在switch或循环中。作用是跳出所在的switch或跳出循环。

① switch(变量或表达式){
           case   常量1:
              语句1;
              break;
           case   常量2:
              语句2;
              break;
           default:
              语句n;
              break;
    }
② while(true){
         if(false){
          break;
         }
     }

Tips：
① break只能跳出所在的单层循环或所在的switch。
示例：
  for(){
      while(){
        if(){
          break;
        }
      }
   }
说明：可以跳出内层的while循环，无法跳出外层的for循环。
② break可以和标记搭配使用【了解】
语法：

  label : while(循环条件){    循环操作;    while(循环条件){      break : label;    }    循环变量更新;  }   说明：① 正常情况下，break只能跳出内层while循环，而添加标记【label】后，当满足内层循环break条件时，可以跳出外层while循环。  ② 标记的名字只要满足规则，就可以随便起。

⑵ continue

主要用在循环中，作用是结束本次循环，而继续执行下一次循环。

语法：一般和if搭配放在循环中，不能单独放在if或者switch等其他语句块中。否则会报错（continue cannot be used outside of a loop 【continue不能放在循环的外面】）。

示例： while(i <= 10){
              if(i >= 5){
                continue;
              }
          }

注意：① 如果放在嵌套循环中，默认作用于内层循环。
② 如果想对外层循环起作用，需要添加标记（和break类似）。
③ continue只能放在循环中。

⑶ return

作用：退出所在的方法。

⑷ break、continue、return都用于跳出或结束某个语句块，它们下面都不能直接放其他语句。因为无法访问到（Unreachable code）。

18、随机数

Math.random();会产生一个 0 <= num < 1 范围的浮点数 [0,1)
double num = Math.random();

公式：产生范围为 a~b 的随机正数
int x = (int)(Math.random() * (b - a + 1) + a);

示例：产生一个随机的两位数
分析：① 两位数的范围是10~99；② 设a = 10，b = 99；③ 带入公式中，得到：b - a + 1 = 90；④ 所以最终表达式为：(int)(Math.random() * 90 + 10);