Java程序控制结构学习笔记

程序控制结构

-程序流程控制介绍

​ 在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

1. 顺序控制
2. 分支控制
3. 循环控制

-顺序控制

• 顺序控制介绍

  程序从上到下逐行地执行，中间没有任何判断和跳转。

-分支控制if-else

• 分支控制if-else介绍

  让程序有选择的执行，分支控制有三种

  1. 单分支
  2. 双分支
  3. 多分支

• 单分支

  • 基本语法

  if(condition){
  	...
  }
  

  • 说明:当条件表达式为ture 时，就会执行{}的代码。如果为false,就不执行。

  • 特别说明，如果 {}中只有一条语句，则可以不用 4,建议写上 (}。

  • 案例：编写一个程序，可以输入人的年龄，如果大于18岁，则输出“你的年龄大于18，要对自己的行为负责，送入监狱”

    import java.util.Scanner;
    public class If01{
    	public static void main(String[] args){
    		Scanner input=new Scanner(System.in);
    		System.out.print("请输入你的年龄：");
    		int age=input.nextInt();
    		if(age>18){
    			System.out.print("你的年龄大于18，要对自己的行为负责，送入监狱。");
    		}
    	}
    }
    

• 双分支

  • 基本语法

    if(condition){
        ...
    }else{
        ...
    }
    

  • 说明:当条件表达式成立，即执行代码块1，否则执行代码块2。如果执行代码块只有一条语句，则 {} 可以省略，否则不能省略

  • 案例：编写一个程序，可以输入人的年龄，如果大于18岁，则输出“你的年龄大于18，要对自己的行为负责，送入监狱”;否则输出“你的年龄不大这次放过你了”。

    import java.util.Scanner;
    public class If02{
    	public static void main(String[] args){
    		Scanner input=new Scanner(System.in);
    		System.out.print("请输入你的年龄：");
    		int age=input.nextInt();
    		if(age>18){
    			System.out.print("你的年龄大于18，要对自己的行为负责，送入监狱。");
    		}else{
    				System.out.print("你的年龄小于18这次就放过你了");
    		}
    	}
    }
    

  • 练习：判断一个年份是否为闰年

    import java.util.Scanner;
    public class IfExercise01{
    	public static void main(String[] args){
    		Scanner input=new Scanner(System.in);
    		System.out.print("请输入年份：");
    		int year=input.nextInt();
    		if(year%4==0&&year%100!=0||year%400==0){
    			System.out.print(year+"是闰年");
    		}else{
    			System.out.print(year+"不是闰年");
    		}
    	}
    }
    

• 多分支

  • 基本语法

  if(condition1){
      ...
  }else if(condition2){
      ...
  }......
  else{
      ...
  }
  

  • 特别说明

    1. 多分支可以没有else如果所有条件表达式都不成立则一个执行入口都没有
    2. 如果有else，如果所有条件表达式都不成立，则执行else代码块

  • 练习：对输入的分数进行评级，A：90-100分，B：80-89分，C：70-79分，D：60-69分，F：0-59分

    import java.util.Scanner;
    public class IfExercise02{
    	public static void main(String[] args){
    		Scanner input=new Scanner(System.in);
    		System.out.print("请输入分数");
    		int score=input.nextInt();
    		if(score>=90&&score<=100){
    			System.out.print("A");
    		}else if(score>=80&&score<90){
    			System.out.print("B");
    		}else if(score>=70&&score<80){
    			System.out.print("C");
    		}else if(score>=60&&score<70){
    			System.out.print("D");
    		}else if(score>=0&&score<60){
    			System.out.print("F");
    		}else{
    			System.out.print("请认真输入分数，分数应在0-100之间");
    		}
    	}
    }
    

• 嵌套分支

  • 基本介绍：

    在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支称为内层分支，外面的分支结构称为外层分支。规范:不要超过3层(可读性不好)

  • 基本语法

    if(){
        if(){
            //if-else
        }else{
            //if-else
        }
    }
    

  • 应用案例

    参加歌手比赛，如果初赛成绩大于8.0进入决赛否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息。

    import java.util.Scanner;
    public class NestedIf{
    	public static void main(String[] args){
    		Scanner input=new Scanner(System.in);
    		System.out.print("请输入分数：");
    		double score=input.nextDouble();
    		System.out.print("请输入性别：");
    		char gender=input.next().charAt(0);
    		if(score>8.0){
    			if(gender=='男'){
    				System.out.println("晋级进入男子组");
    			}else if(gender=='女'){
    				System.out.println("晋级进入女子组");
    			}else{
    				System.out.println("系统不支持此性别");
    			}
    		}else{
    			System.out.println("淘汰");
    		}
    	}
    }
    

-switch分支结构

• 基本语法

  switch(表达式){
  	case 常量1：
          语句块1；
          break；
      case 常量2：
          语句块2；
          break；
          ......
      case 常量n：
          语句块n；
          break；
      default:
          default语句块；
          break;
  }
  

• switch解读

  1. switch 关键字，表示swtich分支
  2. 表达式 对应一个值
  3. case 常量1 :当表达式的值等于常量1，就执行 语句块1
  4. break: 表示退出swtich
  5. 如果和 case 常量1 匹配，就执行语句块1，如果没有匹配，就继续匹配 case 常量2
  6. 如果一个都没有匹配上，执行default

• 入门案例

  用户输入a,b,c,d,e,f,g中的一个字母，输出对应的星期日期

  import java.util.Scanner;
  public class Switch01{
  	public static void main(String[] args){
  		Scanner input=new Scanner(System.in);
  		System.out.print("请输入一个英文字母（a-g）：");
  		char c=input.next().charAt(0);
  		switch(c){
  			case 'a':
  				System.out.println("星期一"); 
  				break;
  			case 'b':
  				System.out.println("星期二"); 
  				break;
  			case 'c':
  				System.out.println("星期三"); 
  				break;
  			case 'd':
  				System.out.println("星期四"); 
  				break;
  			case 'e':
  				System.out.println("星期五"); 
  				break;
  			case 'f':
  				System.out.println("星期六"); 
  				break;
  			case 'g':
  				System.out.println("星期天"); 
  				break;
  			default:
  				System.out.println("没有输入规定范围的字母哦~"); 
  				break;
  		}
  
  		System.out.println("程序运行完毕"); 
  	}
  }
  

• switch细节讨论

  1. 表达式数据类型，应和case 后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
  2. switch(表达式)中表达式的返回值必须是：(byte,short,int,char,enum,String)
  3. case子句中的值必须是常量,而不能是变量
  4. default子句是可选的，当没有匹配的case时，执行default
  5. break语句用来在执行完一个case分支后使程序跳出switch语句块:如果没有写break，程序会顺序执行到switch结尾

• switch和if比较

  1. 如果判断的具体数值不多，而且符合byte、short、int、char, enum,String这6种类型。虽然两个语句都可以使用，建议使用swtich语句。
  2. 其他情况:对区间判断，对结果为boolean类型判断，使用if，if的使用范围更)

-for循环控制

• 基本介绍：可以让代码循环的执行

• 基本语法

  for(循环变量初始化;循环条件;循环变量迭代){
  	循环操作...
  }
  

• 一些说明

  1. for 关键字，表示循环控制
  2. for有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量选代
  3. 循环操作，这里可以有多条语句，也就是我们要循环执行的代码
  4. 如果 循环操作(语句)只有一条语句，可以省略 {},建议不要省略

• 注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. for(;循环判断条件;)中的初始化和变量选代可以写到其它地方，但是两边的分号不能省略。
  3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开循环变量选代也可以有多条变量选代语句，中间用逗号隔开。
  4. 使用内存分析法，老师分析输出下面代码输出什么?

• 练习

  1. 输出1-100之间9的倍数

     //输出1-100间所有9的倍数
     public class For01{
     	public static void main(String[] args){
     		for(int i=9;i<100;i+=9){
     			System.out.println(i);
     		}
     	}
     }
     

  2. 输出两数相加为10的所有加法等式

     //输出两正整数相加为10的所有等式
     public class For02{
     	public static void main(String[] args){
     		for(int i=9,j=1;i>0;i--,j++){
     			System.out.println(i+" + "+j+" = "+(i+j));
     		}
     	}
     }
     

-while

• 基本语法

  while(循环条件){
  	循环操作...
      循环变量迭代;
  }
  

• 一些说明

  1. while循环也有四要素
  2. 只是四要素的位置不一样

• 注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. while循环是先判断再执行语句

• 练习

  1. 打印40-200间所有能被3整除的数

     //打印40-200间所有能被3整除的数
     public class While01{
     	public static void main(String[] args){
     		int i=42;
     		while(i<=200){
     			System.out.println(i);
     			i+=3;
     		}
     	}
     }
     

-do…while

• 基本语法

  do{
      循环体;
      循环变量迭代;
  }while(循环条件);
  

• 说明

  1. do while 是关键字
  2. 也有循环四要素,只是位置不一样
  3. 先执行，再判断，也就是说，一定会执行一次
  4. 最后有一个分号;

• 注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. do…while循环是先执行再判断，因此至少执行一次

• 练习题：如果张三不还钱，则老王将一直使出五连鞭，直到张三说还钱为止

  //如果张三不还钱，则老王将一直使出五连鞭，直到张三说还钱为止
  import java.util.*;
  public class DoWhileExercise{
  	public static void main(String[] args){
  		//初始化Scanner与回答标记
  		Scanner scanner=new Scanner(System.in);
  		char ans;
  		do{
  			System.out.println("老王问：还钱吗？y/n");
  			ans=scanner.next().charAt(0);
  			//如果不还钱则五连鞭，如果说错话则打一巴掌
  			if(ans=='n'){
  				System.out.println("老王对张三使出五连鞭~~~");
  			}else if(ans!='y'){
  				System.out.println("老王对张三打一巴掌");
  			}
  		}while(ans!='y');
  
  		System.out.println("说好的不能耍赖哦~");
  	}
  }
  

-多重循环控制

• 介绍

  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for,while,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层,否则，代码的可读性很差】
  2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
  3. 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

• 练习1：打印出九九乘法表

  public class TimesTable{
  	public static void main(String[] args){
  		//每一行
  		for(int i=1;i<10;i++){
  			//一行的每一项
  			for(int j=1;j<i+1;j++){
  				System.out.print(j+" * "+i+" = "+j*i+"\t");
  			}
  			System.out.println("");
  		}
  	}
  }
  

• 练习2：打印空心的随意调节宽度的空心菱形

  //用户输入菱形的宽度，根据宽度生成空心菱形（效率仍可优化）
  import java.util.*;
  public class Diamond{
  	public static void main(String[] args){
  		Scanner scanner=new Scanner(System.in);
  		System.out.println("请输入菱形的宽度~");
  		int width=scanner.nextInt();
  
  		//先生成矩形
  		for(int i=0;i<width;i++){
  			//记录本行单侧外部空格数量
  			int outsideSpaceNum=Math.abs(width/2-i);
  			//记录本行星号跨度
  			int starNum=width-2*outsideSpaceNum;
  			//输出左侧的空格
  			for(int j=0;j<outsideSpaceNum;j++){
  				System.out.print(" ");
  			}
  			//边缘星号与内部空格
  			for(int j=0;j<starNum;j++){
  				//如果这个位置是边缘星号，则输出星号，否则输出空格
  				if(j==0||j==starNum-1){
  					System.out.print("*");
  				}else{
  					System.out.print(" ");
  				}
  				
  			}
  			//右侧的空格
  			for(int j=0;j<outsideSpaceNum;j++){
  				System.out.print(" ");
  			}
  			System.out.println("");
  		}
  	}
  }
  

-跳转控制语句break

• 基本介绍

  break语句用于终止某个语句块的执行，一般使用在switch或者循环ifor，while，do-while]中

• 基本语法

  {
      ......
      break;
      ......
  }
  

• 注意事项和细节说明

  1. break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪层语句块

  2. 标签的基本使用：

     label1:{
     	label2:{
     		label3:{
     			......
     			break label2;
     			......
     		}
     	}	
     }
     

     1. break 语句可以指定退出哪层
     2. label1 是标签，由程序员指定
     3. break后指定到哪个label 就退出到哪里
     4. 在实际的开发中，尽量不要使用标签.
     5. 如果没有指定 break,默认退出最近的循环体

• 练习：

  实现登录验证，有3次机会，如果用户名为“丁真”，密码“666”提示登录成功，否则提示还有几次机会，请使用for+break完成

  //实现登录验证，有3次机会，如果用户名为“丁真”，密码“666”提示登录成功，否则提示还有几次机会，请使用for+break完成
  import java.util.*;
  public class BreakExercise{
  	static Scanner scanner=new Scanner(System.in);
  	public static void main(String[] args){
  		String userName="";
  		String password="";
  		//三次验证机会
  		for(int i=2;i>=0;i--){
  			//接收用户名和密码
  			System.out.print("请输入用户名：");
  			userName=scanner.next();
  			System.out.print("请输入密码：");
  			password=scanner.next();
  			//如果用户名密码正确就提示成功，否则提示还有几次机会
  			if(userName.equals("丁真")&&password.equals("666")){
  				System.out.println("登陆成功！");
  				break;
  			}else{
  				System.out.println("还有"+i+"次登陆机会~");
  			}
  		}
  	}
  }
  

-跳转控制语句continue

• 基本介绍:

  1. continue语句用于结束本次循环，继续执行下一次循环。
  2. continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样.

• 基本语法:

  {
  	......
  	continue;
  	......
  }
  

-本章练习

1. 编程实现如下功能
   某人有100,000元,每经过一次路口，需要交费,规则如下:

   1)当现金>50000时,每次交5%

   2)当现金<=50000时,每次交1000

   编程计算该人可以经过多少次路口,要求: 使用 while break方式完成

   /*
   编程实现如下功能
   某人有100,000元,每经过一次路口，需要交费,规则如下:
   1)当现金>50000时,每次交5%
   2)当现金<=50000时,每次交1000
   编程计算该人可以经过多少次路口,要求: 使用 while break方式完成
   */
   public class Exercise01{
   	public static void main(String[] args){
   		double cash=100000;
   		int passTimes=0;
   		while(true){
   			if(cash>50000){//当资金大于50000时，缴费5%
   				cash*=0.95;
   				passTimes++;
   				System.out.println("经过路口"+passTimes+"次，剩余资金为"+cash);
   			}else if(cash>=1000){//当资金小于50000并且大于1000时，缴费10000	
   				cash-=1000;
   				passTimes++;
   				System.out.println("经过路口"+passTimes+"次，剩余资金为"+cash);
   			}else{
   				System.out.println("资金不足1000，总通过次数为"+passTimes+"次");
   				break;
   			}
   		}
   	}
   }
   

2. 判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如:153=111+333+555

   /*
   判断一个整数是否是水仙花数
   */
   import java.util.*;
   public class Exercise02{
   	//初始化Scanner
   	static Scanner scanner=new Scanner(System.in);
   	public static void main(String[] args){
   		//一直循环，若输入超范围的数字就推出
   		while(true){
   			//获取用户输入
   			System.out.println("请输入一个三位数字(输入其他数字退出)：");
   			int num=scanner.nextInt();
   			//如果输入不是三位正整数就退出循环
   			if(num<100||num>999){
   				System.out.println("退出程序ing");
   				return;
   			}
   			//否则进行判断是否是水仙花数
   			int a=num/100;
   			int b=num%100/10;
   			int c=num%10;
   			if(num==a*a*a+b*b*b+c*c*c){
   				System.out.println(num+"是水仙花数~");
   			}else{
   				System.out.println(num+"不是水仙花数~");
   			}
   		}
   	}
   }
   

3. 输出1-100之间的不能被5整除的数，每5个一行

   //输出1-100之间的不能被5整除的数，每5个一行
   public class Exercise03{
   	public static void main(String[] args){
   		//记录输出了几个数
   		int pos=0;
   		//对1到100循环
   		for(int i=1;i<=100;i++){
   			//如果不能被5整除就输出
   			if(i%5!=0){
   				System.out.print(i+"\t");
   				pos++;
   				//如果输出数字个数是5的倍数，就换行
   				if(pos%5==0){
   					System.out.println("");
   				}
   			}
   		}
   	}
   }
   

4. 输出小写的a-z以及大写的Z-A

   //输出小写的a-z以及大写的Z-A
   public class Exercise04{
   	public static void main(String[] args){
   		//记录字符的变量
   		char c='a';
   		//输出a-z
   		while(c<='z'){
   			System.out.print(c+"\t");
   			c=(char)(c+1);
   		}
   		//输出Z-A
   		c='Z';
   		while(c>='A'){
   			System.out.print(c+"\t");
   			c=(char)(c-1);
   		}
   	}
   }
   

5. 求出1-1/2+1/3-1/4…1/100的和，求1+(1+2)+(1+2+3)+(1+2+3+4)+.+(1+2+3+…+100)的结果

   //求出1-1/2+1/3-1/4..1/100的和，求1+(1+2)+(1+2+3)+(1+2+3+4)+.+(1+2+3+..+100)的结果
   public class Exercise05{
   	public static void main(String[] args){
   		//求出1-1/2+1/3-1/4..1/100的和
   		double sum1=0;
   		for(int i=1;i<=100;i++){
   			//如果i是奇数则相加，是偶数则相减
   			if(i%2==1){
   				sum1+=1.0/i;
   			}else{
   				sum1-=1.0/i;
   			}
   		}
   		System.out.println("sum1="+sum1);
   
   		//求1+(1+2)+(1+2+3)+(1+2+3+4)+.+(1+2+3+..+100)的结果
   		int sum2=0;
   		for(int i=1;i<=100;i++){
   			for(int j=1;j<=i;j++){
   				sum2+=j;
   			}
   		}
   		System.out.println("sum2="+sum2);
   	}
   }