流程控制语句

public static void main(String[] args) {

    // 1.获取输入的时（hour）、分（minute）、秒（second）

    Scanner input = new Scanner(System.in);

    System.out.print("请输入小时：");

    int hour = input.nextInt();

    System.out.print("请输入分钟：");

    int minute = input.nextInt();

    System.out.print("请输入秒：");

    int second = input.nextInt();

    // 2.获取输入时间的下一秒

    second++;

    if(60 == second) {

       second = 0;

       minute++;

       if(60 == minute) {

           minute = 0;

           hour++;

           if(24 == hour) {

              hour = 0;

           }

       }

    }

    // 3.对时分秒进行格式化操作

    String hourStr = hour + ""; // hour = 9

    if(hour < 10) {

       hourStr = "0" + hour; // hourStr = "09"

    }

    String minuteStr = minute + "";

    if(minute < 10) {

       minuteStr = "0" + minute;

    }

    String secondStr = second + "";

    if(second < 10) {

       secondStr = "0" + second;

    }

    // 输出当前时间的下一秒

    System.out.println(hourStr + ":" + minuteStr + ":" + secondStr);

}

1.1.4 if选择结构总结

如果if选择结构只需执行一条语句时，那么可以省略{}；如果需要执行多条语句，那么就是不能省略{}。为了提高代码的易读性，建议不要省略{}。
{}中的代码语句也称为代码块，在代码块定义的常量或变量的作用域仅限于代码块中，在代码块之外不能被使用。
能用if多选择结构就不要用if单选择结构，因为if多选择结构的效率要高于if单选择结构。
在if选择结构中还可以嵌套别的选择结构或循环结构。

1.2switch多选结构

1.2.1 switch多选结构

使用switch语句来选择要执行的代码块，与if条件分支语句比较类似。

【语法结构】

switch (表达式) {

case 常量1:

语句序列;

[break;]

case 常量2:

语句序列;

[break;]

case 常量3:

语句序列;

[break; ]

……

[default:]

默认语句;

[break;]

}

【工作原理】

switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。与任一case值不匹配，则进入default语句(如果存在default语句的情况)。

【注意事项】

switch()中的数据类型只能为：byte、short、int、char、String（JDK7）和枚举(后面会学习)。
case后面必须是常量，并且常量的类型应该和switch()中的数据类型保持一致。

并且不允许有重复的case值。

break用于跳出switch语句，根据需求我们我们可以省略break，

如果没有break, 一旦进入case,导致后面的所有case都能进入, 直到遇到break或switch结束。

default可以省略，但是最好不要省略，除非case能匹配所有的可能性。

case和default的是无序的，不过default只能最后执行或不执行。

【随堂练习】

输入一个整数,对应的显示出星期几, 例如: 输入“1”,输出为“星期一” 。
接收一个人的成绩, 如果成绩为: 90(包含)到100(包含)输出优秀, 70(包含)到90输出良好, 60(包含)到70输出及格, 60分以下输出不及格。
查询水果的价格，根据输入水果(fruit)的名字，输出对应的水果的价格，例如苹果6块/斤，香蕉3元/斤，榴莲20元/斤，西瓜0.8元/斤。

1.2.2 switch和if的区别

switch：建议判断固定值的时候用。

if：建议判断区间或范围的时候用,对运算结果是boolean类型的表达式进行判断。

注意：用switch能做的，用if都能做，但反过来则不行。

2.循环结构

2.1 for循环结构

【语法格式】

for(初始化表达式; 循环条件表达式; 循环后的操作表达式) {

执行语句;

}

重点：掌握for循环的执行顺序。初始化表达式最先执行，并且在循环过程中只执行一次。

【随堂练习】

输出0(包含)到100(包含)之间的数, 分别以递增和递减的方式实现；
输出1到100之间的奇数和偶数；
输入一个正整数n，计算1+2+3+…+n的和；
输入一个正整数n，计算1-2+3-4+5-6+…-(n-1)+n的和；
输出1到1000之间既能被5整除又能被3整除的数，并且每行输出5个。
求100到999之间的水仙花数。水仙花数的每个位上的数字的3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。
编程找出四位整数abcd中满足下述关系的数，(ab+cd)*(ab+cd)=abcd（例如：(20 + 25) * (20 + 25)= 2025）。

2.2 while循环结构

【语法格式】

while (布尔表达式) {

执行语句;

}

while循环和for循环比较类似，while循环会在指定条件为真的时循环执行代码块。

2.3 do-while循环结构

【语法结构】

do {

执行语句;

} while(条件表达式) ;

先执行循环体，然后判断布尔表达式，do-while循环循环体至少执行一次。

【随堂练习】

[难]输入一个正整数，然后把该正整数转化为二进制。

难点1：把正整数转化为二进制，假设输入的真整数为num=20

第一趟：bit = num % 2; num /= 2; --> num = 10, bit = 0

第二趟：bit = num % 2; num /= 2; --> num = 5, bit = 0

第三趟：bit = num % 2; num /= 2; --> num = 2, bit = 1

第四趟：bit = num % 2; num /= 2; --> num = 1, bit = 0

第五趟：bit = num % 2; num /= 2; --> num = 0, bit = 1

循环的次数到低是多少呢？？？不确定，所以采用死循环。

什么时候跳出循环，当num的值为0时跳出循环。

难点2：拼接二进制位，使用int类型的变量保存二进制

定义一个result变量来保存二进制，result初始值为0

第一趟：bit = 0 result += bit; -->result = 0

第二趟：bit = 0 bit = bit*10, result += bit; -->result = 0

第三趟：bit = 1 bit = bit*10*10, result += bit; -->result = 100

第四趟：bit = 0 bit = bit*10*10*10, result += bit; -->result = 100

第五趟：bit = 1 bit = bit*10*10*10*10, result += bit; -->result = 10100

public static void main(String[] args) {

    // 定义一个变量，然后把该变量的值转换为二进制

    int num = 20;

    // 用于保存获取到的二进制

    int result = 0;

    // 用于保存while循环执行的次数

    int index = 0;

    while(true) {

       // 获取二进制位

       int bit = num % 2;

       num /= 2;

       // 通过int类型变量来保存二进制的值

        for(int i = 0; i < index; i++) {

           bit *= 10;

       }

       result += bit;

       // while循环每执行一次，index递增

       index++;  

       // 当num的值为0时，跳出循环

       if(0 == num) {

           break;

       }

    }

    System.out.println(result);

}

2.4 break和continue详解

2.4.1 break语句

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

适用于switch语句和循环语句中。当break作用于for循环上， “循环后的操作表达式”也不会执行。

注意：break之后不允许书写别的代码语句，因为break会跳出当前循环或switch，那么break之后的代码永远不会执行。

2.4.2 continue语句

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

只适用于循环语句中。

2.4.3 带标签的break和continue

goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用(Java没有goto)。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子，那就是带标签的break和continue。

“标签”是指后面跟一个冒号的标识符，例如：“label:”。对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

【示例】

outer: for(int i = 0; i < 4; i++) {

for(int j = 0; j < 5; j++) {

if (j == 1) {

break outer;

}

【随堂练习】

使用continue实现输出1到100之间能被5整除的数。
韩信点兵，三人一组余两人，五人一组余三人，七人一组余四人，请问最少需要多少士兵。
[难]输入一个任意整数，判断它是否为质数，如果是质数就输出“是质数”，否则输出‘不是质数’。质数：除了1和它本身之外,不能被其他数整除的正整数称质数。

实现步骤：

1)通过Scanner获取一个正整数, 假设正整数为num。

2)通过循环获得[2, num)之间所有的整数，假设循环变量为i。

3)在循环体内部判断num是否能被i整除(：num不能被[2, num)之间的数整除)。

实现方案：

方案一：采用假设法，每次判断之前先假设是一个质数。

a)先假设num是一个质数，设置flag标记的值为true

b)在循环体中，如果num%i==0，则推翻假设，设置flag标记的值为false，同时跳出循环

c)在循环之外,判断flag标记的值，如果flag值依旧为true，则证明是一个质数，否则证明不是一个质数。

public static void main(String[] args) {

// 1.通过Scanner获取一个正整数

    Scanner input = new Scanner(System.in);

    System.out.print("请输入一个正整数：");

    int num = input.nextInt();  

    // 2.通过循环获得[2, num)之间所有的整数

    // 在判断num是否是质数之前，先假设num是一个质数

    boolean flag = true;

    for(int i = 2; i < num; i++) {

       if(num % i == 0) {

           // 推翻假设，证明num不是一个质数

           flag = false;

           // 此处既然已知num不是一个质数，则后续循环判断也没必要执行，跳出循环即可

           break;

       }

    }

    // 在循环之后，判断flag的值。



    if(flag) { // flag值为true，则证明假设成立，num就是一个质数

       System.out.println("num是一个质数， num=" + num);

    }

    else { // flag值为false，则证明假设不成立，num不是一个质数！

       System.out.println("num不是一个质数， num=" + num);

    }

}

方案二：通过分析for循环的执行顺序，从而判断num是否为质数！

循环执行完毕，如果循环变量i的值等于num，则证明循环体中num%i==0这个条件一直不成立，从而也就证明num是一个质数。

循环执行完毕，如果循环变量i的值不等于num，则证明执行某一趟循环时num%i==0成立，从而也就证明num不是一个质数。

public static void main(String[] args) {

    // 1.通过Scanner获取一个正整数

    Scanner input = new Scanner(System.in);

    System.out.print("请输入一个正整数：");

    int num = input.nextInt();

    // 2.通过循环获得[2, num)之间所有的整数

    int i = 2;

    for (; i < num; i++) {

       if(num % i == 0) { // 当num能被i整除，则跳出循环

           break;

       }

    }

    // 3.判断i的取值，从而确定num是否是质数

    if(i == num) { // 则证明循环正常执行完毕，没有执行跳出循环操作

       System.out.println("num是一个质数， num=" + num);

    }else{ // 证明循环非正常执行完毕，有执行break循环跳出的操作

       System.out.println("num不是一个质数， num=" + num);

    }

}

2.5 while与for的区别

for和while的区别：

for循环能做的事情while循环都可以实现，使用循环的时候for和while都可以选择。

建议一下条件使用while循环：

1.循环结束后循环变量还需要参与运算，那么建议使用while循。

2.不确定循环次数的时候，建议使用while循环。

2.6嵌套循环

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

多重循环执行过程：外层循环变量变化一次，内层循环变量要变化一遍。

【随堂练习】

1、在控制台先打印矩形，然后再打印平行四边形，再然后打印等腰三角形。

2、使用嵌套循环实现九九乘法表。

3、[难]输入0-9之间的一个数，输出数字构成的1~5位整数的和，如输入2，则计算出2 + 22 + 222 + 2222 + 22222之和。

实现步骤：

1.获得[0, 9]之间的正整数，假设输入的正整数num=5

2.获得5,55,555,5555,5555

定义一个变量result，并设置result的初始值为0

第一趟：result *= 10; result += num; --> result = 5

第二趟：result *= 10; result += num; --> result = 55

第三趟：result *= 10; result += num; --> result = 555

第四趟：result *= 10; result += num; --> result = 5555

第五趟：result *= 10; result += num; --> result = 55555

因为每一趟的代码都是一模一样，所以我们使用循环来实现，循环的次数为：5次

3.定义一个变量，用于累加5,55,555,5555,5555之和

public static void main(String[] args) {

    // 1.获得[0, 9]之间的正整数

    Scanner input = new Scanner(System.in);

    System.out.print("请输入[0, 9]之间的整数：");

    int num = input.nextInt();

    // 2.获得5,55,555,5555,5555

    int result = 0, sum = 0;

    // 每一趟循环，要求分别得到：5,55,555,5555,5555

    for(int i = 0; i < 5; i++) {

       result *= 10;

       result += num;

       // 3.用于累加5,55,555,5555,5555之和

       sum += result;

    }

    System.out.println("sum:" + sum);

}

4、[难]搬砖问题：36块砖，36个人搬，男搬4块，女搬3块，两个小孩搬1块，要求一次搬完，

问需要男、女、小孩各多少人？

思路分析：

条件：男人 + 女人 + 小孩 == 36 && 男人搬砖数量 + 女人搬砖数量 + 小孩搬砖数量 == 36

我们只需列举出男人、女人和小孩的人数区间范围，然后计算机依次去判断匹配即可！

男人的取值范围？？？[0, 9]

女人的取值范围？？？[0, 12]

小孩的取值范围？？？[0, 36]

public static void main(String[] args) {

    // 男人的取值范围

    for(int x = 0; x <= 9; x++) {

       // 女人的取值范围

       for(int y = 0; y <= 12; y++) {

           // 小孩的取值范围

           for(int z = 0; z <= 36; z+=2) { // 此处小孩数量为偶数个

              // 找到符合条件的人数

              if(x + y + z == 36 && x*4 + y*3 + z/2 == 36) {

                  System.out.println("x=" + x + ", y=" + y + ", z=" + z);

              }

           }

       }

    }  

}

5、[难]假如有一对小兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，请问每个月的兔子总数为多少对？（假设到24个月）

思路分析：

第一月第二月第三月第四月第五月第六月

小兔子 1 1 1 2 3 5

老兔子 0 0 1 1 2 3

总兔子 1 1 2 3 5 8

规律：当前月份兔子总数 = 上个月兔子总数 + 上上个月兔子总数

第一月和第二月的兔子总数都是为1对，然后第三月到第二十四月的兔子数可以通过规律来获得

获取第三个月到第二十四个月之间每个月份的兔子数，应该使用循环来实现。循环的次数22次，可以从[3, 24]之间循环。

public static void main(String[] args) {

    // 上上个月的兔子总数

    int first = 1; // 初始值为第一个月的兔子总数

    // 上个月兔子总数

    int second = 1; // 初始值为第二个月的兔子总数

    // 通过循环，获取第三个月到第二十四个月之间的兔子总数

    for(int i = 3; i <= 24; i++) {

       // 假设此处获取的是第i月的兔子总数

       // i月兔子总数 = i-2个月兔子总数  + i-1月兔子总数

       int result = first + second; // result = 2

       // 更新first和second的值,为获取下一个月做准备

       first = second;

       second = result;        

System.out.println("第" + i + "个月兔子数：" + result);

    }

}

6、[难]中国古代数学家研究出了计算圆周率最简单的办法: PI=4/1-4/3+4/5-4/7+4/9-4/11+4/13-4/15+4/17...... 这个算式的结果会无限接近于圆周率的值,我国古代数学家祖冲之计算出,圆周率在3.1415926和3.1415927之间,请编程计算,要想得到这样的结果,他要经过多少次...

思路分析:

因为不确定需要计算多少次，所以采用死循环！假设循环变量为i，初始值为0

当计算出来的圆周率在：3.1415926到3.1415927之间，则跳出死循环

分析：PI=4/1-4/3+4/5-4/7+4/9-4/11+4/13-4/15+4/17......

发现分子永远为4，分母规律为：2*i+1

另外，当循环变量为偶数时，做累加操作；当循环变量为奇数时，做累减操作！

public static void main(String[] args) {

    // 定义一个变量，用于保存计算出来的圆周率

    double PI = 0;

    // 定义一个循环变量，初始值为0

    int index = 0;

    // 定义一个死循环，用于计算PI的取值

    while(true) {

       // 计算圆周率的操作

       if(index % 2 == 0) { // 偶数

           PI += 4.0/(2*index+1);

       } else { // 奇数

           PI -= 4.0/(2*index+1);

       }

       // 循环变量累加

       index++;

       // 满足PI在3.1415926到3.1415927之间，则跳出死循环

       if(PI >= 3.1415926 && PI <= 3.1415927) {

           System.out.println(index);

           break;

       }

    }

}

3.方法(method)

3.1什么是方法

方法就是定义在类中的具有特定功能的一段独立小程序，用来完成某个功能操作。在某些语言中方法也称为函数或者过程。

特殊的main方法，该方法是程序的入口，由虚拟机来调用执行。在日常的开发中，不可能把程序的所有功能都放到main方法中，我们需要定义其它的方法来完成指定的功能，需要完成该功能时只需要调用方法即可。

3.2方法声明&调用

3.2.1方法声明格式

修饰符返回值类型方法名（参数类型参数名1，参数类型参数名2，……）{

执行语句;
return 返回值；
}

方法格式说明：

修饰符，用于控制方法的访问权限（后面的课程会细讲）。
返回值类型，方法需要返回值的数据类型，如无返回值，必须声明返回值类型为void。
方法名，方法的名字，要求必须符合标识符规范，并且采用小驼峰命名法则。
形参列表，由参数类型和参数名组成，形参可以为任意多个，用于给方法内部传递数据。
执行语句，书写方法需要实现的功能操作。
返回值，如果定义了返回值类型，那么返回值和返回值类型必须保持一致；如果定义的返回值类型为void，那么需要省略返回值，也就是直接返回return ;即可

注意：当方法返回值类型为void时，还可以省略retun;

3.2.2方法调用格式

方法名(实际参数1, 实际参数2, ……);

实际参数（简称实参）：传递给形式参数的具体数值，对应着形式参数（简称形参）。

注意事项：

形式参数（形参）和实际参数（实参）的类型和个数必须一一对应。
在方法中只能调用方法，不可以在方法内部再定义方法。
当方法有返回值类型时，可以用一个变量用于接收方法的返回值，该变量的类型必须和方法返回值类型保持一致。

3.3方法的运用

方法的使用，首先明确两个需求：

明确要定义的功能最后的结果是什么？
明确在定义该功能的过程中，是否需要未知内容参与运算？

方法的使用分为两个步骤：

定义方法
调用方法

定义方法，根据是否有参数列表、是否有返回值，可将定义方法分为四类：

无参无返回值方法
无参有返回值方法
有参无返回值方法
有参带返回值方法

调用方法，根据方法是否有返回值，可将调用方法分为两类：

有返回值方法，可以用一个变量来接收返回值，也可以忽略返回值。
无返回值方法，不能用一个变量来接收方法的void返回值。

3.3.1无参无返回值方法

需求：在方法中输出“hello world”。

分析：不需要参数和返回值，应该选用无参无返回值方法。

【示例】

// 需求：在方法中输出“hello world”。

public static void main(String[] args) {

    // 调用方法

    show();

}

// 声明方法：无参无返回值方法

public static void show() {

    System.out.println("hello world");

}

3.3.2无参有返回值方法

需求：调用方法获得常量3+ 4的和。

分析：不需要外界传入参数，但是需要返回常量3+4之和。

【示例】

// 需求：调用方法获得常量3+4的和。

public static void main(String[] args) {

    // 调用方法:可以选择用一个变量接收返回值，也可以忽略返回值

    int num = add(); // 接收返回值

    add(); // 忽略返回值

}

// 声明方法：无参有返回值方法

public static int add() {

    return 3 + 4;

}

3.3.3有参无返回值方法

需求：在方法中输出指定两个int变量的和。

分析：需要外界传入两个int类型的参数，但不需要返回值。

【示例】

// 需求：在方法中输出指定两个int变量的和。

public static void main(String[] args) {

    // 定义两个变量

    int a = 3, b = 4;

    // 调用方法

    add(a, b);

}

// 声明方法：有参无返回值方法

public static void add(int num1, int num2) {

    int sum = num1 + num2;

    System.out.println("sum: " + sum);

}

3.3.4有参有返回值方法

需求：调用方法获得指定两个double变量的和。

分析：需要外界传入两个double类型的形参，并返回两个double类型形参之和。

【示例】

// 需求：调用方法获得指定两个double变量的和。

public static void main(String[] args) {

    // 定义两个变量

    double a = 3, b = 4;

    // 调用方法:可以选择用一个变量接收返回值，也可以忽略返回值

    double sum = add(a, b); // 接收返回值

    add(a, b); // 忽略返回值

}

// 声明方法：有参有返回值方法

public static double add(double num1, double num2) {

    return num1 + num2;

}

3.4方法调用过程

重点调用方法的内存图分析，课堂上详解。

3.5方法的重载

3.5.1重载的概念

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

核心为两同两不同：

- 同一个类，同一个方法名

- 参数列表不同（类型、个数）

3.5.2重载的特点

返回值不同不构成方法的重载。

形参的名称不同，不构成方法的重载。

方法修饰符不同，不构成方法的重载。

注意：重载的方法，实际是完全不同的方法！只是方法名称相同而已！

3.5.3重载的好处

查看JDK文档中System.out.println()方法，发现共有10个println()方法构成了“重载关系”，如下图：

方法重载通常用来命名一组功能相似的方法，这样做减少了方法名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。

冯宝宝^

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
流程控制语句

第三章：流程控制语句................................................................................................................. 21.选择结构...........................................................................................................................
复制链接

扫一扫