[03]java中的方法以及控制语句

00 Java中的语句块

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

代码中的语句:

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

每个方块就代表一个语句块,从中可以看出语句块的范围以及关系

01 Java中的方法

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

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

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

方法的调用方式：

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

方法的详细说明

1. 形式参数：在方法声明时用于接收外界传入的数据。

2. 实参：调用方法时实际传给方法的数据。

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

4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为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("超超哥哥和java...");
    }
}

注意事项

  1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。

  2. return 语句终止方法的运行并指定要返回的数据。

  3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：

  4. 基本类型传递的是该数据值的copy值。

  5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。

01.1 Java中方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。

雷区

  重载的方法，实际是完全不同的方法，只是名称相同而已!

  构成方法重载的条件：

  1.不同的含义：形参类型、形参个数、形参顺序不同

  2.只有返回值不同不构成方法的重载

  如：

//返回值不同不构成重载
int a(String str){}与 void a(String str){}
//只有形参名称不同是不构成方法重载的
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;
    }
}

02 Java中控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。

顺序结构

“顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；

选择结构

“选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；

循环结构

“循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。

其实生活中的各种事情都可以用这几种结构来解释,编程的思想一定的顺从人类本身的思想,不会违反的来

03 Java中选择语句

选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。

主要的选择结构有：if选择结构和switch多选择结构。有如下结构：

• if单选择结构
• if-else双选择结构
• if-else if-else多选择结构
• switch结构

03.1 Java选择语句中的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语句不写{}，则只能作用于后面的第一条语句.所以强烈建议，任何时候都写上{}，即使里面只有一句话！

03.2 Java选择语句中的if-else双选择结构

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

当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是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);
        }
    }
}

日常我们使用的时候还会有下面这种使用方法:
用条件运算符代替if-else

public class Test4 {
    public static void main(String[] args) {
        int a=2;
        int b=3;
        System.out.println((a<b)?a:b);
    }
}

03.3 Java选择语句中的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的结构来对比,就是每次不满足布尔表达式的时候,进入else的语句块后会再做判断而不是执行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("老寿星， 古来稀！");
        }
    }
}

03.4 Java选择语句中的switch多选择结构

switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
 语句序列2;
[break];
     … … …      … …
[default:
 默认语句;]
}

switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。

要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。

个人理解:实际上就是对号入座,比如这样说:

我的座位号是7

我就按照我的位置去逐排的去找,找到了,就坐下,找不到就坐备用席

switch (我的座位号是7) {
case 座位号1:
已经就坐到座位号1;
[break];
case 座位号2:
 已经就坐到座位号2;
[break];
     … … …      … …
[default:
 没有我的座位号,只好坐在备用的位置;]
}

配套练习

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("辅音");
        }
    }
}

04 Java中循环结构

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

当型：

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

直到型：

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

04.1 Java循环结构中的while循环

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

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

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

配套练习:
练习中的while(i<=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);
    }
}

04.2 Java循环结构中的do-while循环

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

简单的来说就是先执行一次循环体,然后再做判断

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

配套练习

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的区别

浓缩成一句话来说就是又没有先执行语句块,

while:没有先执行语句块,因为是先判断后再根据条件看是否执行

do-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);
    }
}

4.3 Java循环结构中的for循环

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

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

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

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

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

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

  for循环结构的流程图如图3-18所示。

配套练习

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();
    }
}

04.4 Java循环结构中的嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层

配套代码

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();
        }
    }
}

上面是一个九九乘法表

很多人再看这个的时候一般都会乱,主要是不理解其中的逻辑

实际上就是外面第一层for执行后就在执行内部的for语句,知道内部的for语句不在执行了,再进行外面的for语句 之后的内容就重复执行,知道外部的for语句不再进行执行技巧: 如果不能理解的话可以去bil上搜索java断点 通过这种方式可以很直观的看到程序运行的顺序,也可以帮助大家更快的理解其中的运行原理.

04.5 Java循环结构中的break语句和continue语句

break

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

continue

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

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

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

配套解释-break

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

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();
            }
        }
    }
}

## 00 Java中的语句块
语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
**代码中的语句:**
```javapublic class Test19 {    public static void main(String[] args) {        int n;        int a;        {            int k;            int n; //编译错误：不能重复定义变量n        } //变量k的作用域到此为止    }}```每个方块就代表一个语句块,从中可以看出语句块的范围以及关系

## 01 Java中的方法
方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。
```java[修饰符1  修饰符2  …]   返回值类型    方法名(形式参数列表){    Java语句；… … … }```   方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法的调用方式：
对象名.方法名(实参列表)
 方法的详细说明
1. 形式参数：在方法声明时用于接收外界传入的数据。
2. 实参：调用方法时实际传给方法的数据。
3. 返回值：方法在执行完毕后返还给调用它的环境的数据。
4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
**方法的声明和调用**
```javapublic 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("超超哥哥和java...");    }}```
**注意事项**
      1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
      2. return 语句终止方法的运行并指定要返回的数据。
      3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
      4. 基本类型传递的是该数据值的copy值。
      5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。

## 01.1 Java中方法的重载
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。
**雷区**
      重载的方法，实际是完全不同的方法，只是名称相同而已!
      构成方法重载的条件：
      1.不同的含义：形参类型、形参个数、形参顺序不同
      2.只有返回值不同不构成方法的重载
      如：
```java//返回值不同不构成重载int a(String str){}与 void a(String str){} //只有形参名称不同是不构成方法重载的int a(String str){}与int a(String s){}
```**正确方法重载方式**```javapublic 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;    }  }```
## 02 Java中控制语句
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。
**顺序结构**
 “顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；
**选择结构**
“选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；
**循环结构**
 “循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。
其实生活中的各种事情都可以用这几种结构来解释,编程的思想一定的顺从人类本身的思想,不会违反的来

## 03 Java中选择语句
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。
主要的选择结构有：if选择结构和switch多选择结构。有如下结构：
 - if单选择结构 - if-else双选择结构 - if-else if-else多选择结构 - switch结构
## 03.1 Java选择语句中的if单结构
```javaif(布尔表达式){语句块}```
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示:
**配套练习:**
```javapublic 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语句不写{}，则只能作用于后面的第一条语句.所以强烈建议，任何时候都写上{}，即使里面只有一句话！

## 03.2 Java选择语句中的if-else双选择结构
```javaif(布尔表达式){ 语句块1}else{       语句块2}```
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示。

**配套练习:**
```javapublic 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);        }    }}```
**日常我们使用的时候还会有下面这种使用方法:用条件运算符代替if-else**
```javapublic class Test4 {    public static void main(String[] args) {        int a=2;        int b=3;        System.out.println((a<b)?a:b);    }}```

## 03.3 Java选择语句中的if-else if-else多选择结构
```javaif(布尔表达式1) {语句块1;} else if(布尔表达式2) {语句块2;}……else if(布尔表达式n){    语句块n;} else {    语句块n+1;}```
当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图所示。

根据个人的理解来看实际上就是 每次都做判断 比如做个性别分类:
一个人妖对其性别分类(下面是中文解释):
```java来了个人妖if(是个男人?){  输出他是个男人       //这里显然不是,所以就跳到下面} else if(是个女人?){  输出她是个女人      //这里显然不是,所以跳到下面语句块}else{  他/她是个人妖      //这里就输出了结果}```
所以和if-else的结构来对比,就是每次不满足布尔表达式的时候,进入else的语句块后会再做判断而不是执行else后面的语句块
**配套练习**
```javapublic 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("老寿星， 古来稀！");        }    }}```

## 03.4 Java选择语句中的switch多选择结构
```javaswitch (表达式) {case 值1: 语句序列1;[break];case 值2: 语句序列2;[break];     … … …      … …[default: 默认语句;]}```
switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。
要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。
个人理解:实际上就是对号入座,比如这样说:
我的座位号是7
我就按照我的位置去逐排的去找,找到了,就坐下,找不到就坐备用席
```javaswitch (我的座位号是7) {case 座位号1: 已经就坐到座位号1;[break];case 座位号2: 已经就坐到座位号2;[break];     … … …      … …[default: 没有我的座位号,只好坐在备用的位置;]}```
**配套练习**
```javapublic 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("辅音");        }    }}```

## 04 Java中循环结构
循环结构分两大类，一类是当型，一类是直到型。
 **当型：**
当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
 **直到型：**
先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。

## 04.1 Java循环结构中的while循环
```javawhile (布尔表达式) {    循环体;}```
 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。
**配套练习:练习中的while(i<=100)就是结束条件**
```javapublic 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);    }}```

## 04.2 Java循环结构中的do-while循环
```javado {        循环体;     } while(布尔表达式) ;```
简单的来说就是先执行一次循环体,然后再做判断

do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示。
**配套练习**
```javapublic 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的区别
浓缩成一句话来说就是又没有先执行语句块,
while:没有先执行语句块,因为是先判断后再根据条件看是否执行
do-while:先执行语句块,不管满足不满足do-while都会至少执行一次语句块
```javapublic 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);    }}```

## 4.3 Java循环结构中的for循环
```javafor (初始表达式; 布尔表达式; 迭代因子) {      循环体;}```
 for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
      A. 初始化部分设置循环变量的初值
      B. 条件判断部分为任意布尔表达式
      C. 迭代因子控制循环变量的增减
      for循环在执行条件判定后，先执行的循环体部分，再执行步进。
      for循环结构的流程图如图3-18所示。
**配套练习**
```javapublic 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();    }}```

## 04.4 Java循环结构中的嵌套循环
在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层
配套代码
```javapublic 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();        }    }}```
上面是一个九九乘法表
很多人再看这个的时候一般都会乱,主要是不理解其中的逻辑
实际上就是外面第一层for执行后就在执行内部的for语句,知道内部的for语句不在执行了,再进行外面的for语句 **之后的内容就重复执行,知道外部的for语句不再进行执行技巧: 如果不能理解的话可以去bil上搜索java断点  通过这种方式可以很直观的看到程序运行的顺序,也可以帮助大家更快的理解其中的运行原理.**

## 04.5 Java循环结构中的break语句和continue语句
**break**
在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
**continue**
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。(
1. continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
2. continue用在for循环中，跳到for循环的迭代因子部分。)

**配套解释-break**
```javapublic 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**
```javapublic 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();            }        }    }}```