3.1 条件语句
3.1.1 if 条件语句
if条件语句主要用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行
if条件语句主要用于告诉程序在某个条件成立另外的语句。使用if条件语句，可选择是否紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”，如果该表达式返回的结果为 true， 则执行其后的语句:若为false，则不执行if条件之后的语句。if条件语句可分为简单的if条件语句、if..else 语句和if...elseif多分支语句。
1.简单的if条件语句
语法如下：
if（布尔表达式）{
语句;
}
布尔表达式: 必要参数，它最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，也可以是关系表达式。
语句: 可以是一条或多条语句，当布尔表达式的值为true时执行这些语句。如果若语句序列中仅有一条语句，则可以省略条件语句中的“{ }”。
代码如下：
public class SD{
public static void main(String[] args) {
int a=24; //创建整型变量a并赋值24
int b=24; //创建整型变量b并赋值24
if(a==b) //创建if语句，如果a和b的值相等输出下面的语句
System.out.println("a和b的值相等"); //a和b的值相等
}
}
输出结果为：
2.if...else 语句
if...else 语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。
语法如下:
if(布尔表达式) {
语句1; }
else {
语句 2; }
如果表达式的值为true，则执行紧跟if语句的复合语句;如果表达式的值为 false，则执行 else后面的语句。这种形式的判断语句相当于汉语里的“如果……那么……否则……”。
代码如下：
public class SD{
public static void main(String[]args){
int math=95; //声明int型局部变量，并赋给初值95
int english=56; //声明int型局部变量，并赋给初值56
if(math>60){ //使用if语句判断math是否大于60
System.out.println("数学及格了"); //条件成立时输出的信息
}
else{
System.out.println("数学没有及格"); //条件不成立输出的信息
}
if(english>60){ //判断英语成绩是否大于60
System.out.println("英语及格了"); //条件成立输出的信息
}
else{
System.out.println("英语没有及格"); //条件不成立输出的信息
}
}
}
运行结果为：
i
3.if...elseif多分支语句
用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件, 就进行某种处理;如果满足另一种条件，则进行另一种处理”。
语法如下：
if(表达式1）{
语句1;
}
else if(表达式2）{
语句2;
}
...
else if(表达式n){
语句n
}
代码如下：
public class SD{
public static void main(String[] args) {
int x=20; //声明int型局部变量
if(x>30){ //判断变量x是否大于30
System.out.println("a的值大于30"); //条件成立的输出信息
}
else if(x>10){ //判断变量x是否大于10
System.out.println("a的值大于10,但小于等于30"); //条件成立的输出信息
}
else if(x>0){ //判断变量x是否大于0
System.out.println("a的值大于0，但小于等于10"); //条件成立的输出信息
}
else{ //当以上条件都不成立时，执行的语句块
System.out.println("a的值小于等于0"); //输出信息
}
}
}
运行结果为：
4.if 语句的嵌套
这三种形式的条件语句都可以嵌套条件语句。例如，在第一 种形式的条件语句中嵌套第二种形式的条件语句。形式如下:
if(表达式1)
{
if(表达式2)
语句1;
else
语句2;
}
代码如下：
import java.util.Scanner;
public class SD{
public static void main(String[] args) {
int iYear; //创建整型变量，保存输入的年份
Scanner sc=new Scanner(System.in); //创建扫描器
System.out.println("please input number"); //输出内容
iYear=sc.nextInt(); //控制台输入一个数字
if(iYear%4==0){ //如果能被4整除
if(iYear%100==0){ //如果能被100整除
if(iYear%400==0) //如果能被400整除
System.out.println("It is a leap year"); //是闰年
else
System.out.println("It is not a leap year"); //不是闰年
}else
System.out.println("It is a leap year"); //是闰年
}else
System.out.println("It is not a leap year"); //不是闰年
}
}
运行结果为：
3.2.2 switch 语句
switch语句中的参数必须是整型、字符型、枚举型或字符串类型，常量值 1~n 必须是与参数兼容的数据类型。
switch 语句首先计算参数的值,如果参数的值和某个 case 后面的常量表达式相同,则执行case语句后的若干个语句，直到遇到 break 语句为止。此时如果 case 语句中没有 break 语句，将继续执行后面 case 中的若个语句，直到遇到 break 语句为止。若没有任何一个常量表达式与参数的值相同，则执行 default 后面的语句。
break 的作用是跳出整个 switch 语句。
default 语句是可以不写的，如果它不存在，而且switch 语句中表达式的值不与任何 case的常量
来完 值相同，switch 则不做任何处理。
语法如下：
switch（要判断的参数）{
case 参数1: 语句1; break;
case 参数2: 语句2; break;
...
defauit: 语句; break;
}
代码如下：
public class SD{
public static void main(String[] args) {
int week=2; //定义int型变量week
switch(week){ //指定switch语句的表达式为变量week
case 1: //定义case语句中的常量为1
System.out.println("Monday"); //输出信息
break; //终止执行
case 2: //定义case语句中的常量为2
System.out.println("Tuesday"); //输出信息
break; //终止执行
case 3: //定义case语句中的常量为3
System.out.println("Wednesday"); //输出信息
break; //终止执行
case 4: //定义case语句中的常量为4
System.out.println("Thursday"); //输出信息
break; //终止执行
case 5: //定义case语句中的常量为5
System.out.println("Friday"); //输出信息
break; //终止执行
case 6: //定义case语句中的常量为6
System.out.println("Saturday"); //输出信息
break; //终止执行
case 7: //定义case语句中的常量为7
System.out.println("sunday"); //输出信息
break; //终止执行
default: //default语句,如果week不是1~7之间的数字，则执行此行代码
System.out.println("Sorry, I don't Know"); //输出信息
}
}
}
运行结果为：
如果switch 语句中没有 break 关键字，即使执行完对应的 case 的处理语句，switch语句也不会立即停止，而是会继续执行下面所有的case，直至遇见break 关键字或者完成执行完所有代码才会停止。这就是switch 的“贯穿”特性。
3.3 循环语句
循环语句就是在满足一定条件的情况下反复执行某一个操作。在Java中提供了4种常用的循环语句，分别是 while 语句、do…while 语句、for 语句和 foreach 语句，其中，foreach 语句是 for 语句的特殊简化版本。
3.3.1 while 语句
while 语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句。
语法如下:
while(条件表达式)
{
执行语句
}
当条件表达式的返回值为真时，则执行“{ }”中的语句，当执行完“{} ”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。
代码如下：
public class SD{
public static void main(String[] args) {
int x=1; //定义int型变量x,并赋给初值
int sum=0; //定义变量用于保存相加后的结果
while(x<=10){
sum=sum+x; //while循环语句，当变量满足条件表达式时执行循环体语句
x++;
}
System.out.println("sum="+sum); //将变量sum输出
}
}
运行结果为：
3.3.2 do...while 循环语句
do...while 循环语句与 while 循环语句类似，它们之间的区别是 while 语句为先判断条件是否成立再执行循环体，而 do…while 循环语句则先执行一次循环后，再判断条件是否成立。也就是说 do.….while 循环语句中“{ }”中的程序段至少要被执行一次。
语法如下:
do
{
执行语句
}
while(条件表达式);
do.….while 语句与 while 语句的一个明显区别是 do.…while 语句在结尾处多了一个分号(;)。
代码如下：
public class SD{
public static void main(String[] args) {
int a=100; //声明int型变量a并赋初值100
while(a==60)
{ //指定进入循环体条件
System.out.println("ok1"); //输出
a--; //自减运算
}
int b=100; //定义一个int型变量b并赋初值100
do{
System.out.println("ok2"); //输出
b--; //自减运算
}
while(b==60); //循环条件
}
}
运行结果为：
3 while 与 do.….while 比较
可以通过设置起始循环条件不成立的循环语句来观察 while 和 do….while 的不同。将变量i初始值设置为 0，然后循环表达式设置为i>1，显然循环条件不成立。循环体执行的是对变量 j 的加1运算，通过输出变量j在循环前的值和循环后的值进行比较.
代码如下：
//do...while
//do...while
public class SD{
public static void main(String[] args) {
int i=0,j=0; //定义两个int类型变量并赋初值
System.out.println("before do_while j="+j); //输出
do{
j++; //自加运算
}
while(i>1); //循环条件
System.out.println("after do_while j="+j); //输出
}
}
运行结果为：
// while语句
代码如下：
public class SD{
public static void main(String[] args) {
int i=0,j=0; //定义两个变量
System.out.println("before while j="+j); //输出
while(i>1)
{ //循环条件
j++; //自加运算
}
System.out.println("after while j="+j); //输出
}
}
运行结果为:
3.3.4 for 循环语句
for 循环是Java 程序设计中最有用的循环语句之一。一个 for循环可以用来重复执行某条语句直到某个条件得到满足。
语法如下：
for(表达式1;表达式2;表达式3){
语句
}
代码如下：
public class SD{
public static void main(String[] args) {
int sum=0; //定义一个变量存放相加的值
int i; //定义一个控制循环次数的变量
for(i=1;i<=100;i++){ //for语句
sum+=i; //计算1~100
}
System.out.println("the result:"+sum); //输出
}
}
运行结果为：
3.3.5 foreach 语句
foreach 语句是 for 语句的特殊简化版本，但是 foreach 语句并不能完全取代 for 语句，然而任何forreach 语句都可以改写为 for 语句版本。foreach 并不是一个关键字，习惯上将这种特殊的 for 语格式称之为 foreach 语句。foreach 语句在遍历数组等方面提供了很大的方便。
语法如下:
for(循环变量x：遍历对象obj){
引用了x的java语句;
}
代码如下：
public class SD{
public static void main(String[] args) {
int arr[]={7,10,1}; //声明一维数组
System.out.println("一维数组中的元素分别为："); //输出信息
for(int x:arr){ //foreach语句，int x引用的变量，arr指定要循环遍历的数组，最后将x输出
System.out.println(x); //输出x的值
}
}
}
运行结果为：
3.3.6 循环语句的嵌套
循环有 for、while、do...while 这3种方式，这3种循环可以相互嵌套。
语法如下：
for 语句
for(...)
{
for(...)
{
...
}
}
while语句
while(...)
{
while(...)
{
....
}
}
while 和for 语句
while(...)
{
for(...)
{
....
}
}
代码如下：
public class SD{
public static void main(String[] args) {
int i,j; //创建两个整数变量
for(i=1;i<10;i++){ //输出9行
for(j=1;j
运行结果为：
3.4 跳转语句
跳转语句包含两方面的内容，一方面是控制循环变量的变化方式，也就是让循环判断中的逻辑关系表达式变成 false，从而达到终止循环的效果:一方面是控制循环的跳转。控制循环的跳转需要用到 break 和 continue 两个关键字，这两条跳转语句的跳转效果不同，break 是中断循环，continue是直接执行下一次循环。
3.4.1 break语句
使用 break 语句可以跳出 switch 结构。在循环结构中，同样也可用 break 语句跳出当前循环体,从而中断当前循环。
代码如下：
public class SD{
public static void main(String[] args) {
for(int i=1;i<20;i++){//for语句控制循环次数
if(i%2==0){//如果i是偶数
System.out.println(i);//输出i的值
break;//跳出下一次循环
}
}
System.out.println("---end---");//输出
}
}
运行结果为：
break 标签名:break 跳出指定的循环体，此循环体的标签名必须与 break的标签名一致。带有标签的 break 可以制定跳出的循环，这个循环可以是内层循环，也可以是外层循环。
3.4.2 continue 语句
continue 语句是针对 break 语句的补充。continue不是立即跳出循环体，面是跳过本次循环结束前的语句，回到循环的条件测试部分，重新开始执行循环。在 for 循环语句中遇到 continue 语句后，首先执行循环的增量部分，然后进行条件测试。在 while 和 do….while 循环中，continue 语句使控制直接回到条件测试部分。
代码如下：
public class SD{
public static void main(String[] args) {
for(int i=1;i<20;i++){ //控制循环次数
if(i%2!=0){ //如果i不是偶数
continue; //跳出下一循环
}
System.out.println(i); //输出i的值
}
}
}
运行结果为：
