第二章 程序结构（1.6）

八、程序结构

8.1、顺序结构

顺序结构，自然就是按照程序的先后顺序进行执行。

Public class Text12 {
    Public static void mian(String[] args){
     int num1 = 10;
     int num2 = 20;
     int num3,num4;
     num3 = num1 + num2;
     num4 = num3*2;
     System.out.println(“num3 = ”+num3);
     System.out.printlm(“num4 = ”+num4);
   }
}

8.2、分支结构

分支结构，是根据是否满足条件来执行对应的程序段。

8.2.1 单分支if语句

单分支if语句就是使用一个布尔表达式进行条件判断，如布尔表达式的值为true,则执行{}内的程序段。

单分支if语句的语法格式：

If(布尔表达式){
//布尔表达式的值为ture时执行的程序段。
}

例：

Ppublic class Text13 {
      Public static void main(String[] args){
      int num = 100;
      if(num <= 200){
      System.out.println(“布尔表达式的值为ture。”);
     }
   }
}

8.2.2 双分支if…else语句

双分支if…else语句就是使用一个布尔表达式进行条件判断，如果布尔表达式的值为true,则执行{}内的程序段，如果布尔表达式的值为false,则执行else后面{}内的程序段。

== 双分支==if…else语句的语法格式：

if(布尔表达式){
//布尔表达式的值为true时执行的程序段。
}else{
//布尔表达式的值为false时执行的程序段。
} 

例：

Public class Text14 {
   Public static void main(String[] args){
   Scanner input = new Scanner(System.in)；
   System.out.println(“请输入数据num:”);
   num1 = inpput.nextin();
   num2 = input.nextint();
   if(num1 <= num2){
      System.out.println(“布尔表达式的值为true。”);
   }else{
      System.out.println(“布尔表达式的值为false。”);
   }
 }
}

注意：条件运算符也可以实现双分支if…else语句。

Public class Text15 {
     Public static void main(String[] args){
     Scanner input = new Scanner(System.in)；
     System.out.println(“请输入数据num:”);
     num1 = inpput.nextin();
     num2 = input.nextint();
     num = (num1 <= num2) ? num1 : num2;
     System.out.println(“输出最小的num = ”+num);
     //如果布尔表达式(num1 <= num2)的值为true,输出num = num1,如果值为false则输出num = num2  ; 
    }
}

8.2.3 嵌套的if…else语句

嵌套if…else语句就是在一个if…else语句中，套入另外一个if…else语句

嵌套if…else语句的语法格式：

if(布尔表达式1){
   //布尔表达式的值为true.
 if(布尔表达式2){}else{}
}else{
    //布尔表达式1的值为false.
  if(布尔表达式3){}else{}
}

例：

Public class Text {
      Public static void main(String[] args){
      Scanner input = new Scanner(System.in)；
      System.out.println(“请输入数据num:”);
      int num1 = input.nextin();
      int num2 = input.nextint();
      if(num1 <= num2){
         System.out.println(“布尔表达式的值为true。”);
         if(num1 <= num2/2){
            System.out.println(“num1小于num2的一半。”);
         }else{
            System.out.println(“num1大于num2的一半。”);
         }
     }else{
        System.out.println(“布尔表达式的值为false。”);
        if(num2 <= num1/2){
           System.out.println(“num2小于num1的一半。”);
        }else{
           System.out.println(“num2大于num1的一半。”);
     }
   }
  }
}

8.2.4 多分支if…else if…else语句

多分支if…else if…else语句中含有多个判断条件，每个布尔表达式的值为true时才会执行，将所有的条件判断完之后，没有满足的条件才会执行else后{}中的程序段。

多分支if…else if…else语句的语法格式：

if(布尔表达式1){
//布尔表达式1的值为true.
}else if(布尔表达式2){
//布尔表达式2的值为true.
}else if(布尔表达式3){
//布尔表达式3的值为true.
} else{
//所有的布尔表达式的值皆为false时执行的程序段。
}

8.2.5 switch语句

switch…case语句也是有多个判断条件，但不同if…else if…else语句的是，switch…case语句的case值为确定值，而if…else if…else语句的布尔表达式取值是一个范围。

switch…case语句的表达式：

switch (表达式) {
	case 常量1:
		语句1;
		Break;
	case 常量2:
		语句2;
		Break;
	[...]
	[default:
		语句n;
}

注意：

• key可以取什么值？
  1、能自动转换为int的数据类型。（char,byte,short,Integer）
  2、enum枚举类型
  3、字符串（string型）(JDK7之后)
• 穿透
  没有break会出现穿透的现象。

8.3、循环结构

循环结构就是在条件允许的情况下重复执行某段程序段。Java中主要有三种循环结构，while循环，do…while循环，for循环；

8.3.1 while循环语句

while循环首先使用一个布尔表达式进行条件判断，如果布尔表达式的值为true，表示条件满足，则执行while语句后紧跟的{}中的代码块，这段代码即循环体，循环体执行完之后，再计算布尔表达式进行条件判断，如果布尔表达式的值仍然为true，便再次执行循环体，形成循环；当布尔表达式的值为false时，直接执行循环体之后的代码。

While循环语句的语法：

While(布尔表达式){
//循环体
}

特点：先判断后执行。

8.3.2 do…while循环语句

do-while循环的原理与while循环基本相同，不同的是，do-while循环先执行一遍循环体中的代码块，再计算布尔表达式进行条件判断，如果布尔表达式的值仍然为true，便再次执行循环体，形成循环；当布尔表达式的值为false时，直接执行循环体之后的代码.

do...while循环语句的语法格式：

do{
//循环体
}while（布尔表达式）；

特点：先循环后判断，循环体至少要执行一次。

8.3.3 for循环语句

for循环语句是程序中使用最多的循环结构。for循环语句使用三个表达式，分别用来初始化循环变量，判断循环执行条件，以及改变循环变量。

For循环懂得语法格式：

For(表达式1，表达式2，表达式3){
//循环体
}

注意：

• 表达式1：定义初值；
• 表达式2：判断条件是否成立；
• 表达式3：判断值的改变。
• 特点：已知循环次数。

8.3 4 break语句

Java中提供了break语句，可用于switch语句或while、 do-while、for循环语句，如果程序执行到break语句，立即从switch语句或循环语句退出。

注意:break使执行位置跳到右括号外面。

8.3.5 continue循环语句

continue语句可用于fo、do-while、while语句的循环体中，如果程序执行到continue语句，则结束本次循环，回到循环条件处，判断是否执行下一次循环。

注意:continue使执行位置跳到左括号外面。

8.3.6 多重循环

如果循环语句的循环体中又包含循环语句，就形成了多重循环结构，称为循环嵌套。被包含的循环称为内循环，包含的循环称为外循环。常用的循环嵌套是二重嵌套和三重嵌套，更多重的=嵌套由于代码逻辑复杂，应当尽量避免使用。循环嵌套既可以是一种循环自身的嵌套，也可以是不同循环语句相互嵌套。

例：

public class Test {
	public static void main(String[] args) {
		// 使用双重for循环输出乘法口诀表
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(j + "x" + i + "=" + (j * i) + "\t");
			}
			System.out.println();
		}
	}
}