目录

3.1程 序 结 构

3.2条件语句

1.简单的if条件语句 语法如下：

​ 2.if...else 语句

3.if....else if多分支语句，语法： 

4.嵌套if语句的使用 

5.swich多分支语句 

3.3循环语句

1.while循环语句

 2.do...while循环语句

3.while与do...while比较 

​ 4.for循环语句

5.foreach语句 

 6.循环语句的嵌套

​ 

3.4跳转语句

1. break语句

2.continue语句  

3.5小结 

由顺序结构.选择结构.循环结构组成的基本结构。

3.2条件语句

1.简单的if条件语句 语法如下：

1. if(布尔表达式）{
2. 语句;
3. } 

• 布尔表达式：必要参数，它最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，也可以是关系表达式

public class test2 {
	public static void main(String[]args){
		if(true)//让判断条件永远为真
			System.out.println("我没有使用大括号");//没有大括号，直接跟在if语句之后
		if(true)//让判断条件永远为真
			System.out.println("我使用大括号");//输出语句大括号之内
	}
 
}

import java.util.Scanner;
 
public class test3 {
public static void main(String[]args){
	Scanner in=new Scanner (System.in);//创建Scanner对象，用于进行输入
	System.out.println("请输入要拨打的电话号码：");//输出
	int phoneNumber=in.nextInt();//创建变量，保存电话号码
	if(phoneNumber!=84972266)//判断此电话号码是否是84972266，如果不是84972266号码，则提示号码不存在
		System.out.println("对不起，您拨打的号码不存在！");//输出
		
}
}

 2.if...else 语句

注意else不能单独使用，必须和关键字if一起出现。

public class test4 {
	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("英语没有及格");//条件不成立输出的信息
		}
	}
 
}

3.if....else if多分支语句，语法： 

if(表达式1）{
语句1;
}
else if(表达式2）{
语句2;
}
...
else if(表达式n){
语句n
}

 

public class test5 {
 
	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;
    }
} else {
    if(表达式3) {
        语句块3;
    } else if(表达式4) {
        语句块4;
    } else {
        if(表达式n) {
            语句块n;
        } else {
            语句块n+1;
        }
    }
}

例判断是否是闰年

package test;

import java.util.Scanner;
public class JudgeLeapYear {
	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");			// 不是闰年
	}
}

package test;

import java.util.Scanner;
public class JudgeLeapYear2 {
	public static void main(String[] args) {
		int iYear; // 创建整型变量，保存输入的年份
		Scanner sc = new Scanner(System.in); // 创建扫描器
		System.out.println("please input number");
		iYear = sc.nextInt(); // 控制台输入一个数字
		// 如果iYear可以被4整除并且不能被100整除，或者iYear可以被400整除
		if (iYear % 4 == 0 && iYear % 100 != 0 || iYear % 400 == 0)
			System.out.println("It is a leap year"); // 是闰年
		else
			System.out.println("It is not a leap year");// 不是闰年
	}
}

5.swich多分支语句 

switch(表达式) {
    case 值1:
        语句块1;
        break;
    case 值2:
        语句块2;
        break;
    …
    case 值n:
        语句块n;
        break;
    default:
        语句块n+1;
    break;
}

1.switch
表示“开关”，这个开关就是 switch 关键字后面小括号里的值，小括号里要放一个整型变量或字符型变量。表达式必须为 byte，short，int，char类型
2.case
表示“情况，情形”，case 标签可以是：
类型为 char、byte、 short 或 int 的常量表达式。
枚举常量。
3.default
表示“默认”，即其他情况都不满足。default 后要紧跟冒号，default 块和 case 块的先后顺序可以变动，不会影响程序执行结果。通常，default 块放在末尾，也可以省略不写。
4.break
表示“停止”，即跳出当前结构。

package test;

public class GetSwitch {
	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");
		}
	}
}

3.3循环语句

循环语句：while循环语句、do...whlie语句、for循环语句 、foreach语句、循环语句的嵌套。

1.while循环语句

语法如下：

while(条件表达式)
{
执行语句
} 

• while语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句。
• 当条件表达式的返回值为真时，则执行”{}“中的语句，当执行完“{}”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环

public class test11 {
 
	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输出
 
	}
 
}

 2.do...while循环语句

•  do....while循环语句 ：先执行一次循环后，再判断条件是否成立。也就是说do...while循环语句中“{}”中的程序段至少要被执行一次。
• 语法如下：

do
{
执行语句
}
while(条件表达式);

 

public class test12 {
 
	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<1，明显循环条件不成立。 

public class test13 {
 
	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);//输出
		
	}
 
}

 4.for循环语句

语法如下：

for(表达式1;表达式2;表达式3){
语句
}

1. 先执行表达式1 。
2. 判断表达式2，若其值为真，则执行for语句中指定的内嵌语句，然后执行3.。若为假，则结束循环，转到5.。
3. 执行表达式3.
4. 返回2.继续执行。
5. 循环结束，执行for语句下面的一个语句。

 

public class test15 {
 
	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);//输出
	}
 
}

运行结果：

5.foreach语句 

语法如下：

for(循环变量x：遍历对象obj){
引用了x的java语句;
}

•  其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素 

package test;

public class Repetition { 								//创建类Repetition
	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);
		}
	}
}

 运行结果：

 6.循环语句的嵌套

 循环有for.while.do.....while三种方式，三种循环可以互相嵌套列。

在for循环中套用for循环。

for(...)
{
for(...)
{
...
}
}

在while循环中套用while循环。

while(...)
{
while(...)
{
....
}
} 

在while循环中套用for循环。

while(...)
{
for(...)
{
....
}
}

使用嵌套的for循环输出乘法口诀表。

package test;

public class Multiplication {
	public static void main(String[] args) {
		int i, j;  // 创建两个整型变量
		for (i = 1; i < 10; i++) {  // 输出9行
			for (j = 1; j < i + 1; j++) {  // 输出与行数相等的列
				System.out.print(j + "*" + i + "=" + i * j + "t");
			}
			System.out.println();  // 换行
		}
	}
}

3.4跳转语句

1. break语句

break语句：使用break语句可以跳出switch结构。在循环中可以跳出当前循环体，从而中断当前循环。

package test;

public class BreakTest {
	public static void main(String[] args) {
		for (int i = 1; i < 20; i++) {
			if (i % 2 == 0) {// 如果i是偶数
				System.out.println(i);// 输出i的值
				break;// 跳到下一循环
			}
		}
		System.out.println("---end---");
	}
}

 使用break跳出内层循环

public class test19 {
 
	public static void main(String[] args) {
		for(int i=0;i<3;i++){//外循环
			for(int j=0;j<6;j++){//内循环
				if(j==4){//如果j等于4的时候就结束内部循环
					break;//跳出内循环
				}
				System.out.println("i="+i+"j="+j);//输出内容
			}
		}
 
	}
 
}

• 如果想要让break跳出外层循环，java提供了标签的功能，语法如下： 

标签名：循环体{
break标签名;
} 

标签名：任意标识符。

循环体：任意循环语句

break标签名：break跳出指定的循环体，此循环的标签名必须与break的标签名一致。带有标签的break可以制定跳出外层循环，这个循环可以是内层循环，也可以是外层循环。

使用带标签的break跳出外层循环。

public class test20 {
 
	public static void main(String[] args) {
		Loop:for(int i=0;i<3;i++){//在for循环前用标签标记
			for(int j=0;j<6;j++){//内循环
				if(j==4){//如果j等于4的时候就结束外层循环
					break Loop;//跳出Loop标签标记的循环体
				}
				System.out.println("i="+i+"j="+j);//输出
			}
		}
	}
 
}

2.continue语句  

continue语句则是针对break语句的补充，不是立即跳出循环体语句而且跳过本次循环结束前的语句，回到循环的条件测试部分，重新开始执行循环。continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。

输出1-20（不包含20）的偶数，使用continue语句跳出循环。

public class test21 {
 
	public static void main(String[] args) {
		for(int i=1;i<20;i++){//控制循环次数
			if(i%2!=0){//如果i不是偶数
				continue;//跳出下一循环
			}
			System.out.println(i);//输出i的值
		}
 
	}
 
}

3.5小结 

本章介绍了流程控制语句（条件语句、循环语句和跳转语句）；通过使用if与switch语句，可以基于布尔类型的测试，将一个程序分成不同的部分；通过while、do...while循环语句和for循环语句，可以让程序的一部分重复执行，直到满足某个终止循环条件；使用跳转语句和循环语句变得更加灵活，