Java_基础_10.控制语句（control statement）

控制语句

结构	作用
顺序	代表“先执行a，再执行b”的逻辑
选择	代表“如果…，则…”的逻辑。
循环	代表“如果…，则再继续…”的逻辑。

选择结构

1. if单选择结构
2. if-else双选择结构
3. if-else if-else多选择结构
4. switch结构

if

省略

if else

/**
 * 测试if单选择结构
 * @author creep_creep_creep
 *
 */
public class A_if {
	public static void main(String[] args) {
		double d=Math.random();
		System.out.println(d);
		int i=(int)(6*Math.random()+1);
		System.out.println("************");
		if(i<6) {
			System.out.println("小");
		}else {
			System.out.println("大");
		}
	}
}

if else if

/**
 * 测试if else if
 * @author creep_creep_creep
 *
 */
public class A_ifelse {
	public static void main(String[] args) {
		int age=(int)(100*Math.random());
		System.out.println("年龄"+age);
		
		if (age<15) {
			System.out.println("儿童");
		}else if(age<25) {
			System.out.println("青年");
		}else if (age<45) {
			System.out.println("中年");
		}else if (age<65) {
			System.out.println("中老年");
		}else if (age<85) {
			System.out.println("老年");
		}else {
			System.out.println("老寿星");
		}
	}
}

switch

/**
 * 测试switch语句
 * 遇到多值判断的时候使用
 * @author creep_creep_creep
 *
 */
public class A_switch {
	public static void main(String[] args) {
		int month=(int)(1+12*Math.random());
		System.out.println("月份"+month);
		
		switch(month) {//正数，枚举，1.7之后的字符串
		case 1:
			System.out.println("一月");
			break;
		case 2:
			System.out.println("二月");
			break;
		case 3:
			System.out.println("三月");
		}
	}
}

循环结构

类型	说明
当型	当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
直到型	先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。

while循环

语法结构：

while (布尔表达式) {
    循环体;
}

• 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
• 语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

while循环结构流程图。

/**
 * 测试while
 * @author creep_creep_creep
 *
 */
public class A_while {
	public static void main(String[] args) {
		int i=1;
		int sum=0;
		
		while (i<=100) {
			sum=sum+i;
			i++;
		}
		System.out.println(sum);
	}
}

do-while循环

语法结构：

do {
        循环体;
     } while(布尔表达式) ;

do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。

/**
 * 测试Dowhile循环
 * @author creep_creep_creep
 *
 */
public class A_do {
	public static void main(String[] args) {
		int i=0;
		int sum=0;
		do {
			sum=sum+i;
			i++;
		}while(i<=100);
		System.out.println(sum);
	}
}

for循环

语法结构：

for (初始表达式; 布尔表达式; 迭代因子) {
      循环体;
}

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

A. 初始化部分设置循环变量的初值
B. 条件判断部分为任意布尔表达式
C. 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。

/**
 * 测试for循环
 * @author creep_creep_creep
 *
 */
public class A_for {
	public static void main(String[] args) {
		int sum=0;
		
		for(int i=1;i<=100;i++) {//for循环定义的i只在循环中有效
			sum=sum+i;
		}
		
		System.out.println(sum);
		
		for(int j=1,k=j+10; j<5; j++,k=j*2) {
			System.out.println(k);
		}
		
		for(;;) {
			System.out.println("爱你到永远");//会一直循环
		}
	}
}

嵌套循环（nesting loop）

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层。

/**
 * 嵌套循环
 * @author creep_creep_creep
 *
 */
public class A_nesting {
	public static void main(String[] args) {
		int i,j;
			
		for(i=0;i<4;i++) {
			for(j=i;j>=0;j--) {
				System.out.print(i+" ");
			}
			System.out.println();
		}
		
		for(i=4;i>=0;i--) {
			for(j=i;j>=0;j--) {
				System.out.print(i+" ");
			}
			System.out.println();
		}
	}
}

break语句和continue语句

在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。

/**
 * 测试循环语句中的break
 * @author creep_creep_creep
 *
 */

public class A_break {
	public static void main(String[] args) {
		int total=0;//定义计数器
		System.out.println("begin");
		while(true) {
			total++;//循环加一
			int i=(int)Math.round(100*Math.random());
			System.out.println(i);
			
			if(i==88) {//当等到88是对出循环
				break;//结束整个循环
			}
		}
		System.out.println("Game over,used "+total+" times");//输出循环次数
	}
}

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

/**
 * 测试continue的使用
 * @author creep_creep_creep
 *
 */
public class A_continue {
	public static void main(String[] args) {
		int count =0;
		for(int i=100;i<160;i++) {
			if(i%3==0) {
				continue;
			}
			System.out.print(i+"、");
			count++;
			
			if(count%5==0) {
				System.out.println();
			}
		}
	}
}

  1. continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
  2. continue用在for循环中，跳到for循环的迭代因子部分。

带标签的break和continue

“标签”是指后面跟一个冒号的标识符，例如：“label:”。对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

/**
 * 测试带标签的Break和continue
 * @author creep_creep_creep
 *
 */
public class A_outer {
	public static void main(String[] args) {
		outer:for(int i=101;i<150;i++) {
			for(int j=2;j<i/2;j++) {
				if(i%j==0) {
					continue outer;
				}
			}
			System.out.println(i+" ");
		}
	}
}