Java Sum（运算符&流程控制语句）

左手的ㄟ右手 2022-12-15 14:03 269阅读 0赞

## Java Sum（运算符&流程控制语句） ##

### 一、运算符 ###

#### 1.1概念解析 ####

1、运算
    对常量和变量进行操作的过程称为运算。
    2、运算符
    对常量和变量进行操作的符号称为运算符
    3、操作数
    参与运算的数据称为操作数
    4、用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。
    举例：
    int a = 3 + 4;
    这是做了一个加法运算
    +就是运算符，是算术运算符，我们还有其他很多的运算符
    3，4就是参与运算的操作数据
    3 + 4整体其实就是一个算数表达式

#### 1.2算数运算符 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center]

#### 1.3赋值运算符 ####

符号
    = , +=, -=, *=, /=, %=
    =为基本的赋值运算符，其他的为扩展的赋值运算符。

技巧题（强制转换）

以下代码哪一句会编译失败,如何解决?
    		short s = 1 ;
    		1)s = s +1 ;
    		2)s += 1  ;
    		  s += 1 ;//等价于 s = (short)(s+1) ; 
      结论:扩展的赋值运算符:  += ,*=,-= ,/= ,%= 隐藏了强制类型转换!
    
    class OperatorTest{
    	public static void main(String[] args){
    		//定义变量
    		short s = 1 ;
    		//s = s + 1 ; //不兼容的类型: 从int转换到short可能会有损失
    		//byte,short,char:三者之间不转换,但是参与运算,先提升int类型(隐式转换)
    		//解决:强制类型转换
    		//s = (short)(s+1) ;  //显示转换 (强制类型转换)
    		
    		s += 1 ;//等价于 s = (short)(s+1) ; 
            System.out.println("s:"+s) ;		
    	}
    }

#### 1.4关系运算符 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center 1]

public class CompareEax {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
          int x = 20;
          int y = 15;
          int z = 30;
          System.out.println(x>y);
          System.out.println(x>=y);
          System.out.println(x<y);
          System.out.println(x<=y);
          System.out.println(x==y);
    	}
    
    }
    结果：
    true
    true
    false
    false
    false

#### 1.5逻辑运算符 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center 2]

int a = 5;
    	  int b = 4;
    	  int c = 7;
    	  System.out.println((a>b) & (b<c));
    	  System.out.println((a>b) |(b<c));
    	  System.out.println((a>b) ^ (b<c));
    	  System.out.println(! (b<c));
    	  System.out.println((a>b) && (b<c));
    	  System.out.println((a>b) ||(b<c));
    	  
    结果：
    true
    true
    false
    false
    true
    true

**小结**

逻辑单与&:有false,则false  
逻辑单或|:有true,则true  
逻辑异或^:相同则为false,不同则为true  
逻辑非!:非true,false;非false,则true。偶数个非是它本身!

##### 逻辑单与&和逻辑双与&&的区别? #####

逻辑单与和逻辑双与:  
都表示并列关系,有false,则false。

逻辑双与&&连接的表达式:左边为false,右边就不执行了(具有短路效果)

class OperatorDemo2{
    	public static void main(String[] args){
    		
    		//定义三个变量
    		int a = 3 ;
    		int b = 4 ;
    		int c = 5 ;
    		
    		//逻辑双与 &&
    		System.out.println((a>b) && (a>c)) ;//false & false = false
    		System.out.println((a<b) && (a>c)) ;//true & false = false
    		System.out.println((a>b) && (a<c)) ;//false & true = false 
    		System.out.println((a<b) && (a<c)) ;//true  & true = true
    		
    		System.out.println("-----------------------------") ;
    		
    		//定义两个变量x,y
    		int x = 3 ;
    		int y = 4 ;
    		System.out.println("x:"+x) ;
    		System.out.println("y:"+y) ;
    		System.out.println("-----------------------------") ;
    							//true     &&    false
    		//System.out.println(((++x) ==4) && ((--y) == 4) ) ; //false
    							//false    &&  true
    		
    		//逻辑双与&&的短路效果
    		System.out.println(((x++) == 4)   && ((y--) == 4)) ;
    		System.out.println("x:"+x) ;//4
    		System.out.println("y:"+y) ;//还是4:没有变化
    		
    		
    	}
    }

#### 1.6位运算符 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center 3]

##### **实现两个变量的结果进行交换?** #####

int a = 10 ;
    			int b = 20 ;
    
    
    class OperatorTest2{
    	public static void main(String[] args){
    		
    		//有两个已知变量
    		int a = 10 ;
    		int b = 20 ;
    		System.out.println("交换前:") ;
    		System.out.println("a:"+a) ;
    		System.out.println("b:"+b) ;
    		
    		System.out.println("----------------------") ; 
    		
    		
    		//方式1:开发中:采用中间变量的方式
    		/*
    			int temp  = a ;  //10
    			a = b ;//a = 20 
    			b = temp ;//b =temp = 10 ;
    		*/
    		
    		//方式2:位异或运算符的特点:一个数据被另一个数据位异或两次,其值是它本身
    		a = a ^ b ; 
    		b = a ^ b ;//b = a^ b ^ b = a
    		a = a ^ b ;//a = a ^ b ^ a = b
    		System.out.println("交换后:") ;
    		System.out.println("a:"+a) ;
    		System.out.println("b:"+b) ;
    	}
    }

#### 1.7三目（三元）运算符 ####

格式
    (关系表达式)?表达式1：表达式2；
    如果条件为true，运算后的结果是表达式1；
    如果条件为false，运算后的结果是表达式2；
    示例
    获取两个数中大数。
    int x=3,y=4,z;
    z = (x>y)?x:y;//z变量存储的就是两个数的大数。

/*	
    
    	需求:
    				1)求两个数据的最大值
    				2)求三个数据的最大值
    				3)求两个数据是否相等
    */
    class OperatorTest{
    	public static void main(String[] args){
    		
    		//两个变量
    		int x  = 3 ;
    		int y = 5 ;
    		
    		//接收结果
    		int result = (x > y )? x : y ;
    		System.out.println("这两个数据中的最大值是:"+result) ;
    		System.out.println("-------------------------------") ;
    		
    		//求三个数据的最大值
    		int a = 10 ;
    		int b = 30 ;
    		int c = 5 ;
    		
    		//使用中间变量的方式(推荐)
    		//分步执行:
    		//定义变量temp
    		int temp = (a > b) ? a: b ;
    		//在使用temp变量和c进行比较
    		int max = (temp > c) ? temp : c ;
    		System.out.println("这三个数据中的最大值是:"+max) ;
    		System.out.println("-------------------------------") ;
    		
    		//方式2:一步执行
    		//直接三元运算符
    		int max2 = (a > b) ? ((a>c)? a: c) : ((b>c)? b: c) ;
    		System.out.println("这三个数据中的最大值是:"+max2) ;
    		
    		System.out.println("-------------------------------") ;
    		//比较两个数据是否相等
    		
    		int m = 10 ;
    		int n = 20 ;
    		//boolean  flag = (m==n)? true: false ;
    		boolean flag = m==n ;
    		System.out.println("flag:"+flag) ;
    	}
    }

#### 扩展： ####

键盘录入里面的细节
    	
    	1)同时录入两个int
    	2)同时录入两个字符串String    nextLine()
    	3)先录入字符串,在录入一个int
    	以上三个都没有问题.
    	4)先录入int,在录入一个String
    	 
    	存在问题:
    		先录入int类型的数据,在录入String---->字符串数据没有录入,直接漏掉了,
    		回车符号
    		每次录入数据----->敲"回车符号"  10,回车符号本身---->字符串值

### 二、流程控制语句 ###

#### 2.1概述 ####

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对
    运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语
    句的执行顺序来实现我们要完成的功能。
    流程控制语句的分类
    顺序结构语句
    选择结构语句
    循环结构语句

#### 2.2选择结构语句-if ####

if语句的格式:  
**第一种格式**\*\*

if(表达式){
    			语句;
    	}

执行流程:  
判断表达式是否成立,如果是true,成立,执行语句;  
如果不成立,不执行!

if语句的格式:  
**第一种格式**

if(表达式){
    			语句;
    	}

执行流程:  
判断表达式是否成立,如果是true,成立,执行语句;  
如果不成立,不执行!

//导包
    import java.util.Scanner ;
    class IfDemo{
    	public static void main(String[] args){
    		
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并接收
    		System.out.println("请你输入一个数据:");
    		int a = sc.nextInt() ;
    		
    		//if格式1
    		if(a >= 10){
    			System.out.println("a的值大于等于10") ;
    		}
    		
    		System.out.println("over") ;
    		
    	}
    }

**if格式2:**

if(表达式){
    	语句1;
    }else{
    	语句2;
    }

执行流程:  
1)首先判断表达式是否成立,如果是true,执行语句1  
2)如果不成立,执行语句2;

//导包
    import java.util.Scanner;
    class IfDemo3{
    	public static void main(String[] args){
    		
    		//定义一个变量
    		int x = 10 ;
    		if(x >=10){
    			System.out.println("x大于等于10") ;
    		}else{
    			System.out.println("x小于10") ;
    		}
    		
    		System.out.println("over...") ;
    		System.out.println("---------------------------") ;
    		
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		//提示并接收
    		System.out.println("请输入一个数据:") ;
    		int num = sc.nextInt() ;
    		
    		if(num %2 == 0){ //%:求余: 能够被2整数,余数为0
    			System.out.println(num+"是偶数!") ; 
    		}else{
    				System.out.println(num+"是奇数!") ; 
    		}
    	}
    }

**if语句的第三种结构:**

if(表达式1){
    		语句1;
    	}else if(表达式2){
    		语句2;
    	...
    	...
    	...
    	}else{
    		语句n+1 ;
    	}

执行流程:  
1)首先判断表达式1是否成立,如果成立,执行语句1,if语句结束!  
2)如果表达式1不成立,再次判断表达式2是否成立,如果成立,执行语句2,语句结束!  
3)如果上述表达式都不成立,就执行else中的语句,if语句结束!

举例:

键盘录入学生的成绩,判断学生的成绩等级
    		90~100    突出
    		80~90之间 优秀
    		70~80之间  良好
    		60~70     及格
    		60以下    不及格

//导包  
import java.util.Scanner ;  
class IfDemo4\{  
public static void main(String\[\] args)\{  
//创建键盘录入对象  
Scanner sc = new Scanner(System.in) ;

//提示,并接收数据
    	System.out.println("请您录入学生的成绩: ") ;
    	int score = sc.nextInt() ;
    	if(score >100 || score < 0){
    		System.out.println("您录入的是一个非法数据...") ;
    	}else if(score >= 90 && score <=100){
    		System.out.println("该学生成绩十分突出...") ;
    	}else if(score >=80 && score< 90){
    		System.out.println("该学生成绩优秀...") ;
    	}else if(score >= 70 && score <80){
    		System.out.println("该学生成绩良好...") ;
    	}else if(score >= 60 && score <70){
    		System.out.println("该学生成绩及格...") ;
    	}else{
    		System.out.println("该学生成绩不及格...") ;
    	}
    	}
    }

//键盘录入两个数据,求最大值!if...else方式
    //导包
    import java.util.Scanner;
    class IfTest{
    	public static void main(String[] args){
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并接收数据
    		System.out.println("请输入第一个数据:") ;
    		int firstNumber = sc.nextInt() ;
    		
    		System.out.println("请输入第二个数据:") ;
    		int secondNumber = sc.nextInt() ;
    		
    		
    		//if语句实现
    		//定义变量
    		int max ;
    		if(firstNumber > secondNumber){
    			max = firstNumber ;
    		}else{
    			max = secondNumber;
    		}
    		
    		System.out.println("两个数据的最大值是:"+max) ;
    		System.out.println("---------------------------") ;
    		//三元
    		int max2 = (firstNumber > secondNumber) ? firstNumber : secondNumber ;
    		System.out.println("两个数据的最大值是:"+max2) ;
    	}
    }

**if语句格式2它和三元运算符的区别?**

if语句格式2范围更大一些:推荐使用if语句格式2
    	if语句格式2:既可以操作具体的数据值/也可以操作输出语句	
    	三元运算符:仅仅是作为一个运算符,一般都是操作具体的数据值!
    	int a = 10 ;
    	int b  =20 ;
    	(a>b) ? a:  b ;
    	如果能够使用三元运算符的就一定能够使用if...else...
    	但是如果能够使用if...else...,不一定能够使用三元运算符!

##### 2.1 if语句格式嵌套 #####

格式：

if(表达式){
        if(表达式1){
            语句1...
            
        }else{
            语句2...
            
        }
        
    }else{
        if(表达式2){
            
           语句3 ...
        }else{
            
            语句4 ....
        }
        
    }

执行流程：

首先判断外层if中表达式是否成立,
    	如果成立,执行表达式1是否成立
    			如果表达式1成立,执行语句1;否则,执行语句2;
    	外层if中表达式不成立,就执行else中的语句
    	
    			首先判断表达式2是否成立,如果成立,执行语句3,
    			否则执行语句4;

**例题1** 需求:键盘录入三个数据:求三个数据最大值

//导包
    import java.util.Scanner ;
    class IfTest{
    
    	public static void main(String[] args){
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示,并接收数据
    		System.out.println("请输入第一个数据:");
    		int a = sc.nextInt() ;
    		
    		System.out.println("请输入第一个数据:");
    		int b = sc.nextInt() ;
    		
    		System.out.println("请输入第一个数据:");
    		int c = sc.nextInt() ;
    		
    		//操作判断
    		//方式1:中间变量的方式+三元运算符
    		int temp = (a>b) ? a: b ;
    		//使用max变量接收
    		int max = (temp > c ) ? temp : c ;
    		System.out.println("三个数据中的最大值是:"+max) ;
    		System.out.println("---------------------------");
    		
    		//方式2:三元运算符一步走:
    		int max2 = (a>b) ? ((a > c) ? a: c) :((b > c) ? b : c) ;
    		System.out.println("三个数据中的最大值是:"+max2) ;
    		System.out.println("---------------------------");
    		
    		//方式3:使用if语句格式嵌套
    		
    		//定义一个变量max3
    		int max3 ;
    		if( a > b){
    			//a>b成立
    			if(a > c){
    					//a比c大
    				max3 = a ;	
    			}else{
    				//c比a大
    				max3 = c ;
    			}
    		}else{
    			//不成立
    			if(b > c){
    				//b比c大
    				max3 = b ;
    			}else{
    				//c比b大
    				max3 = c ;
    			}
    		}
    		System.out.println("三个数据中的最大值是:"+max3) ;
    	}

**例题 2** 数学分段函数的实现

/*
    	数学表达式:
    	   x >=3   y=2x+1
    	   -1=<x<3  y=2x
    	   x<-1   y=2x-1
    	   
    键盘录入x的值,求y的值
    */
    //导包
    import java.util.Scanner;
    class IfDemo
    {
    	public static void main(String [] args)
    	{
    		//键盘录入数据
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请你输入一个 X 值");
    		
    		int x = sc.nextInt();
    		 //if语句中加一个内if（）{}else语句进行表达数学公式可以正常运算
    		int y;
    		 if(x >= 3){
    			 y = 2*x + 1;
    			 if (x < 3 & x > 0)
    			 {
    				 y = 2*x;
    			 }else{
    				 y = 2*x - 1;
    			 }
    			 System.out.println(y);
    		 }
    		
    	}
    
    }

**例题 3** 键盘录入月份的值,判断季节

/*
    	键盘录入月份的值,判断季节
    			
    		3,4,5   春季
    		6,7,8   夏季
    		9,10,11 秋季
    		12,1,2  冬季
    	       
    */
    //导包
    import java.util.Scanner;
    class IfTest3{
    	public static void main(String[] args){
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并接收数据
    		System.out.println("请输入一个月份的值: ") ;
    		int month = sc.nextInt() ;
    		
    		if(month > 12 || month < 1){
    			System.out.println("非法数据!") ;
    		}else if(month >=3 && month <= 5){
    			System.out.println("该月份是春季") ;
    		}else if(month >= 6 && month <= 8){
    			System.out.println("该月份是夏季") ;
    		}else if(month >= 9 && month <= 11){
    			System.out.println("该月份是秋季") ;
    		}else{
    			System.out.println("该月份是冬季") ;
    		}
    	}
    }

#### 2.3选择结构语句-switch ####

switch语句的格式：

switch(表达式){
    	
    	
    		case 值1:
    				语句1;
    				break ;
    		case 值2:
    				语句2;
    				break ;
    				
    		...
    		...
    		default:
    				语句n;
    				break ;
    		
    	
    	}
    	
    执行流程:
    		1)先判断表达式的值它和case语句值1,是否匹配
    			如果匹配,执行语句1,遇见break ,switch语句结束了!
    		2)如果值1不匹配,继续判断值2是否和表达式中的值是否匹配,如果匹配,执行语句2
    			遇见break,switch语句结束!
    		3)如果上面的所有case语句都不匹配,执行default语句,执行语句n,直接结束

**Import：**

switch表达式可以是byte类型吗?
    		可以是String类型吗?
    		可以是char类型吗?
    		可以是枚举类型吗?
    		
    		switch(表达式)---->本身可以使用的类型:byte,short,char,int类型
    		JDK5以后可以枚举enum(引用类型--->定义常量)  后面讲(Java高级部分多线程Thread类: State(枚举类型))
    		JDK7以后:可以使用String类型

**例题 1** 键盘录入一个数据,判断星期

import java.util.Scanner;
    class SwitchExp
    {
    	public static void main(String [] args)
    	{
    		//键盘录入数据
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请你输入一个数据");
    		int monthDate = sc.nextInt();
    		//利用case穿透规定1-3月去哪里
    		
    		switch(monthDate)
    		{
    			case 1:
    			case 2:
    			case 3:
    			   System.out.println("去吴中");    
    		         break;
    			case 4:
    			case 5:
    			case 6:
    			   System.out.println("去银川"); 
                     break;			   
                case 7:
    			case 8:
    			case 9:
    			   System.out.println("去灵武"); 			   
    		        break;
    			case 10:
    			case 11:
    			case 12:
    			    System.out.println("曹操家"); 			   
    		          break;
    			default:
    			   System.out.println("非法数据！！");
    		break;   
            }  
    		System.out.println("请你输入一个数据");
    		int weekDate = sc.nextInt();
    		switch(weekDate)
    		{
    			case 1:
    			 System.out.println("星期1");      ;
    		    break;
    			case 2:
    			  System.out.println("星期2");     ;
    		    break;
    			case 3:
    			   System.out.println("星期3");    ;
    		    break;
    			case 4:
    			   System.out.println("星期4");    ;
    		    break;
    			default:
    			   System.out.println("非法数据！！");
    			  break;      
    		
            		
    		}
        }
    }

switch语句使用的注意事项:
    	
    	1)switch语句中的case语句后面跟的常量值,不能跟变量!  
    			对比:javascript:switch语句 中的case可以是常量也可以变量
    			
    	2)case语句中的break不能轻易省略,否则就会造成"case穿透"
    			如果没有写break,跟下面case值不进行比较,直接运行语句,直到遇见break结束!
    			
    	3)switch中的default语句:书写位置默认是在末尾,但是它也可以在switch语句中的任何位置,但是不影响执行流程
    				
    				都需要先跟case中的值进行比较,如果都没有匹配,都需要执行default...
    				如果default在语句的末尾,break可以省略,如果在语句中的话,不建议省略break ;
    				
    	4)关于switch语句的结束问题:
    			
    			1)遇见break (中断,结束的意思) ,switch语句结束
    					break:属于跳转控制语句中一种:两种场景:switch中/循环语句中
    			2)语句默认执行到末尾!

\*\*例题2\*\*键盘录入月份的值,判断季节(switch语句完成)

/*
    	键盘录入月份的值,判断季节(switch语句完成)
    			
    		3,4,5   春季
    		6,7,8   夏季
    		9,10,11 秋季
    		12,1,2  冬季
    	
    		
    */
    //导包
    import java.util.Scanner ;
    class SwitchTest2{
    	public static void main(String[] args){
    		
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并接收数据
    		System.out.println("请输入一个月份的值:") ;
    		int month = sc.nextInt() ;
    		//方式1:普通方式
    		/*
    		switch(month){
    		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 ;
    		 case 8:
    		  System.out.println("夏季") ;
    		  break ;
    		 case 9:
    		  System.out.println("秋季") ;
    		  break ;
    		 case 10:
    		  System.out.println("秋季") ;
    		  break ;
    		 case 11:
    		  System.out.println("秋季") ;
    		  break ;
    		 case 12:
    		  System.out.println("冬季") ;
    		  break ;
    		 default:
    			System.out.println("非法数据!!") ;
    			break ;
    		}
    		*/
    		
    		//方式2:利用case穿透
    		switch(month){
    		case 1:
    		case 2:
    		case 12:
    			System.out.println("冬季");
    			break ;
    		case 3:
    		case 4:
    		case 5:
    			System.out.println("春季");
    			break ;
    		case 6:
    		case 7:
    		case 8:
    			System.out.println("夏季");
    			break ;
    		case 9:
    		case 10:
    		case 11:
    			System.out.println("秋季");
    			break ;
    		default:
    			System.out.println("非法数据!!!");
    			break ;
    		}
    	}
    }

\*\*例题3\*\*模拟一个单项选择题 使用switch语句操作

/*
    		
    	需求:
    	键盘录入一个选择: Scanner类--->录入不了字符类型
    		模拟一个单项选择题   使用switch语句操作
    		  'A' 'B' 'C'  'D'	  		  
    */
    //导包
    import java.util.Scanner;
    class SwitchSelectExp
    {
    	public static void main(String [] args)
    	{
    		//键盘录入数据
    		Scanner sc = new Scanner(System.in);
    		//提供几个选项
    		System.out.println("你喜欢的水果？");
    		System.out.println("65 苹果");
    		System.out.println("66 梨");
    		System.out.println("67 香蕉");
    		System.out.println("68 凤凰");
    		
    		System.out.println("请输入一个选项");
    		int choic = sc.nextInt();
    		//强转
    		char choicNumber = (char) choic; 
    		switch(choiceNumber){
    		case 'A' :
    			System.out.println("答案正确!") ;
    			break ;
    		case 'B' :
    			System.out.println("对不起,答案有误!") ;
    			break ;
    		case 'C' :
    			System.out.println("对不起,答案有误!") ;
    			break ;
    		case 'D' :
    			System.out.println("对不起,答案有误!") ;
    			break ;
    		default :
    			System.out.println("没有提供该选项") ;
    			break ;
    		}
    	}
    }

#### 2.4循环控制语句 ####

循环结构语句分类:  
for循环  
while循环  
do-while循环

##### 2.4.1For循环 #####

for循环的格式:

for(初始化语句;条件表达式;步长语句){
    			  循环体语句;
    		}

执行流程:

1)初始化语句给变量进行赋值,只执行一次
    2)判断这个条件表达式是否成立,
      如果成立,就执行循环体语句,在去执行步长语句 (++,--)
    3)再次判断条件表达式是否成立,如果成立,继续上面执行方式...
     ...
    
    4)一直循环到条件表达式不成立的时候,for循环结束!

**例题1**求10以内数字的和

import java.util.Scanner;
    class ForExam
    {
    	public static void main(String[] args)
    	{
    		    //求10以内数字的和
    			int sum = 0;
    			for(int x = 1; x <= 100; x++)
    			{
    				sum = sum + x;
                                                                      //+= 运用
    				 //sum +=  x;
    			}
               
    			//System.out.println(x);
    			System.out.println(sum);
    			
    			System.out.println("------------------------");
    			//求两个数乘积
    			int sum2 = 0;
    			for(int i = 1; i <=9; i++)
    			{
    				for(int j = 1; j <=i; j++)
    				{
    					sum2 = i*j;
    					System.out.println(i + "*" + j +"="+sum2+"");
    				}
    				System.out.println(" ");
    			}
    			System.out.println("------------------------");
    		
    	}
    }

**例题2** 求水仙花数

class ShuiXianHua
    {
    	public static void main(String[] args)
    {
    	for( int x = 100; x <= 999; x++){
    			int ge = x%10;         //获取个位
    		    int shi = (x/10)%10;   //获取十位
    		    int bai = (x/10/10)%10;  //获取百位
    		    if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)){
    		    	System.out.println(x + "是一个水仙花数。");
    	}
    	}
    }
    }

统计水仙花数个数

/*
    需求:
    	统计所有的水仙花数有多少个?
    分析:
    	1)定义一个统计变量:int count = 0
    	2)水仙花数:三位数----for循环
    	3)获取每一个数据的数据
    				获取个位
    							
    				定义变量
    					int  ge = 153 % 10(对10求余)  3
    				
    				获取十位:
    					int shi = 153 /10(取整) % 10(取整的结果对10求余)  5
    					
    				获取百位:
    					int bai = 153 /10 /10  % 10 (取整结果对10求余) 1
    					
    	4)在循环中满足的条件:	
    			bai*bai*bai + shi * shi *shi + ge * ge * ge 
    			结果和数据(100-999之间的数据)本身相等,统计变量++即可!
    	
    */
    class ForTest3{
    	public static void main(String[] args){
    		
    		//1)定义统计变量
    		int count = 0 ;
    		
    		//2)水仙花数:三位数:明确范围
    		for(int x = 100 ; x <= 999 ; x ++){
    			//定义三个变量:获取每个位的数据本身
    			int ge = x % 10 ;
    			int shi = x / 10 % 10 ;
    			int bai = x /10 /10 % 10 ;
    			
    			//满足的条件
    			if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
    				//统计变量++
    				count ++ ; //1 //2
    				
    				System.out.println("x:"+x) ;
    			}
    		}
    		
    		System.out.println("水仙花共有"+count+"个") ;
    	}
    }

##### 2.4.2for循环嵌套 #####

格式：

for(初始化语句;条件表达式;步长语句){
    		
    		
    		//循环体语句
    		for(初始化语句;条件表达式;步长语句){
    		
    			
    		}
    	}

**例题1** 打印输出\*矩阵

/*
    	
    需求:
    控制台输出:四行五列的*形
    *****
    *****
    *****
    *****	
    */
    
    class ForForDemo{
    	public static void main(String[] args){
    		
    		//原始的做法:
    		System.out.println("*****") ;  //System.out.println():打印内容并换行
    		System.out.println("*****") ;
    		System.out.println("*****") ;
    		System.out.println("*****") ;
    		System.out.println("------------------------------") ;
    		
    		//改进
    		for(int x = 0 ; x < 4 ; x ++){//x = 0,1,2,3 (循环四次) :外层循环控制行数
    			
    			for(int y = 0 ; y < 5 ;y++){ //0,1,2,3,4 //内存循环控制:列数
    				
    				System.out.print("*") ; 
    			}
    			System.out.println() ; //空行
    		}
    		
    		System.out.println("----------------------------------") ;
    		
    		//6行7列
    		for(int x = 0 ; x < 6 ; x ++){
    			for(int y = 0 ; y < 7 ; y ++){
    				System.out.print("*") ;
    			}
    			System.out.println();
    		}
    	}
    }

例题2 打印九九乘法表

/*
    需求:99乘法表
    1*1 = 1 
    1*2 = 2	 2*2 = 4
    1*3 = 3  2*3 = 6   3*3 = 9 
    1*4 = 4                          ........
    												 
    	转移字符:
    		\t : 制表符号  ----->类似于文本文件中那个tab键 :缩进
    		\n : 换行符号
    													 
    */
    
    class ForForTest{
    	public static void main(String[] args){
    
    		//99乘法表:
    		//为了有数据,从1开始
    		for(int x = 1 ; x <= 9 ; x ++){//外层循环控制行数
    			for(int y = 1 ; y<=x ; y ++){//内层循环
    				//输出
    				System.out.print( y+"*" + x +"="+(y*x)+"\t") ;
    			}
    			System.out.println() ;
    			
    		}
    	}
    }

##### 2.4.3While循环 #####

while循环语句格式:

基本格式
    	while(初始化语句以及条件表达式){
    		 循环体语句;
    		 步长语句(控制体语句) ;
    	}
    	
    扩展格式:(推荐)
    		初始化语句;
    		while(条件表达式){
    			循环体语句;
    			步长语句(控制体语句) ;
    		}

执行流程:

1)首先初始化语句进行赋值
    		2)判断条件表达式是否成立,如果成立,执行循环体语句
    		   再次执行步长语句;
    		3)继续判断条件表达式是否成立,如果成立,执行循环体语句
    		  再次执行步长语句;
    		  ...
    		  ...
    		  
    		4)当条件表达式为false,不成立,while循环语句结束

##### 2.4.4死循环 #####

/*
    	两个死循环
    		
    		格式1:
    			for(;;){
    				
    				循环体语句;
    			}
    			
    		格式2 :(推荐)
    			while(true){
    				
    				循环体语句;
    			}
    */
    
    class WhileDemo3{
    	public static void main(String[] args){
    		
    		//格式1;
    		/*
    		for(;;){
    			System.out.println("我很开心,学习了死循环....") ;
    		}
    		*/
    		//格式2:
    		while(true){ //恒成立
    			System.out.println("我很开心,学习了死循环....") ;
    		}
    	}
    }

##### 2.4.5获取随机数 #####

/*
    	java.lang.Math
    	Math 
    	类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
    	
    	获取随机数的方法
    		使用:
    			public static double random() :取值范围[0.0,1.0)
    			static:静态的 (面向对象讲)
    			
    			
    	需求:使用Math类中的方法 random()获取一个1-100之间的随机数
    	
    	然后在键盘录入一个int类型的数据,猜产生的随机数!
    	
    	分析:
    			
    			1)使用Math的random()产生一个1-100之间的随机数
    			2)然后使用Scanner:键盘录入录入int类型的数据
    			
    			while(true){ //保证不断录入数据,不知道录入多少次,使用while循环
    			3)判断当前录入的数据和随机数的数据进行对比
    			
    				要么大了,提示"数据大了"
    				小了,提示"数据小了"
    				相等,
    						break ; 结束while循环
    				
    			}
    			
    			
    */
    //导包
    import java.util.Scanner;
    class WhileTest2{
    	public static void main(String[] args){
    		
    		//产生一个随机数:1-100之间
    		int number = (int)(Math.random()*100+1) ; //99
    		//为保证不断的录入数据,使用while(true)
    		//定义一个统计变量
    		//int count = 0 ;
    		while(true){
    		//	count ++ ;//统计变量++
    			//键盘录入数据
    			Scanner sc = new Scanner(System.in) ;
    			
    			//提示并接收数据
    			System.out.println("请您输入一个要猜的数据:") ;
    			int guessNumber = sc.nextInt() ;
    			
    			//判断
    			//键盘录入的数据大于产生的随机数
    			if(guessNumber > number){
    				System.out.println("您要猜的数据大了...") ;
    			}else if(guessNumber < number){
    				System.out.println("您要猜的数据小了...") ;
    			}else{
    				System.out.println("恭喜您,猜中了!!!") ;
    				break ;//结束了
    			}
    		}
    		
    	}
    }

##### 2.4.6 do …while循环 #####

格式：

初始化语句;
    		do{
    			循环体语句;
    			步长语句(控制体语句) ;
    		}while(条件表达式) ;

执行流程：

1)初始化语句赋值
    2)直接执行循环体语句---->步长语句--->条件表达式
    	....
    	....

#### 扩展： ####

#### 1.for循环和while循环的区别? ####

1)格式的区别
    	for(初始化语句;条件表达式;步长语句){
    		循环体语句;
    		}
    		初始化语句;
    		while(条件表达式){
    			循环体语句;
    			步长语句;
    		}
    		
    	2)是否节省内存空间 
    		for循环结束,这个变量及时从内存中释放掉了...
    		while循环结束,这个变量依然可以访问的!
    		
    	3)是否明确循环次数
    	   
    	  for循环:明确循环次数
    	  while:不明确循环次数!

#### 2.dowhile循环和其他两个循环语句的区别是什么? ####

循环体至少执行一次!

少次,使用while循环  
3)判断当前录入的数据和随机数的数据进行对比

要么大了,提示"数据大了"
    			小了,提示"数据小了"
    			相等,
    					break ; 结束while循环
    			
    		}

\*/  
//导包  
import java.util.Scanner;  
class WhileTest2\{  
public static void main(String\[\] args)\{

//产生一个随机数:1-100之间
    	int number = (int)(Math.random()*100+1) ; //99
    	//为保证不断的录入数据,使用while(true)
    	//定义一个统计变量
    	//int count = 0 ;
    	while(true){
    	//	count ++ ;//统计变量++
    		//键盘录入数据
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并接收数据
    		System.out.println("请您输入一个要猜的数据:") ;
    		int guessNumber = sc.nextInt() ;
    		
    		//判断
    		//键盘录入的数据大于产生的随机数
    		if(guessNumber > number){
    			System.out.println("您要猜的数据大了...") ;
    		}else if(guessNumber < number){
    			System.out.println("您要猜的数据小了...") ;
    		}else{
    			System.out.println("恭喜您,猜中了!!!") ;
    			break ;//结束了
    		}
    	}
    	
    }

##### 2.4.6 do ...while循环
    
    格式：

初始化语句;  
do\{  
循环体语句;  
步长语句(控制体语句) ;  
\}while(条件表达式) ;

执行流程：

1)初始化语句赋值  
2)直接执行循环体语句---->步长语句—>条件表达式  
…  
…

#### 扩展：
    
    #### 1.for循环和while循环的区别?
    
    		1)格式的区别
    		for(初始化语句;条件表达式;步长语句){
    			循环体语句;
    			}
    			初始化语句;
    			while(条件表达式){
    				循环体语句;
    				步长语句;
    			}
    			
    		2)是否节省内存空间 
    			for循环结束,这个变量及时从内存中释放掉了...
    			while循环结束,这个变量依然可以访问的!
    			
    		3)是否明确循环次数
    		   
    		  for循环:明确循环次数
    		  while:不明确循环次数!
    
    #### 2.dowhile循环和其他两个循环语句的区别是什么?
    
    	循环体至少执行一次!

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/d0d5ccf7941640ddb16a9bda096ababe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/ccc927b4a1e7451fa971feed0d4482f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/2f87076b3f814e419a0368acce3f9358.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Vpa2kxMjMw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/583aa9b81edc417d85d4abbd23d4df4c.png