java小白从入门到精通（基础二）

六：流程控制语句

1.作用：
一个程序他在执行的时候，各个语句的执行顺序对程序的结果是有直接影响的，所以我们必须很清楚每条语句的执行流程。并且有些时候我们需要通过控制语句的执行流程来实现我们要完成的功能。

2.流程控制语句的分类：
-顺序结构
-选择结构
-循环结构

3.顺序结构
是程序中最简单的结构，是最基本的流程控制，没有特定的语法，按照代码的先后顺序依次执行，程序中很多代码都是这样执行的。简单来说：写在前面的先执行

4.选择结构（分支结构）
-有特定的语法，代码需要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，真或假，所以就产生了选择，按照不同的选择去执行不同的代码。
-Java语言中提供了两种选择结构语句
if
switch
-选择结构之if语句：(使用是针对一个表达式结果是boolean类型的判断；针对一个范围的判断) （if 语句是可以随意嵌套的）

格式：a:   if(关系表达式){
                                       语句体;
                                     }

执行流程：先判断关系表达式，看结果是真还是假—真执行语句体，假不执行
注意：关系表达式不管在怎么复杂，结果必须是boolean类型 if语句中的语句体如果只有一条语句体，{}可以不写（建议永远不要省）；多条语句，{}必须写

  b:   if（）{
                                      语句体1;
                                         }
                                   else{
                                      语句体2;
                                         }

执行流程：先判断关系表达式，看结果是真还是假----如果是真执行语句体1；假执行语句体2。
注意： 此语句在某些情况下和三元运算符是可以相互转化的。三元运算符的操作都可以使用if语句来实现，反之不成立。
当if语句的语句体是一条输出语句的时候，就不成立。因为三元运算符是运算符，必须要有一个结果返回去。输出语句不能作为结果返回。
eg：(i%2 == 0)?System.out.println("输入的是偶数")：System.out.println("输入的是奇数")；
此写法错误！！！！！！！

 c:   if（关系表达式1）{
                                      语句体1;
                                         }
                             else if(关系表达式2){
                                      语句体2；
                                         }
                             else if(关系表达式3){
                                      语句体3；
                                         }
                                      ......
                                  else{
                                      语句体n+1;
                                         }

执行流程：先判断关系表达式1，看结果是真是假-----如果是真执行语句体1；假就继续判断关系表达式2，看结果真假，以此类推。
如果没有一个关系表达式为真就执行语句体n+1;
注意：这个代码实现了基本要求，但是存在问题，程序将来是要给用户使用的，他有时候不按套路出牌，所以在测试程序的时候，一定要考虑一些问题：
正确数据，错误数据，边界数据
if语句的 格式一：单个判断 格式二：两个判断 格式三：多个判断
例题：使用键盘录入 x 的值，计算出 y 的值 x>5 y = 3x+1; 0<x<5 y = 3x; x<0 y=3x-1;

  -选择结构之switch语句：
           格式：
                   switch(表达式){
                                   case 值一：
                                            语句体1;
                                            break;
                                   case 值二：
                                            语句体2;
                                            break;
                                   case 值三：
                                            语句体3;
                                            break;
                                   ...........
                                   default:
                                            语句体n+1;
                                            break;
                                         }  

格式说明：
switch表示这是一个switch语句，表达式的取值：byte 、short 、 int 、 char 、枚举(jdk5以后) 、 String（jdk7以后)。
case后跟的是要和表达式进行比较得值，语句体可以是1条语句，也可以是多条语句
break表示跳出switch语句，（中断）结束switch语句
default语句表示所有情况都不符合的时候就执行default处的语句，它和if语句中的else作用相似。
执行流程：
先计算表达式的值和case后的值依次进行比较，一旦发现有对应的值，就执行对应的语句，执行过程中碰到break就结束了。
如果所有的case值都与之不匹配，就执行default后的语句体。执行完成后结束switch。

/*
用switch语句 键盘录入一个数据，根据数据的值，输出对应的星期
/*

import  java.util.Scanner;
class Demo21{
public static void main(String[]args){
Scanner  sc = new Scanner(System.in);
System.out.println("请输入一个范围在1-7的数: ");
int day = sc.nextInt();
switch(day){
          case  1:
                  System.out.println("星期一");
                  break;
          case  2:
                  System.out.println("星期二");
                  break;
          case  3:
                  System.out.println("星期三");
                  break;
          case  4:
                  System.out.println("星期四");
                  break;
          case  5:
                  System.out.println("星期五");
                  break;
          case  6:
                  System.out.println("星期六");
                  break;
          case  7:
                  System.out.println("星期天");
                  break;
          default:
                  System.out.println("输入有误，请重新输入!");
                  break;
}
}
}

//break不能省，case穿透

import   java.util.Scanner;
class Demo21{
public static void main(String[] args){
int a = 3;
int b = 5;
switch(a){
      default:
           b++; 
           break;
      case 2:
           b++;
           break;
      case 3:
           b++;
           break;
}
System.out.println(b);
int a = 2;
int b = 3;
switch(a){
      default:
           b++;
      case 3:
           b++;
      case 4:
           b++;
}
System.out.println(b);
}
}

注意： case后面只能是常量，不能是变量。多个case后面的值不能出现相同的。 default 可以省略，建议不要省略。 break 也可以省略，但是也不要省略。
default语句可以出现在switch语句中的任意位置。

/*
用switch语句模拟一个选择题
分析：
先出一道题，给出选择答案
通过键盘选择你认为正确的答案
根据你的选择来判断是否选择正确
case 后可以是字符，但是Scanner却没有可以接受字符的方法
所以我们可以接受一个整数，然后把整数强转成字符。
*/

import java.util.Scanner;
class Demo22{
public static void main(String[] args){
//出题
System.out.println("请选择你最喜欢的女明星:");
System.out.println("65:迪丽热巴");
System.out.println("66:杨幂");
System.out.println("67:佟丽娅");
System.out.println("68:杨颖");

//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请选择: ");

int number = sc.nextInt();
char yourChose = (char)number;

switch(yourChose){
          case'A':
                 System.out.println("你选的是迪丽热巴");
                 break;
          case'B':
                 System.out.println("你选的是迪丽热巴");
                 break;
          case'C':
                 System.out.println("你选的是迪丽热巴");
                 break;
          case'D':
                 System.out.println("你选的是迪丽热巴");
                 break;
          default:
                 System.out.println("没有该选项");
          break;
}
}
}

练习：
/*
键盘录入字符串，判断是否有匹配的，如果有就输出该字符串，没有的话输出错误
*/

import  java.util.Scanner;
class Demo23{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串:");
String str = sc.nextLine();
switch(str){
       case "Good":
              System.out.println("Good");
              break;
       case "Bad":
              System.out.println("Bad");
              break;
       case "Study":
              System.out.println("Study");
              break;
       default:
              System.out.println("错误");
              break;
}
}
}

/*
用switch判断月份的季节
利用switch语句中的一个小特点：case穿透
*/

import  java.util.Scanner;
class Demo23{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份: ");
int month = sc.nextInt();
switch(month){       
       case 12:
       case 1:
       case 2:
              System.out.println(month+"月是冬天");
              break;
       case 3:
       case 4:
              System.out.println(month+"月是春天");
              break;
       case 6:
       case 7:
       case 8:
              System.out.println(month+"月是夏天");
              break;
       case 9:
       case 10:
       case 11:
              System.out.println(month+"月是秋天");
              break;
       default:
              System.out.println("输入有误，请重新输入!");
              break;
}
}
}

5.循环结构
循环语句可以在满足条件的情况下，反复执行某一段代码。
这个被反复执行的代码叫做 循环体语句。
当反复执行这个循环体时，需要在合适的时候结束循环，就需要把判断条件改成false，就可以结束循环，否则会一直执行下去形成了死循环。

-循环语句的组成：
初始化语句
可由一条或多条语句组成，这些语句完成了一些初始化操作
判断条件语句
是一个boolean类型表达式，由这个表达式来决定是否继续执行循环体语句
循环体语句
就是我们需要多次执行的代码
在一次循环体结束后，下一次循环判断条件执行前执行。通过控制循环条件中的变量，可以让我们的循环在适当的时候结束。
-循环语句分类：
for 循环
while 循环
do…while 循环

-for 循环
格式：for(初始化语句；判断条件语句；控制条件语句){
循环体语句；
}
执行流程：
a：先执行初始化语句
b：执行判断条件语句，看结果是真还是假
如果是真，就继续执行循环体语句
如果是假，就结束循环
c：当为真时，执行控制条件语句
d：回到b步骤继续
/
输出10次hellojava
*/

class xunhuan{
public static void main(String[] args){
int i;
for(i=1;i<10;i++){
System.out.println("Hello Java");
}
}

注意：判断条件语句不管简单还是复杂，结果是boolean类型。如果循环体语句是一条语句，{}可以省略，建议永远不要省！！！！如果是多条就不能省。

public class Demo1{
public static void main(String[] args){
int i = 0;
while (i<10){
System.out.println(i++);
}
}
}

练习：
求1-100的偶数和:
方法一：

class xunhuan{
public static void main(String[] args){
int sum = 0;
for(int i = 0;i<=100;i++){
if (i%2 ==0){
sum += i;
}
}
System.out.println(sum);
}
}

方法二：

class xunhuan{
public static void main(String[] args){
int sum = 0;
for(int i = 0;i<=100;i+=2){
sum += i;
}
System.out.println(sum);
}
}

求8的阶乘

class xunhuan{
public static void main(String[] args){
int sum = 1;
for(int i = 1;i<=8;i++){
sum *= i;
}
System.out.println(sum);
}
}

面试题：
/*
在控制台上输入所有“水仙花数“
水仙花数：指的是一个3位数，各个位上的数字的立方和(100-999)等于该数本身
eg：153 = 111+555+333 = 1+125+27 = 153
分析：如何获取个位、十位、百位的数字
比如153：
个位：153%10 = 3；
十位：153/10%10 = 5；
百位：153/100%10 = 1；
千位：i/1000%10
万位：i/10000%10
各个位上的数字的立方和等于该数本身
*/

class xunhuan{
public static void main(String[] args){
int count = 0;
for(int i=100;i<1000;i++){
int ge = i%10;
int shi = i/10%10;
int bai = i/100%10;
if(ge*ge*ge+shi*shi*shi+bai*bai*bai == i){
count++;
System.out.println(i);
}
}
System.out.println(count);
}
}

/*
统计1-1000之间满足条件的数据有多少个?并输出
条件：除3余2；除5余3；除7余2
*/

class xunhuan2{
public static void main(String[] args){
int count = 0;
for(int i=1;i<1000;i++){
if(i%3 == 2 && i%5 == 3 && i%7 ==2){
System.out.println(i);
count++;
}
}
System.out.println("共"+count+"个");
}
}

/*
在控制台上输出满足条件的五位数
条件：个位=万位；十位=千位；个位+十位+千位+万位=百位
*/

class xunhuan2{
public static void main(String[] args){
for(int i=10000;i<99999;i++){
int ge = i%10;
int shi = i/10%10;
int bai = i/100%10;
int qian = i/1000%10;
int wan = i/10000%10;
if(ge==wan && shi==qian && ge+shi+qian+wan == bai){
System.out.println(i);
}
}
}
}

-while循环
基本格式：while（判断条件语句）{
循环体语句：
}
扩展格式：
初始化语句：
while（判断条件语句）{
循环体语句：
控制条件语句：
}
练习：
/*
输出10次hellojava
*/

class xunhuan2{
public static void main(String[] args){
int i = 0;
while(i<10){
i++;
System.out.println("Hello Java");
}
}
}

求1-100的偶数和:

class xunhuan2{
public static void main(String[] args){
int sum = 0;
int i=0;
while(i<=100){
sum += i;
i += 2;
}
System.out.println("sum="+sum);
}
}

求8的阶乘

class xunhuan2{
public static void main(String[] args){
int sum = 1;
int i = 1;
while(i<=8){
sum *= i;
i++;
}
System.out.println(sum);
}
}

/*
在控制台上输入所有“水仙花数“
水仙花数：指的是一个3位数，各个位上的数字的立方和(100-999)等于该数本身
*/

class xunhuan2{
public static void main(String[] args){
int count = 0;
int i =100;
while(i<1000){
int ge = i%10;
int shi = i/10%10;
int bai = i/100%10;
if(ge*ge*ge+shi*shi*shi+bai*bai*bai == i){
count++;
System.out.println(i);
}
i++;
}
System.out.println(count);
}
}

/*
统计1-1000之间满足条件的数据有多少个?并输出
条件：除3余2；除5余3；除7余2
*/

class xunhuan2{
public static void main(String[] args){
int count = 0;
int i = 1;
while(i<1000){
if(i%3 == 2 && i%5 == 3 && i%7 == 2){
System.out.println(i);
count++;
}
i++;
}
System.out.println("共"+count+"个");
}
}

/*
在控制台上输出满足条件的五位数
条件：个位=万位；十位=千位；个位+十位+千位+万位=百位
*/

class xunhuan2{
public static void main(String[] args){
int count = 0;
int i = 10000;
while(i<99999){
int ge = i%10;
int shi = i/10%10;
int bai = i/100%10;
int qian = i/1000%10;
int wan = i/10000%10;
if(ge==wan && shi==qian && ge+shi+qian+wan == bai){
System.out.println(i);
count++;
}
i++;
}
System.out.println(count);
}
}

---

 -for循环和while循环的区别：
        for循环和while循环是可以相互转换的，但是还是有一些区别的：
             使用区别：控制条件语句控制的那个变量，在for循环结束后，就不能被访问了，而while循环在结束后那个变量还可以使用。
                           如果想在循环外边继续使用那个变量就用while，否则就用for。因为for循环结束后，那个变量就跟着从内存中消失了，可以提高内存利用率。
             场景区别：for循环适合针对一个范围进行判断（循环次数可知）；while循环适合判断次数不确定的情况（循环次数不可知）。

/*
面试题：
珠穆朗玛峰的高度是8848m，假设我有一张足够大的纸，厚度是0.01m。问：最低对折多少次,厚度就不低于珠穆朗玛峰的高度？
*/

class xunhuan2{
public static void main(String[] args){
//定义统计变量，默认值0
int count = 0;
double start = 0.01;
double last = 8848;
while(){
if(start<last){    //判断每一次厚度有没有超过珠穆朗玛峰
count++;
start *= 2;
System.out.println("第"+count+"次的厚度是"+start);
}
}
System.out.println(count); 
}
}

---

     -do...while循环
           格式：
                   基本格式：
                   do{
                          循环体语句
                        }while(判断条件语句);   
                                    
                   扩展格式:
                      初始化语句:
                    do{
                         循环体语句:
                         控制条件语句:
                         }while(判断条件语句)；

练习：
/*
输出10次hellojava
*/

class xunhuan2{
public static void main(String[] args){
int i = 1;
do{
System.out.println("Hello Java");
i++;
}while(i<=10);
}
}

/*
求1-100之和
*/

class xunhuan2{
public static void main(String[] args){
int sum = 0;
int i = 1;
do{
sum += i;
i++;
}while(i<=100);
System.out.println(sum);
}
}

---

       循环语句的区别：
              do...while循环无论怎么样至少都会执行一次循环体
              for,while循环先判断条件是否成立，如果成立才会执行循环体语句
              先考虑用for，如果循环次数不确定，在考虑while，最后再考虑do...while(特殊情况下才使用)。

eg：

class xunhuan2{
public static void main(String[] args){
int a = 2;
/*
while(a<2){
System.out.println("空气是世界的");
}
*/
do{
System.out.println("空气是世界的");
a++;  //不能丢，一旦丢了就造成死循环
}while(a<=3);
}
}

         注意：死循环（一定要注意控制条件语句控制的那个变量，如果没有的话，就变成死循环了）
   -两种死循环的格式：
            while(true){}
            for(;;){}

---

-循环嵌套

练习：
/*
在控制台上输出一个三行八列的*图案
*/

class xunhuan2{
public static void main(String[] args){
for(int i = 0;i<3;i++){
for(int j = 0;j<8;j++){
System.out.print(" * ");
}
System.out.println();
}
}
}

//通过这个例子发现外层for控制行，内层for控制列。for中套for，这就是循环嵌套。

/*
在控制台上输出一个三角形

class xunhuan2{
public static void main(String[] args){
for(int i=0;i<5;i++){
//for(int j=i;j<5;j++){ 出来是倒三角
for(int j=0;j<=i;j++){            //出来是正三角
System.out.print(" * ");
}
System.out.println();
}
}
}

/*
在控制台上输出九九乘法表
11=1
12=2 22=4
13=3 23=6 33=9
*/

class xunhuan2{
public static void main(String[] args){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+i*j+"\t");  //     \t 制表符   移动一个tab的距离    \  转义字符     \r 回车   \n   换行
}
System.out.println();
}
}
}

练习：等腰三角形、菱形。。。。。。
/*
等腰三角形
*/

import java.util.Scanner;
class xunhuan2{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入num=");
int num = sc.nextInt();
for(int i=0;i<=num;i++){
for(int j=i;j<=num;j++){
System.out.print(" ");
}
for(int j=1;j<=2*i+1;j++){
System.out.print("*");
}
System.out.println();
}
}
}

---

    -跳转控制语句：
      如果想在循环执行到某一步的时候就结束
      java给我们提供了break（中断）   continue（继续）     return（返回） 来实现控制语句的跳转和中断
       -break：(使用范围)在选择结构switch语句中、在循环语句中。   （作用）跳出单层循环，也可以跳出多层循环（在外层循环带标签、标签格式--标签名：循环语句）                 
                   注意：标签名要符合java命名规则

class xunhuan2{
public static void main(String[] args){
//跳单层
for(int i=0;i<10;i++){
if(i==5){
break;
}
System.out.println(i);
}
}
}
class xunhuan2{
public static void main(String[] args){
//跳多层
aaa:for(int i=0;i<5;i++){
bbb:for(int j=0;j<10;j++){
if(j==3){
break aaa;//跳出外层
//break bbb;
}
System.out.print("*");
}
System.out.println();
}
}
}

       -continue：（在循环语句中用）结束本次循环，执行下次循环。 

class xunhuan2{
public static void main(String[] args){
for(int i=0;i<10;i++){
if(i==5){
continue;
}
System.out.println(i);
}
}
}

结果：12346789

/*
输出2次aaa，空白处写什么？
break；
输出7次aaa，空白处写什么？
continue;
输出13次aaa，空白处写什么？
System.out.println(“aaa”); 3,6,9的时候会输出2次
*/

class xunhuan2{
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i%3==0){
System.out.println("aaa");
}
System.out.println("aaa");
}
}
}

       -return：返回。return关键字不是为了跳出循环，最常用的功能是结束一个方法；也就是退出方法。跳转到上层调用的方法。
                   作用：不是结束循环，而是结束方法。

class xunhuan2{
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i==2){
System.out.println("aaa");
//   break; 结果是 1   aaa   ccc
//   continue;  结果是 1 aaa 3456789  ccc
return; // 结果是 1 aaa
}
System.out.println(i);
}
System.out.println("ccc");
}
}

面试题： 小明他妈每天给小明2.5元，他都会存起来，但是，如果当这一天是存钱的第5天或者第5天的倍数，他就会花掉6元。
问：要多少天，小明才能存够100元。

class xunhuan2{
public static void main(String[] args){
int day = 0;
double start = 0;
double last = 100;
while(start<last){
if(start<last){
day++;
start +=2.5;
if(day%5==0){
start -= 6;
}
continue;
}
}
System.out.println("第"+day+"天攒够100元");
}
}