Java Basics Two

JAVA流程Control StatementsJAVA中非常重要的Basic知识点务必完全理解Master，Summary记录一下之前Study Notes。JAVA流程Control Statements是编程的Basic知识，主要是为了更好的组织Code的Execute流程，下面将详细介绍java流程Control Statements。

一、选择结构if

if条件语句分为三种格式。

1. if语句

   如果满足某种条件就Execute。

   

   if语句格式：

   if（条件）{
   	语句的Execute体
   }

   条件：结果必须是布尔Type 1==1 true || false Execute体：当id条件为true的时候，Execute大括号中的语句，否则什么都不做。

   例如：

   /**
    * if语句例子
    */
   public class IfDemo {
   
   	public static void main(String[] args) {
   		// TODO Auto-generated method stub
   		int i = 5;
   		if(i==5) {
   			System.out.println("if中的条件是true");
   			i++;
   		}
   		System.out.println("i="+i);
   	}
   
   }

   注意：if()括号后面没有分号”;”

2. if…else语句

   如果满足某种条件，就Execute某种处理，否则就Execute另一种处理。

   

   if … elseSyntax格式：

   if(条件){
   	if的Execute体
   }else{
   	else的Execute体
   }

   当if中的条件为true时，Executeif的Execute体，为false时，Executeelse的Execute体。

   例如：

   **
    * if ... else 语句
    * */
   public class IfElseDemo {
   
   	public static void main(String[] args) {
   		int i = 13;
   		if(i%2==0) {
   			System.out.println(i+"是偶数");
   		}else {
   			System.out.println(i+"是奇数");
   		}
   	}
   
   }

3. if…else if…else语句

   用于多条件进行判断，进行多种不同的处理。

   

   语句格式：

   if(条件1){
   	Execute语句1
   }else if(条件2){
   	Execute语句2
   }
   ... 
   else if(条件n){
   	Execute语句n
   }else{
   	Execute语句n+1
    }

当判断条件1为true时，if后面{}中的Execute语句1会Execute。当判断条件1为false时，会继续Execute判断条件2，如果为true则Execute语句2，以此类推，如果所有的判断条件都为false，则意味着所有条件均未满足，else后面{}中的Execute语句n+1会Execute。 注意：条件最后都是boolean值，要么true要么false。

例如： 
  ```java
package java_learn_code;

import java.util.Scanner;

/**
* if...else if...else
* 多条件判断
*/
public class IfElseIfElseDemo {
public static void main(String[] args) {
	while(true) {
		System.out.print("请输入分数:");
		Scanner scan = new Scanner(System.in);
		double sum = scan.nextDouble();
		if(sum<90) {
			System.out.print("可以哦");
		}else if(sum <=80) {
			System.out.println("合格");
		}else if(sum <=60){
			System.out.println("不及格");
		}else {
			System.out.println("分数有Problem");
		}
		System.out.println("");
	}
}
}
  ```

注意:if…else只能进行单条件判断，而if…else if…else可以进行多条件进行判断了。if..else也可以Implementation，但是效率没有if..else .. if … else效率高。

二、三元运算符

三元运算符得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为Expression1的值，否则结果为Expression2的值。

三元运算符和if…else类似，Syntax如下：

判断条件 ？ 表达式1 : 表达式2

例如：

package java_learn_code;
/**
 * if..else 与三元运算符的转换
 */
public class IfAllDemo {

	public static void main(String[] args) {
		int m = 10;
		int n = 8;
		//if...else运算
		if(m>n) {
			System.out.println(m);
		}else {
			System.out.println(n);
		}
		
		//三元运算符运算
		System.out.println(m>n ? m : n);
	}

}

注意：如果判断条件比较多，Usage三元运算符，是必须有结果的，而if语句可以没有结果的。

三、循环语句while

while语句会反复地进行条件判断，只要条件成立，{}内的Execute语句就会Execute，直到条件不成立，while循环结束。

while循环语句的Syntax结构:

while(循环条件){
执行语句
………
}

说明：{}中的Execute语句被称作循环体，循环体是否Execute取决于循环条件。当循环条件为true时，循环体就会Execute。 循环体Execute完毕时会继续判断循环条件，如条件仍为true则会继续Execute，直到循环条件为false时，整个循环过程才会结束。

例如：

/**
 * while循环语句
 */
public class WhileDemo {

	public static void main(String[] args) {
		int i = 0;
		while(i<5) {
			System.out.println("i="+i);
			i++;
		}
	}

}

注意：i++用于在每次循环时改变变量i的值，从而达到最终改变循环条件的目的。如果没有这行Code，整个循环会进入无限循环的状态，永远不会结束。

四、循环语句for

Syntax格式：

for（初始化表达式; 循环条件; 操作表达式）{
	执行语句
	………
}

说明：

初始化变量：定义变量，用于控制循环的次数。

条件：当条件是true的时候，Execute循环体，为false时，结束循环。

增量：变量自增情况

/**
 * for循环
 * @author Jole
 * */
public class ForDemoOne {

	public static void main(String[] args) {
        //1、变量  2、条件 3、增量 
		for(int i=0;i<5;i++) {
			System.out.println("i="+i); //两大括号之间：4、循环体
		}
	}

}

Execute过程：

第一步：变量定义i，在整个循环中，只会执行一次（int i=0,在整个过程中至执行一次）。
第二步：如果条件为false，整个循环就结束了。
第三步：如果为true时，执行循环体。
第四步：增量，i++
第五步：重复走条件(第二步或第三步)
后面继续循环
注意：int i=0；终其一生只运行一次。条件为false时，不会在走增量，而是直接结束了

注意：int i=0；终其一生只Run一次。条件为false时，不会在走增量，而是直接结束了。

分析for循环的Execute流程：

for（1 ; 2 ; 3）{
	4
}
第一步，执行1
第二步，执行2，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行4
第四步，执行3，然后重复执行第二步
第五步，退出循环

注意事项：

1、初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。
2、int i=0；终其一生只运行一次。
3、条件为false时，不会在走增量i++，而是直接结束了。

Example：用for循环进行累加求和。1+2+3+4…+100=?

/**
 * 用for循环进行累加求和，1+2+3+4...+100=?
 */
public class ForSum {

	public static void main(String[] args) {
		int sum = 0;
		for(int i=1;i<=100;i++) {
			sum += i;
		}
		System.out.println("sum="+sum);
	}
}

五、do…while()循环

do…while循环语句和while循环语句功能类似。

Syntax格式：

do {
执行语句
………
} while(循环条件);

说明： 关键字do后面{}中的Execute语句是循环体。do…while循环语句将循环条件放在了循环体的后面。意味着，循环体会无条件Execute一次，然后再根据循环条件来决定是否继续Execute。

public class DowhileDemo {

	public static void main(String[] args) {
		int i = 1;
		do {
			i++;
		}while(i<0);
		System.out.println("i="+i);
	}

}

注意：无论条件是否成立，都会Execute一次循环体。

do …while循环和while循环能Implementation同样的功能，区别在于，如果循环条件在循环语句开始时就不成立，那么while循环的循环体一次都不会Execute，而do…while循环的循环体还是会Execute一次。（无论条件是否成立，do…while都会Execute一次循环体）

六、死循环(无限循环)

最简单无限循环格式：

while(true){} 
或
for(;;){}

注意：无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

/**
* while、for死循环
*/
public class DeadDemo {

	public static void main(String[] args) {
		//while死循环
		while(true) {
		}
		//for死循环(注意：上面的while死循环，这个for死循环不会执行)
		for( ;true ; ) {
			
		}
	}

}

注意：上面的while死循环，这个for死循环不会Execute。

七、循环嵌套

嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的Syntax结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。

在for循环中嵌套for循环，格式如下：

for(初始化表达式; 循环条件; 操作表达式) {
	………
	for(初始化表达式; 循环条件; 操作表达式) {
		执行语句
		………
	}
	………
}

嵌套循环的Execute顺序：

public class ForForDemoTwo {

	public static void main(String[] args) {
		for(int i = 0;i < 2;i++) {
			for(int j = 0; j<2 ;j++) {
				
			}
		}
	}
}

Execute顺序说明:

1.i=0
2.i<2
    
3.执行循环体j=0
4.j<2
5.执行内循环的循环体
6.j++ 1
    
7.j<2
8.执行内循环的循环体
9.j++
10.j<2 内循环结束

11.外循环的增量i++ 1
    
12.i<2
    
执行3到10步骤
13.外循环的增量i++ 2
14.i<2

注意：循环次数=外循环次数*内循环次数。内循环是外循环的一个循环体。嵌套循环：主要是理解Execute顺序

Example：打印三角形

public class ForForDemo {
	public static void main(String[] args) {
		for(int i=1;i<=5;i++) {
			for(int j=1;j<i;j++) {
				System.out.print("* ");
			}
			System.out.println("*");	
		}
	}
}

输出结果：

```
* * *
* * *
* * * *
* * * * *

八、跳转语句(break、continue)

跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句。

1. break语句

1、在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。
2、当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。

   public class BreakDemo {
   	public static void main(String[] args) {
   		int i=1;
   		while(true) {
   			if(i==3) {
   				break;
   			}else {
   				System.out.println("i="+i);
   			}
   			i++;
   		}
   	}
   }

输出结果：

i=1
i=2

多循环，break是结束的哪个循环?

   public class MostForBreakDemo {
   	public static void main(String[] args) {
   		for(int i=1;i<5;i++) {
   			for(int j=1;j<7;j++) {
   				if(j==4) {
   					break;
   				}else {
   					System.out.print(" j="+j);
   				}
   			}
   			System.out.println(" i="+i);
   		}
   	}
   }

注意：当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。 标记:当多层循环时，想在内循环结束外循环通过加标记结束。

   package java_learn_code;
   public class MostForBreakDemo {
   	public static void main(String[] args) {
   		a:for(int i=1;i<4;i++) {
   			for(int j=1;j<7;j++) {
   				if(j==4) {
   					break a;
   				}else {
   					System.out.print(" j="+j);
   				}
   			}
   			System.out.println(" i="+i);
   		}
   	}
   }

输出结果：

 j=1 j=2 j=3

switch或循环遇到break就全结束。

2. continue语句

   continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。

   public class ContinueDemo {
   	public static void main(String[] args) {
   		for (int j = 1; j < 7; j++) {
   			if (j == 4) {
   				continue;
   			} else {
   				System.out.print("  j=" + j);
   			}
   		}
   	}
   }

输出结果：

  j=1  j=2  j=3  j=5  j=6

多层循环，通过标记，跳过外层其中一次循环。

   public class ContinueDemoTwo {
   	public static void main(String[] args) {
   		a:for(int i=1;i<7;i++) {
   			for(int j=1;j<4;j++) {
   				if(i==3) {
   					continue a;
   				}else {
   					System.out.print("  j="+j);
   				}
   			}
   			System.out.println(" i="+i);
   		}
   	}
   }

输出结果：

  j=1  j=2  j=3 i=1
  j=1  j=2  j=3 i=2
  j=1  j=2  j=3 i=4
  j=1  j=2  j=3 i=5
  j=1  j=2  j=3 i=6

注意：同样支持标记，跳过某一次循环。

九、综合实例：随机猜数字

   import java.util.Random;
   import java.util.Scanner;
   
   public class DemoOne {
   	public static void main(String[] args) {
   		while(true) {
   			System.out.print("请输入猜的数字：");
   			Scanner scan = new Scanner(System.in);
   			int number = scan.nextInt();
   			Random ran = new Random();
   			int yourNum = ran.nextInt(10)+1;
   			if(number==yourNum) {
   				System.out.println("恭喜你猜对了，么么哒！");
   				break;
   			}else if(number>yourNum) {
   				System.out.println("输入的值："+number);
   				System.out.println("随机值："+yourNum);
   				System.out.println("sorry....猜大了哦");
   			}else {
   				System.out.println("输入值："+number);
   				System.out.println("随机值："+yourNum);
   				System.out.println("sorry....猜小洛");
   			}
   			System.out.println("");
   		}
   	}
   }

十、选择结构switch

选择结构switch，switch 条件语句也是一种很常用的选择语句，它和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。

Switch语法格式:

switch (Expression){
	case 目标值1:
		Execute语句1
		break;
	case 目标值2:
		Execute语句2
		break;
	．．．．．．
	case 目标值n:
		Execute语句n
		break;
	default:
		Execute语句n+1
		break;
}

说明：

switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的语句，如果没找到任何匹配的值，就会执行default后的语句。break的作用是跳出switch语句。在switch语句中的表达式只能是byte、short、char、int类型的值，如果传入其它类型的值，程序会报错。

但上述说法并不严谨，实际上在JDK5.0中引入的新特性enum枚举也可以作为switch语句表达式的值，在JDK7.0中也引入了新特性，switch语句可以接收一个String类型的值。

实例：数字转星期

public class SwitchDemo {
	public static void main(String[] args) {
		boolean flag=true;
		while(flag) {
			System.out.print("星期转换：");
			Scanner scan = new Scanner(System.in);
			int num = scan.nextInt();
			switch(num) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				flag = false;
				System.out.println("退出成功！");
			}
			System.out.println("");
		}
	}
}

Case的穿透性：在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。

实例：判断一周中的某一天是否为工作日

import java.util.Scanner;
public class SwitchCaseDemo {
	public static void main(String[] args) {
		boolean flag=true;
		while(flag) {
			System.out.print("星期转换：");
			Scanner scan = new Scanner(System.in);
			int num = scan.nextInt();
			switch(num) {
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("工作日");
				break;
			case 6:
			case 7:
				System.out.println("休息日");
				break;
			default:
				flag = false;
				System.out.println("推出成功！");
			}
			System.out.println("");
		}
	}
}

没有break就会一直往下穿透。

例如： 
  ```java
package java_learn_code;

import java.util.Scanner;

/**
* if...else if...else
* 多条件判断
*/
public class IfElseIfElseDemo {
public static void main(String[] args) {
	while(true) {
		System.out.print("请输入分数:");
		Scanner scan = new Scanner(System.in);
		double sum = scan.nextDouble();
		if(sum<90) {
			System.out.print("可以哦");
		}else if(sum <=80) {
			System.out.println("合格");
		}else if(sum <=60){
			System.out.println("不及格");
		}else {
			System.out.println("分数有问题");
		}
		System.out.println("");
	}
}
}
  ```

判断条件 ？ 表达式1 : 表达式2

package java_learn_code;
/**
 * if..else 与三元运算符的转换
 */
public class IfAllDemo {

	public static void main(String[] args) {
		int m = 10;
		int n = 8;
		//if...else运算
		if(m>n) {
			System.out.println(m);
		}else {
			System.out.println(n);
		}
		
		//三元运算符运算
		System.out.println(m>n ? m : n);
	}

}

while(循环条件){
执行语句
………
}

/**
 * while循环语句
 */
public class WhileDemo {

	public static void main(String[] args) {
		int i = 0;
		while(i<5) {
			System.out.println("i="+i);
			i++;
		}
	}

}

for（初始化表达式; 循环条件; 操作表达式）{
	执行语句
	………
}

/**
 * for循环
 * @author Jole
 *
 */
public class ForDemoOne {

	public static void main(String[] args) {
        //1、变量  2、条件 3、增量 
		for(int i=0;i<5;i++) {
			System.out.println("i="+i); //两大括号之间：4、循环体
		}
	}

}

第一步：变量定义i，在整个循环中，只会执行一次（int i=0,在整个过程中至执行一次）。
第二步：如果条件为false，整个循环就结束了。
第三步：如果为true时，执行循环体。
第四步：增量，i++
第五步：重复走条件(第二步或第三步)
后面继续循环
注意：int i=0；终其一生只运行一次。条件为false时，不会在走增量，而是直接结束了

for（1 ; 2 ; 3）{
	4
}
第一步，执行1
第二步，执行2，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行4
第四步，执行3，然后重复执行第二步
第五步，退出循环

1、初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。
2、int i=0；终其一生只运行一次。
3、条件为false时，不会在走增量i++，而是直接结束了。

/**
 * 用for循环进行累加求和，1+2+3+4...+100=?
 */
public class ForSum {

	public static void main(String[] args) {
		int sum = 0;
		for(int i=1;i<=100;i++) {
			sum += i;
		}
		System.out.println("sum="+sum);
	}
}

do {
执行语句
………
} while(循环条件);

public class DowhileDemo {

	public static void main(String[] args) {
		int i = 1;
		do {
			i++;
		}while(i<0);
		System.out.println("i="+i);
	}

}

while(true){} 
或
for(;;){}

/**
* while、for死循环
*/
public class DeadDemo {

	public static void main(String[] args) {
		//while死循环
		while(true) {
		}
		//for死循环(注意：上面的while死循环，这个for死循环不会执行)
		for( ;true ; ) {
			
		}
	}

}

for(初始化表达式; 循环条件; 操作表达式) {
	………
	for(初始化表达式; 循环条件; 操作表达式) {
		执行语句
		………
	}
	………
}

public class ForForDemoTwo {

	public static void main(String[] args) {
		for(int i = 0;i < 2;i++) {
			for(int j = 0; j<2 ;j++) {
				
			}
		}
	}
}

1.i=0
2.i<2
    
3.执行循环体j=0
4.j<2
5.执行内循环的循环体
6.j++ 1
    
7.j<2
8.执行内循环的循环体
9.j++
10.j<2 内循环结束

11.外循环的增量i++ 1
    
12.i<2
    
执行3到10步骤
13.外循环的增量i++ 2
14.i<2

public class ForForDemo {
	public static void main(String[] args) {
		for(int i=1;i<=5;i++) {
			for(int j=1;j<i;j++) {
				System.out.print("* ");
			}
			System.out.println("*");	
		}
	}
}

```
*
* *
* * *
* * * *
* * * * *

1、在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。
2、当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。

   public class BreakDemo {
   	public static void main(String[] args) {
   		int i=1;
   		while(true) {
   			if(i==3) {
   				break;
   			}else {
   				System.out.println("i="+i);
   			}
   			i++;
   		}
   	}
   }

i=1
i=2

   public class MostForBreakDemo {
   	public static void main(String[] args) {
   		for(int i=1;i<5;i++) {
   			for(int j=1;j<7;j++) {
   				if(j==4) {
   					break;
   				}else {
   					System.out.print(" j="+j);
   				}
   			}
   			System.out.println(" i="+i);
   		}
   	}
   }

   package java_learn_code;
   public class MostForBreakDemo {
   	public static void main(String[] args) {
   		a:for(int i=1;i<4;i++) {
   			for(int j=1;j<7;j++) {
   				if(j==4) {
   					break a;
   				}else {
   					System.out.print(" j="+j);
   				}
   			}
   			System.out.println(" i="+i);
   		}
   	}
   }

 j=1 j=2 j=3

   public class ContinueDemo {
   	public static void main(String[] args) {
   		for (int j = 1; j < 7; j++) {
   			if (j == 4) {
   				continue;
   			} else {
   				System.out.print("  j=" + j);
   			}
   		}
   	}
   }

  j=1  j=2  j=3  j=5  j=6

   public class ContinueDemoTwo {
   	public static void main(String[] args) {
   		a:for(int i=1;i<7;i++) {
   			for(int j=1;j<4;j++) {
   				if(i==3) {
   					continue a;
   				}else {
   					System.out.print("  j="+j);
   				}
   			}
   			System.out.println(" i="+i);
   		}
   	}
   }

  j=1  j=2  j=3 i=1
  j=1  j=2  j=3 i=2
  j=1  j=2  j=3 i=4
  j=1  j=2  j=3 i=5
  j=1  j=2  j=3 i=6

   import java.util.Random;
   import java.util.Scanner;
   
   public class DemoOne {
   	public static void main(String[] args) {
   		while(true) {
   			System.out.print("请输入猜的数字：");
   			Scanner scan = new Scanner(System.in);
   			int number = scan.nextInt();
   			Random ran = new Random();
   			int yourNum = ran.nextInt(10)+1;
   			if(number==yourNum) {
   				System.out.println("恭喜你猜对了，么么哒！");
   				break;
   			}else if(number>yourNum) {
   				System.out.println("输入的值："+number);
   				System.out.println("随机值："+yourNum);
   				System.out.println("sorry....猜大了哦");
   			}else {
   				System.out.println("输入值："+number);
   				System.out.println("随机值："+yourNum);
   				System.out.println("sorry....猜小洛");
   			}
   			System.out.println("");
   		}
   	}
   }

switch (表达式){
	case 目标值1:
		执行语句1
		break;
	case 目标值2:
		执行语句2
		break;
	．．．．．．
	case 目标值n:
		执行语句n
		break;
	default:
		执行语句n+1
		break;
}

public class SwitchDemo {
	public static void main(String[] args) {
		boolean flag=true;
		while(flag) {
			System.out.print("星期转换：");
			Scanner scan = new Scanner(System.in);
			int num = scan.nextInt();
			switch(num) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				flag = false;
				System.out.println("退出成功！");
			}
			System.out.println("");
		}
	}
}

import java.util.Scanner;
public class SwitchCaseDemo {
	public static void main(String[] args) {
		boolean flag=true;
		while(flag) {
			System.out.print("星期转换：");
			Scanner scan = new Scanner(System.in);
			int num = scan.nextInt();
			switch(num) {
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("工作日");
				break;
			case 6:
			case 7:
				System.out.println("休息日");
				break;
			default:
				flag = false;
				System.out.println("推出成功！");
			}
			System.out.println("");
		}
	}
}