JavaSE(三)--选择结构与循环结构

1.变量的比较

• 基本数据类型(byte,short,int,long,float,double,char,boolean)的变量,用==表比较.
• 引用数据类型(String)的变量,用字符串1.equals(字符串2)表比较.

	eg:int num11=6;
		int num12=6;
		boolean result1=num11==num12;
		System.out.println("两个数的比较结果为:"+result1);
		
		String s1="我是学生";
		String s2="我是学生";
		boolean result2=s1.equals(s2);
		System.out.println("两个字符串的比较结果为:"+result2);

2.Java中三种结构:

• 顺序结构.
• 选择结构.
• 循环结构.

3.基本if选择结构:

有一种情况,满足就执行,没满足什么都不做.

3.1:语法:

if(布尔表达式){
		代码块;
	}

3.2:执行流程:

如果if后面小括号的布尔表达式为true,就执行大括号中代码块,否则就不执行.

	eg://第一步:导包
import java.util.Scanner; 

//基本if选择结构的使用

public class IfTest{
	/**
	*程序的入口方法
	*/
	public static void main(String[] args){
		//第二步:获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//给用户提示
		System.out.println("上课时是否有手机响了(y(是)/其他字母表示否):");
		//第三步:接收从键盘上的输入,并将输入的值赋值给变量
		String answer=input.next();
		
		if(answer.equals("y")){
			System.out.println("下课时又有人给我们发红包了");
		}
	}
}

4.if-else结构:

两种情况,无论如何都要执行其中一种.

4.1:语法:

if(布尔表达式){
			代码块1;
		}else{
			代码块2;
		}

4.2:执行流程:

• 如果布尔表达式的结果为true,就执行代码块1;
• 如果布尔表达式的结果为false,就执行代码块2;

		eg:public static void main(String[] args){
		//第二步:获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//给用户提示
		System.out.println("晨考是否考好(y(是)/其他字母表示否):");
		//第三步:接收从键盘上的输入,并将输入的值赋值给变量
		String answer=input.next();
		
		if(answer.equals("y")){
			System.out.println("老师请吃饭");
		}else{
			System.out.println("罚抄10遍");
		}
   }

5.多重if选择结构:

有两种及两种以上情况.

5.1:语法:

	if(布尔表达式1){
				代码块1;
			}else if(布尔表达式2){
				代码块2;
			}else if(布尔表达式3){
				代码块3;
			}else{
				else代码块;
			}

5.2:执行流程:

• 如果布尔表达式1为true,就执行代码块1,执行完之后,执行结构后面的语句;
• 如果布尔表达式1为false,就接着判断布尔表达式2,布尔表达式2为true,就执行代码块2,执行完之后,执行结构后面的语句;
• 如果布尔表达式2为false,就接着判断布尔表达式3,布尔表达式3为true,就代码块3,执行完之后,执行结构后面的语句;
• 如果上面的条件都不满足才会执行else代码块.

5.3:多重if结构特点:

• 1:在多重if结构中,if有且仅有一个;else if至少有一个,也可以有多个;else有0个或1个.
• 2:在多重if结构中,最多执行一个分支(一种情况),至少一个分支都不执行(当布尔表达式都为false,且没有else时).
• 3:在多重if结构中,如果是范围判断问题,如果条件有部分省略没写,那么我们范围从上到下,要么从小范围写到大范围,要么从大范围写到小范围,分支之间不可随便换位置,否则逻辑执行有问题.
  如果范围判断问题,条件写全了,那么分支之间互换位置是没有关系,不 影响结果;
• 4:在多重if结构中,如果是等值判断问题,分支之间互换位置,不影响结果.

//eg:
public static void main(String[] args){
		//第二步:获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//给用户提示
		System.out.println("请输入你银行存款:");
		//第三步:接收从键盘上的输入,并将输入的值赋值给变量
		double money=input.nextDouble();
		
		//java中不支持 100<money<1000
		if(money>1000){
			System.out.println("买兰博基尼");
		}else if(money>10&&money<=100){
			System.out.println("买五凌红光");
		}else if(money>100&&money<=1000){
			System.out.println("买宝马");
		}else{
			System.out.println("买自行车");
		}
	}

6.嵌套选择结构:

在选择结构的大括号中(代码块中)完整嵌套另一个选择结构.
注意: 嵌套要正确,在java中所有选择结构都可以随便嵌套,也可以多层嵌套,但是一般两到三层.

	eg:public static void main(String[] args){
		//第二步:获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//给用户提示
		System.out.println("请输入你银行存款:");
		//第三步:接收从键盘上的输入,并将输入的值赋值给变量
		double money=input.nextDouble();
		
		if(money>0){
			//java中不支持 100<money<1000
			if(money>1000){
				System.out.println("买兰博基尼");
			}else if(money>10&&money<=100){
				System.out.println("买五凌红光");
			}else if(money>100&&money<=1000){
				System.out.println("买宝马");
			}else{
				System.out.println("买自行车");
			}
		}else{
			System.out.println("你的输入有误或余额不够");
		}
	}

题目:现在举行百米赛跑运动,如果你百米赛跑的时间超过10秒,就谢谢参与;如果小于10秒就可以进入决赛,当进入决赛后,请输入性别,如果性别是男,恭喜你进入男子组决赛,如果性别是女,恭喜你进入女子组决赛.

//eg:/**
	*程序的入口方法
	*/
	public static void main(String[] args){
		//第二步:获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//给用户提示
		System.out.println("请输入你百米赛跑的时间(数字):");
		//第三步:接收从键盘上的输入,并将输入的值赋值给变量
		double time=input.nextDouble();
		
		if(time<=10&&time>0){
			System.out.println("恭喜你进入决赛");
			System.out.println("请输入你的性别:");
			String sex=input.next();
			if(sex.equals("男")){
				System.out.println("恭喜你进入男子组决赛");
			}else if(sex.equals("女")){
				System.out.println("恭喜你进入女子组决赛");
			}else{
				System.out.println("你输入的性别有误!");
			}
		}else if(time>10){
			System.out.println("谢谢参与!");
		}else if(time<=0){
			System.out.println("你的输入有误!");
		}
	}

7.switch选择结构:

有两种及两种以上等值判断问题.

7.1:语法:

	switch(变量/表达式){
				case 值1:
					代码块1;
					break;
				case 值2:
					代码块2;
					break;
				case 值3:
					代码块3;
					break;
				......
				default:
					default代码块;
					break;
			}

7.2:执行流程:

• 如果表达式的结果等于值1,就执行代码块1,遇到break或结尾大括号就跳出switch结构,执行这个结构之后的语句;
• 如果表达式的结果等于值2,就执行代码块2,遇到break或结尾大括号就跳出switch结构,执行这个结构之后的语句;
• 如果表达式的结果等于值3,就执行代码块3,遇到break或结尾大括号就跳出switch结构,执行这个结构之后的语句;
• 如果表达式不等于case后面的任何一个值,就默认执行default块,遇到break或结尾大括号就跳出switch结构.

7.3:结构特点:

• 在switch结构中,case块可以有1到多个;default块可以有0个到1个.
• 在switch结构中,break作用就是跳出switch结构.
• 在jdk1.7之前,switch结构的小括号中变量或表达式数据类型只能是 byte,short,int char类型;在jdk1.7之后,switch结构的小括号中变量 或表达式数据类型支持String类型.
• 在switch结构中,case块互换位置对结果没有影响;default可以放在switch结构大括号中任何地方.
• 在switch结构中,break可以省略,如果省略break关键字,只会判断一次满足条件,就执行这个case块,没有break就接着往后面继续,不会再判断,直到遇到 结尾大括号才能跳出结构.
• 在switch结构中,至少一种情况都不执行,最多全部情况都执行.

	eg:public static void main(String[] args){
		//第二步:获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//给用户提示
		System.out.println("请输入今天是星期几(1-7):");
		//第三步:接收从键盘上的输入,并将输入的值赋值给变量
		int today=input.nextInt();
		switch(today){
			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:
				System.out.println("你的输入有误!");
				break;
		}
	}

8.switch VS 多重if

8.1:相同点:

• 都可以解决多种情况等值判断问题(首选switch结构).
• 当条件不满足时,都有可能一种情况都不执行.

8.2:不同点:

• 多重if结构既能解决多种情况范围判断问题,又可以解决多种情况等值判断问题;
  switch结构只能解决多种情况的等值判断问题.
• 多重if结构最多只能执行一种情况;
  switch结构可以执行多种情况.
• 多重if结构小括号中式子(布尔表达式)的结果,只能是boolean类型;
  switch结构小括号中式子或变量,数据类型在jdk1.7之前,只能是 byte,short,int char类型;在jdk1.7之后,支持String类型.
• 多重if结构中分支情况不一定可以互换位置;
  在switch不省略break情况下,分支情况一定可以互换位置;

9.局部变量:

• 声明在方法中变量,或声明在方法中某个结构中变量叫局部变量
• 局部变量的作用域:只在声明它的大括号中有效.

10.循环结构

• 循环结构:重复性做某件事或执行某个操作.
• 死循环:如果重复性事件或操作一直执行叫死循环.java中避免死循环.

10.1.循环结构组成部分

• 循环初始值:循环起始值.
• 循环判断条件(布尔表达式):执行重复性操作需要满足的条件.
• 循环体:重复做的事或操作.
• 循环叠加条件:改变条件的值

10.3 while循环:

适用于有重复性操作,并且要先判断后执行,循环次数不固定首选while循环.

10.3.1:语法:

		循环初始值;
		while(循环判断条件){
			循环体;
			循环叠加条件;
		}

10.3.2:循环执行流程:

先执行循环初始值,再执行循环判断条件，如果循环判断条件为false就跳出循环结构,执行循环结构之后的语句;如果循环判断条件为true,就执行循环体和循环叠加条件; 再重复加粗字体部分.

10.3.3:执行特点:

• 1:在while循环结构中,先判断后执行.
• 2:在while循环结构中,循环初始值是一定会执行一次;循环判断条件至少执行一次,最多执行n次;循环体和循环叠加条件至少执行0次,最多执行n次.
• 3:在while循环结构中,循环初始值和循环条件不可以省略;循环操作可以省略,但没意义;循环叠加条件可以省略,只是省略之后变成了死循环.

		eg:public static void main(String[] args){
		//循环初始值
		int count=0;//记录跑的圈数
		int sum=0;//记录跑的长度
		
		//循环判断条件
		while(sum<10000){
			//循环操作
			System.out.println("跑了一圈400米");
			count++;
			
			//循环叠加条件
			sum=sum+400;
		}
		System.out.println("万米赛跑的圈数为:"+count);
	}

11.do-while循环:

有重复性的操作,且先无条件要执行一次,再判断再执行就用do-while.

11.1:语法:循环初始值;

			do{
				循环操作;
				循环叠加条件;
			}while(循环判断条件);

11.2:执行流程:

先执行循环初始值,再无条件执行循环体和循环叠加条件,**再执行循环判断条件,如果循环判断条件为false,就跳出循环结构,执行循环结构之后的语句; 如果循环判断条件为true,就要执行循环体和循环叠加条件;**再重复加粗字体部分.

11.3:结构特点:

• 1:do-while循环中,先无条件执行一次循环体和循环叠加条件,再判断再执行.
• 2:do-while循环中,循环初始值在第一次时执行且执行一次;
  循环体和循环叠加条件至少执行一次;循环判断条件至少执行一次.
• 3:do-while循环中,循环初始值和循环条件不可省略;
  循环体可以省略,只是没意义;
  循环叠加可以省略,只是省略后变成死循环.

	eg:public static void main(String[] args){
		//获得从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		//循环初始值
		char answer='n';
		do{
			System.out.println("考试进行中....");
			System.out.println("考试结束");
			
			//循环叠加条件
			System.out.println("此次考试是否合格(y表示是,其他表示否):");
			answer=input.next().charAt(0);
		}while(answer!='y');//循环判断条件
		
		System.out.println("恭喜你考试通过!");
	}

12.for循环:

适用于有重复性操作,并且要先判断后执行,循环次数固定首选for循环.

12.1:语法:

for(循环初始值1;循环判断条件2;循环叠加条件3){
	循环体;
}

12.2:执行流程:

先执行循环初始值1,再执行循环判断条件2,如果循环判断条件2为false,就跳出循环结构,执行循环结构之后的语句;如果循环判断条件2为true,就执行循环体,再执行循环叠加条件3;重复蓝色字体部分.

12.3:结构特点:

• 1:for循环先判断后执行.
• 2:for循环中,循环初始值1只在第一次执行且只执行一次;
  循环判断条件2至少执行一次;循环体和循环叠加条件3至少执行0次.
• 3:for循环中小括号中两个分号是一定不可以省略.
• 4:for循环中,循环初始值1可以是一个也可以是多个表达式,式子之间用,隔开;
  循环判断条件2只有一个boolean类型结果,至少是一个判断表达式 还多个用逻辑运算符连接都可以;循环叠加条件3可以是一个也可以 是多个表达式,式子之间用,隔开;
• 5:for循环中,循环初始值1可以省略,省略后可以在for前面声明;
  循环叠加条件3如果直接省略就变成死循环,想省略可以将循环叠加 条件3作为循环体的一部分;
  循环判断条件2在语法上可以省略,只是变成死循环.

		eg:public static void main(String[] args){
		//声明一个变量存总和
		int sum=0;
		for(int i=1;i<=100;i++){
			sum=sum+i;
		}
		System.out.println("1到100之和为:"+sum);
	}

			   public static void main(String[] args){
		//循环初始条件:int i=1,j=6
		//循环判断条件:i<=6&&j>=1
		//循环叠加条件:i++,j--
		for(int i=1,j=6;i<=6&&j>=1;i++,j--){
			System.out.println(i+"+"+j+"="+(i+j));
		}
	}

13.for VS do-while VS while的不同点

13.1:适用场景不同:

• for循环适用于先判断,后执行,循环次数固定的重复性问题.
• do-while循环适用于先无条件执行一次循环操作,再判断再执行的重复性问题.
• while循环适用于先判断,后执行,循环次数不固定的重复性问题.

13.2:能用do-while循环解决的问题都可以用for循环和while循环解决.

• 能用while循环解决的问题一定可以用for循环解决,但是不一定可以用do-while循环解决.
• 能用for循环解决的问题一定可以用while循环解决,但是不一定可以用do-while循环解决.

14.嵌套循环结构:

将一个循环结构作为另一个循环结构的循环体.
(在一个循环结构的大括号中,完整包含另一个循环结构).
注意: 外层循环一次,内层循环从头循环到尾.
循环结构之间可以任意嵌套,也可以多层嵌套,嵌套要正确
(一般情况下目前用两层嵌套).

	eg:public static void main(String[] args){
		//获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		
		for(int j=1;j<=3;j++){
			System.out.println("第输入第"+j+"个班的学员成绩:");
			//接收一个班四名学员成绩
			for(int i=1;i<=4;i++){
				System.out.println("第输入第"+i+"位学生的成绩:");
				double score=input.nextDouble();
			}
			//接收完一个班成绩
			System.out.println();
		}
	}

15.break

跳出switch结构,跳出循环结构.

15.1:break第一种用法:

跳出当层循环结构;

		eg:public static void main(String[] args){
		//获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		
		//接收一个班四名学员成绩
		for(int i=1;i<=4;i++){
			System.out.println("第输入第"+i+"位学生的成绩:");
			double score=input.nextDouble();
			if(score<0){
				System.out.println("你的输入有误,停止录入");
				break;
			}
		}
	}

15.2:break第二种用法:作标记

声明标记语法:标记名:循环结果
跳出标记结构语法:break 标记名

	eg:public static void main(String[] args){
		//获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		
		//用a给外层循环作标记
		a:for(int j=1;j<=3;j++){
			System.out.println("第输入第"+j+"个班的学员成绩:");
			//接收一个班四名学员成绩
			for(int i=1;i<=4;i++){
				System.out.println("第输入第"+i+"位学生的成绩:");
				double score=input.nextDouble();
				if(score<0){
					System.out.println("你的输入有误,停止录入");
					break a;//跳出指定标记循环结构
				}
			}
			//接收完一个班成绩
			System.out.println();
		}
	}

16.continue

结束当前循环结构当次循环,进入下一次循环.

	eg:public static void main(String[] args){
		//获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		
		//接收一个班四名学员成绩
		for(int i=1;i<=4;i++){
			System.out.println("第输入第"+i+"位学生的成绩:");
			double score=input.nextDouble();
			/*if(score<0){
				continue;
			}*/
			
			if(score>=0){
				System.out.println("录入成功");
			}
		}
	}

个人笔记，思路，仅供参考