小白Java笔记——流程控制

Java提供的流程控制结构:

一、顺序结构

    任何编辑语言最常见的程序结构是顺序结构。顺序结构就是从上到下依次进行，中间没有任何判断和跳转。
    如果main方法的多行代码之间没有任何流程控制，那里面的语句就是一个顺序执行流，从上到下依次执行。

二、分支结构

   有if和switch两种：if用布尔表达式或者布尔值作为分支条件来进行分支控制；switch用与多个整型值进行匹配，实现分支结构。

（一）if条件语句

• 放在if（）里的只能是逻辑表达式，即返回值只能是true或者false；
• 优先书写和处理范围小的情况，避免因为忽略else隐含的条件，而出错；
• 注意花括号的书写

int age = 30;
if(age>20)
/* 
* if和else if后面用花括号括起来的叫“代码块”，一个代码块会当作整体执行（除非遇到return、break、continue等关键字，或异常），因此也叫“条件执行体”

*/
{
System.out.println("年龄已经大于20岁了");
System.out.println("年龄已经大于20岁了");
}
else
{
System.out.println("年龄还不到20岁啊");
}

• 如果代码块只有一行语句，是可以不用花括号的，但实际上书写代码时仍要加上花括号，为了方便阅读。
• 也就是说if语句可以管到最临近的一行代码，即紧跟条件语句的第一个分号处。

常出错的代码写法

错误一：花括号问题

int c = 5;
if(c>4)
  c--;
  /*
  *由于没加花括号，所以上面if管不到下面这一行，也就是下面这一行属于普通代码，脱离执行体，也导致了if语句到c--出结束，使下面的else失去if 句，编译出错
  */
  System.out.println("c>4");
else
  System.out.println("c<4");

错误二:else的隐含条件

int age = 45;
if(age>20)
{
System.out.println("青年人");
}
else if(age>40)
{
System.out.println("中年人");
}
else if(age>60)
{
System.out.println("老年人");
}
//打印结果是：青年人。实际上希望打印出的是中年人
//实际上else和else if都有隐藏的条件，就是else含义“否则”就是对上面条件的取反
//上面的代码也就相当于下面的代码，即加上隐含的else的条件
int age = 45;
if(age>20)
{
System.out.println("青年人");
}
else if(age>40&&!(age>20))
{
System.out.println("中年人");
}
else if(age>60&&!(age>20)&&!(age>40&&!(age>20)))
{
System.out.println("老年人");
}
//这样写就容易看出为什么会出错，现在知道忽略else隐含条件是多可怕了吧，就像潜规则一样，表面上好像正常，实际上人家已经心照不宣了，必须给人家一点好处，才能通过，那这所谓的好处就相当于else的隐含条件，你不知道那就永远通不过。当然正常人不会期望有潜规则，所以还是需要清楚，避开这些地方。扯远了。。。。。

正确的改法:

int age = 45;
if(age>60)
{
System.out.println("老年人");
}
else if(age>40)
{
System.out.println("中年人");
}
else if(age>20)
{
System.out.println("青年人");
}
//也就相当于下面加上else隐含条件的
int age = 45;
if(age>60)
{
System.out.println("老年人");
}
else if(age>40&&!(age>60))
{
System.out.println("中年人");
}
else if(age>20&&!(age>60)&&!(age>40&&!(age>60)))
{
System.out.println("青年人");
}
//因此得出if else语句的一条基本规则：总是优先把包含范围小的条件放在前面处理。如age>60和age>20两个条件，明显age>60范围小，所以先处理这个情况

（二）switch分支语句

• 与if语句的区别：1.switch语句后面只能是byte、short、char、int四种整数类型的表达式，外加上Java7才允许的枚举类型和java.lang.String类型。但一定不能是boolean类型。2.switch语句中的case标签后的代码块开始点和结束点很清晰，因此完全可以省略caes后的花括号；
• 同样的，default也有隐含条件：就是switch（experssion）中experssion的值不能等于前面任何一个case标签后的值。
• 注意experssion的类型，注意break不能缺少

char score = 'C';
switch(score)
{
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("不及格");
}
//输出结果是“中”，正确

这里注意，每个case后面的break意义重大，一定不能漏写；因为score的值会和每个case值比较，一旦遇到相等的值，就开始执行这个case标签后的代码，不再判断与case、default标签的条件是否符合，除非遇到break；所以如果上面的代码都去掉break，就结果是：

中
及格
不及格

switch增强的功能，所以下面的代码也是正确的
对String的理解https://www.cnblogs.com/dolphin0520/p/3778589.html

//只能是java.lang.String类型，不能是StringBuffer、StringBuilder类型
//简单的解释：String是不可变的；StringBuffer是可变的以及线程安全的字符串操作类；Stringbuilder作用和StringBuffer相同，区别是它线程不安全

String season = "夏天";//声明了一个String变量season
switch(season)
{
case "春天":
 System.out.println("春暖花开");
 break;
case "夏天":
 System.out.println("夏日炎炎");
 break;
case "秋天":
 System.out.println("秋高气爽");
 break;
case "冬天":
 System.out.println("冬雪皑皑");
 break;
default:
 System.out.println("季节错误！");
}

三、循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码。在适合的时候将循环条件改为假，否则会形成死循环。循环语句一般有以下几部分：初始化语句（init_statement）、循环条件（test_experssion）、循环体（body_statement）、迭代语句（iteration_statement）:用于控制循环条件中的变量，使循环在适合的时候结束。

（一）while循环语句

• 同分支结构里的if语句一样，注意花括号的问题，不再赘述

• 注意不要陷于死循环以及分号的位置问题

  出错的代码写法：
  错误一：死循环的错误

int count = 0;
while(count<10)
{
System.out.println("死循环"+count);
count--;
}
System.out.println("永远无法跳出的循环体");
//所以一定要保证循环条件有变成false的时候

错误二：分号位置陷阱

int count = 0;
//在while后紧跟分号，意味着循环体是一个分号，也就是空语句
while(count<10);
//下面的代码已经脱离了循环体，与循环已经没有关系
{
count++;
}

（二）do while 循环语句

• 与while区别：1.先执行循环体，再进行条件判断，如果条件为真，再执行下一次循环，否则终止循环；2.while后要有一个分号
• 循环至少执行一次，也就是说就算初始条件是假的，也会执行一次循环体

int count = 20;
do
 System.out.println(count++);
 while(count<10);//注意后面加分号
 System.out.println("End!");
 //结果是21

（三）for循环

• 大部分情况下，for循环可以代替while、do while循环；
• 循环条件总比循环体多执行一次，因为最后一次条件返回false，就不再执行循环体；
• 迭代语句没有和循环体放在一起，因此不管是否使用continue结束本次循环，循环迭代语句一样会获得执行。

//可以有多个初始化语句，但声明语句只能有一个；
//循环条件是boolean表达式，也可以是包含逻辑运算符的表达式
for(int b = 0,s = 0,p = 0;b<10 && s<4 && p<10;p++)
{
System.out.println(b++);
System.out.println(++s + p);
}

错误的代码书写
错误一：在循环体内改变循环变量（循环计数器）的值

for(int i = 0 ; i < 10 ; i++)
{
System.out.println(i);
//下面有再次修改了循环变量，就形成了死循环
i *= 0.1;
}
System.out.println("循环结束！");
//所以不要在循环体内修改循环变量，否则可能会出现
//万一需要访问，就直接定义一个临时变量，将循环变量的值赋给临时变量

错误二：忽略了循环条件（没有循环条件默认为true）

//括号中两个分号是必要的；其他可以省略
//但如果循环条件省略时，默认就是true，要注意循环体是可能就此形成了死循环
//以下就是形成了死循环
for( ; ; )
{
System.out.println("======");
}

• 当然初始化条件的定义可以放在外面，把迭代语句放在循环体内。这样类似前面的while循环，在这不再赘述；
• for的初始化定义放在前面有一个作用：扩大初始化语句所定义变量的作用

int tmp = 0;
for(int i = 0 ; i<10 ; i++)
{
System.out.println(i);
//用tmp保存i的值
tmp = i;
}
//通常使用这种解决方案，还可以通过tmp访问i的值

四、嵌套结构

指的是一个循环放在另一个循环体中：

for(int i=0; i<5; i++)
{
 for(int j=0; j<3; j++)
 {
  System.out.println("i="+i+"j="+j);

 }
}
//可以嵌套两层，三层。。。。
//理解：知道内层循环体执行完了，再回到外层判断

结果是：

i=0j=0
i=0j=1
i=0j=2
i=1j=0
i=1j=1
i=1j=2
i=2j=0
i=2j=1
i=2j=2
i=3j=0
i=3j=1
i=3j=2
i=4j=0
i=4j=1
i=4j=2

五、控制循环结构

Java没有goto语句来控制程序的跳转，提高了可读性，但为了提高灵活性，用break、continue、return控制循环结构。
（一）用break结束循环

• break不仅可以结束所在的循环，也可以结束外层的循环

//结束其所在的循环：
for(int i = 0 ; i<10 ; i++)
{
 System.out.ptintln(i);
 if(i==2)
 {
 break;
 }
}
/*
*结果是：0 1 2并没有执行i<10因为有break结束了循环
*/
//结束外层的循环，但这时需要在break后紧跟一个标识外层循环的标签；这个标签一般后面加：当然只在循环内有用

public class BreakTest{
 public static void main(String[] args){
  //outer：用于标识外层循环体，可以起别的名字，如out、asd但为了可读性，还是建议用outer
  outer:
  for(int i = 0;i<5;i++){
   for(int j = 0 ; j<3; j++)
    {
       System.out.println("i="+i+"j="+j);
       if(j == 1){
          break outer;
               }
          }
    }
 }
}

结果是：

i=0j=0
i=0j=1

（二）用continue忽略本次循环剩下的语句

• 与break区别：continue只忽略本次循环剩下的语句，接着开始下一次循环，不会终止循环。也就是说只影响本次循环！！！

public class ContinueTest{
 public static void main(String[] args){
   for(int i=0; i<5;i++){
    System.out.println("i="+i);
     if(i==2){
          continue;
}
System.out.println("continue后输出的语句");
}
}
}

结果是：

i=0
continue后输出的语句
i=1
continue后输出的语句
i=2
i=3
continue后输出的语句
i=4
continue后输出的语句

而使用break时结果：

i=0
break后输出的语句
i=1
break后输出的语句
i=2

同样的也可以紧跟一个标签

outer:
for(int i = 0;i<5;i++){
   for(int j = 0 ; j<3; j++)
    {
       System.out.println("i="+i+"j="+j);
       if(j == 1){
          continue outer;
               }
          }
    }

结果：很明显j没有超过1

i=0j=0
i=0j=1
i=1j=0
i=1j=1
i=2j=0
i=2j=1
i=3j=0
i=3j=1
i=4j=0
i=4j=1

（三）用return结束方法
该关键字并不是专门用于结束循环的，它的功能是结束一个方法，不管return处在多少层内。

for(int i=0; i<5;i++){
    System.out.println("i="+i);
     if(i==2){
          return;
}
System.out.println("return后输出的语句");
}

结果：

i=0
return后输出的语句
i=1
return后输出的语句
i=2