流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以我们要通过控制语句的执行顺序来实现我们要完成的功能。
顺序结构
是程序中最简单最基本的流程控制语句，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行
System.out.println("第一步执行");
System.out.println("第二步执行");
System.out.println("第三步执行");
/*
运行结果：
第一步执行
第二步执行
第三步执行
*/
//在顺序结构语句中，会根据代码的顺序来运行。
选择结构
选择结构也被称为分支结构。选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个（true和false），所以产生选择，按照不同的选择执行不同的代码。
if语句
几种格式：
//1
if(比较表达式或boolean类型的值)
{
语句体；
}
/*
执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体；
*/
//示例
if(10>2)
{
System.out.println("执行");
}
/*
首先会对if里的表达式进行判断，10>2为ture，所以执行{}中的代码。
运行结果：
执行
*/
//2
if(比较表达式)
{
语句体1;
}
else
{
语句体2;
}
/*
执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
*/
//示例：
if(10==2)
{
System.out.println("执行if{}");
}
else
{
System.out.println("执行else{}");
}
/*
首先对if括号中的表达式进行判断，10==2为false，所以跳过if{}中的语句，执行else{}中的代码。
运行结果：
执行else{}
*/
//3
if(比较表达式1)
{
语句体1;
}
else if(比较表达式2)
{
语句体2;
}
else if(比较表达式3)
{
语句体3;
}
...
else
{
语句体n+1;
}
/*
执行流程：
首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，else if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
...
如果都是false，就执行else大括号中的语句体n+1。
*/
//示例
if(10==2)
{
System.out.println("执行if{}");
}
else if(10>2)
{
System.out.ptintln("执行else if{1}");
}
else if(10<2)
{
System.out.println("执行else if{2}");
}
else
{
System.out.println("执行else{}");
}
/*
首先判断if后括号里的表达式，10==2为false，所以跳过if{}中的语句。
再判断else if后括号里的表达式，10>2为true，所以执行else if{}中的语句。
然后跳出选择语句的结构体，不再判断下面的10<2，也不执行下面的else if{}和else{}中的语句
运行结果：
执行else if{1}
*/
注意事项：
1.比较表达式无论简单还是复杂，结果必须是boolean类型。
2.if语句控制的语句体如果是一条语句，{}可以省略。建议慎用。
//例题
boolean b = true;
if(b=false)
System.out.println("a");//if只控制这一条语句，{}可以省略。
else if(b)
System.out.println("b");
else if(!b)
System.out.println("c");
else
System.out.println("d");
/*
分析：
首先定义一个布尔类型的变量b，值为true
按照顺序先判断if()中的b=false。但这个表达式不是boolean类型的结果，是个赋值语句。
！！所以不执行if{}中的语句，但是把false赋给了b。
然后进行下面的语句，第二个else if()中!b为true，所以输出c，结束整个选择语句结构体。
运行结果：
c
*/
if与三元运算符的转换问题
注意：三元运算符能够实现的，都可以用if语句实现，反之不成立。
如：当if控制的语句是一个输出语句时，就不能转换为三元运算符。
因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
if嵌套使用
//示例
/*
先判断userName（用户名）是否是"123"
如果是再判断passwor（密码）是否是"321"
如果是，输出"正确"
*/
if(userName=="123")
{
if(password=="321")
{
System.out.println("输入正确");
}
}
//在使用if嵌套时，无论if控制的语句有多少句，都将其用{}括起来
//这样可以提高代码的可读性
switch语句
格式：
switch(表达式)
{
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
....
default：
语句体n+1;
break;
}
/*
格式解释：
1.switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举(什么是枚举，以后再讲)
JDK7以后可以是String
2.case后跟的是要和表达式进行比较的值
3.语句体部分可以是一条或多条语句
4.break表示中断，结束的意思，结束switch语句
5.default语句表示所有情况都不匹配时，就执行该处的内容，和if语句中的else相似
*/
/*
执行流程：
依次判断表达式的值与哪一个case后面的值相同。
如果有相同值，执行该case后的语句，最后break;跳出选择语句结构体。
如果没有相同值，执行default中的语句，然后break;跳出选择语句结构体。
*/
面试题：
1.byte可以作为switch的表达式吗？可以
2.long可以作为switch的表达式吗？不可以
3.String可以作为switch的表达式吗？JDK1.7之后可以
注意事项：
1.case后面只能是常量，不能是变量，而且多个case后面不能出现相同的值。
2.default可以省略，但是不建议，如果case后面没有匹配项，他能对这种情况给出提示
3.break可以省略，但会出现case穿透现象，有时可以利用这种情况
4.default可以放在switch结构体中的任意位置，但是建议放在最后
5.switch遇到break或者执行到末尾就结束了
//注意以下两个程序的区别
//1
int x = 2;
int y = 3;
switch(x)
{
default:
y++;
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
/*
分析：
没有与x相匹配的case值，此时虽然在switch的末尾，但是还有default没有执行
执行default，y=4，break结束结构体
运行结果：
y=4
*/
//2
int x = 2;
int y = 3;
switch(x){
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
/*
分析：
没有与x相匹配的case值，执行default，y=4
注意：default中无break，此时并不在switch结构的末尾，要继续往下执行
但不再判断是否与case后面的值相匹配，发生case穿透
执行两次y++，最后y=6
运行结果：
y=6
*/
case穿透现象的应用
//根据月份，输出对应的季节
int month=6;
switch(month)
{
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default：
System.out.println("month的值非法");
break;
}
/*
如果month的值为3，因为case穿透现象，会直接执行case 5:后面的输出语句，然后break;退出循环体
这样做可以简化代码
*/
循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环
for循环
格式：
// 1 2 3
for(初始化表达式语句;判断条件语句;控制条件语句)
{// 4
循环体语句;
}
/*
执行流程：
1.执行初始化表达式语句
2.执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
3.执行循环体语句;
4.执行控制条件语句
5.回到第二步继续。
注意：初始化表达语句只执行一次
执行顺序为1–>2–>4–>3–>2–>3–>4... 直到2中的条件判断为false为止
*/
//示例：输出1～10之间的数字之和
int sum=0;//存储1～10之间的和
for(int i=1;i<=10;i++)
{
sum=sum+i;
}
System.out.println(sum);
/*
执行流程：
1.先定义一个变量i，并将其初始化，初始化值为1
2.判断i<=10，结果为true
3.执行循环体中的语句，将sum+i赋值给sum
4.执行i++，i=2
5.再继续判断i<=10
……
直到i<=10为false
运行结果：
55
*/
for循环的计数思想
/*
统计水仙花数有多少个
水仙花数：个位数字的三次方+十位数字的三次方+百位数字的三次方=该数本身
*/
/*
问题分析：
水仙花数都是三位数，出现水仙花数的范围是100～999
范围过大，我们需要遍历这个范围，就要用到循环
初始化表达语句：int i=100
判断条件语句：i<=999
控制条件语句：i++
在循环体中，我们需要判断一个数各位数字的立方和是否等于该数本身
问题在于如何求出一个三位数的个位数字、十位数字和百位数字
再判断出一个数是水仙花数的时候，我们还要统计水仙花数的数量
*/
int count=0;
for(int i=100;i<=999;i++)
{
int g=i%10; //个位数字
int s=i/10%10; //十位数字
int b=i/100%10; //百位数字
if(g*g*g+s*s*s+b*b*b==i)
count++;
}
System.out.println(count);
/*
在这个问题中，我们定义了一个变量count来统计水仙花数的个数
只要该数字满足条件，就让count自增
在统计的问题中，我们可以定义这样一个记录个数的变量，一旦符合条件，使其自增1
对于取出各位上的数字，可以用上述方法，对于四位数、五位数等也同样适用
*/
for循环嵌套
/*
请输出一个4行5列的星星(*)图案（每次只能输出一个*）。
如图：
*****
*****
*****
*****
问题分析，如果要输出5颗星要循环5次
现在要在输出4次5颗星。在5次循环的基础上再循环4次
*/
for(int i=0;i<4;i++)
{
for(int j=0;j<5;j++)
{
System.out.print(“*”);//注意print（不换行）和println的区别
}
System.out.println();//每输出5个*进行换行
}
//外循环控制行数，内循环控制列数
while循环
格式：
初始化条件语句;
while(判断条件语句)
{
循环体语句;
控制条件语句;
}
/*
执行流程：
1.执行初始化条件语句;
2.执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
3.执行循环体语句;
4.执行控制条件语句
5.回到第二步继续。
*/
//示例：输出1～10之间的数字之和
int sum=0;
int i=1; //要有初始化条件语句
while(i<=10)
{
sum=sum+i;
i++; //如果没有控制条件语句，会陷入死循环
}
System.out.println(sum);
/*
运行结果：
55
*/
do…while循环
格式：
初始化条件语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
/*
执行流程：
1.执行初始化条件语句;
2.执行循环体语句;
3.执行控制条件语句;
4.执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
5.回到b继续。
注意：无论判断条件是否成立，循环都会执行1次，即先执行再判断
*/
//示例：输出1～10之间的数字之和
int sum=0;
int i=1;
do{
sum=sum+i;
i++
}while(i<=10)
/*
运行结果：
55
*/
注意：一定要注意控制条件语句的变量，不要弄丢了，不然就会造成死循环！
三种循环的区别：
1.do…while循环至少执行一次循环体，而for，while循环必须先判断条件是否成立，然后决定是否执行 循环体语句
2.如果你想在循环结束后，继续使用控制条件的变量（上述的i），用while循环，否则用for循环。
for循环可以使控制条件的变量及早的从内存中消失，提高内存的使用效率
3.如果明确循环次数使用for循环，如果不明确循环次数使用while循环
4.优先考虑for循环，然后是while循环，最后是do…while循环
键盘录入
优点：
1.能够使程序的数据更符合开发的数据
2.让程序更加灵活一点
步骤：
1.导包
import java.util.Scanner; //位置：在class上面
2.创建键盘录入对象
Scanner input=new Scanner(System.in);
3.通过对象获取数据
int x=input.nextInt(); //要接收的数据类型是什么，next后就跟什么类型，如：nextDouble()
//示例：由键盘输入两个数，求两数之和
import java.util.Scanner;
class Demo
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
System.out.println(“请输入第一个数字”)；
int num1=input.nextInt();
System.out.println(“请输入第二个数字”)；
int num2=input.nextInt();
int sum=num1+num2;
System.out.ptintln(sum);
}
}
控制跳转语句之break、continue
比如说，我们想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
为了弥补这个缺陷，Java就提供了break，continue和return（后面讲）来实现控制语句的跳转和中断。
break（中断）
使用场景：
1.在选择结构switch语句中
2.在循环语句中
注意：离开使用场景的存在是没有意义的
作用：
1.退出单层循环
2.退出多层循环（实现这个效果，要使用带标签的语句）
3.退出switch结构体
tag1:for( ; ; )
{
循环体语句
tag2:for( ; ; )
{
循环体语句
break tag1;//退出外循环
break tag2;//退出内循环
break; //退出当前循环，即内循环
}
break; //退出当前循环，即外循环
}
//退出多层循环不常用
continue（继续）
使用场景：在循环语句中
注意：离开使用场景的存在是没有意义的
作用：跳出一次循环，执行下一步操作
//练习题
for(int x=1;x<10;x++)
{
if(x%3==0)
{
//在此处填写代码
}
System.out.println(“Java”);
}
/*
需求：
1.在控制台输出2次“Java”
2.在控制台输出7次“Java”
3.在控制台输出13次“Java”
在提示处填写代码
1.break;
2.continue;
3.System.out.println(“Java”);
*/
