Java -- 运算符、流程控制、案例

梦里梦外; 2023-07-20 10:55 85阅读 0赞

### 一、运算符 ###

Java中提供了非常丰富的运算符，如赋值运算符、算术运算符、比较运算符等

##### 1、赋值运算符 #####

*  用符号 “ = ” 表示

##### 2、算术运算符 #####

> “ + ”和“ - ” 运算符还可以作为数据的正负符号

##### 3、自增自减运算符 #####

自增++、自减–

++a(--a)//表示在使用变量a之前，先使a的值加（减）1
    a++(a--)//表示在使用变量a之后，使a的值加（减）1

测试案例

package cn.tedu.hello.day03;
    
    //测试自增++、自减--
    public class Test_Zizeng { 
    	//符号在前，先变化后使用
    	//符号在后，先使用再变化
    	public static void main(String[] args) { 
    		int a = 1;//符号在后，先使用再变化
    		System.out.println(a++);//输出1，此时a=2
    		int b = 1;//符号在前，先变化后使用
    		System.out.println(++b);//2
    		
    		System.out.println(++a+b+a++); //3+2+3=8
    		
    		int c = 1;
    		System.out.println(c--);//1,此时c=0
    		int d = 1;
    		System.out.println(--d);//0
    		
    		System.out.println(--c-d-c--);//0
    	}
    }

##### 4、比较运算符 #####

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>作用</th> 
   <th>举例</th> 
   <th>操作数据</th> 
   <th>结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&gt;</td> 
   <td>比较左边是否大于右边</td> 
   <td>‘a’&gt;‘b’</td> 
   <td>整型、浮点型、字符型</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>比较左边是否小于右边</td> 
   <td>156&lt;456</td> 
   <td>整型、浮点型、字符型</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>比较左右两边是否相等</td> 
   <td>‘c’==‘c’</td> 
   <td>基本数据类型、引用型</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>比较左边是否大于等于右边</td> 
   <td>479&gt;=426</td> 
   <td>整型、浮点型、字符型</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>比较左边是否小于等于右边</td> 
   <td>12.45&lt;=45.6</td> 
   <td>整型、浮点型、字符型</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>比较左右两边是否不相等</td> 
   <td>‘y’!=‘t’</td> 
   <td>基本数据类型、引用型</td> 
   <td>true</td> 
  </tr> 
 </tbody> 
</table>

##### 5、逻辑运算符 #####

![在这里插入图片描述][2020040114503695.png_pic_center]  
![在这里插入图片描述][20200401150321672.png_pic_center]  
**5.1 逻辑与：是并且的关系**

*  单与：&  
    1 & 2 , 如果结果想要是true，要求1 和 2 都是true
 *  双与/短路与：&& ，高效，是指可以把2短路掉，省去执行2的过程  
    1 && 2 , 如果1是false，此时，结果必然会是false，2就会被短路。

**5.2 逻辑或：是或者的关系**

*  单或：|  
    1 | 2 ,如果结果想要是true，要求1 或者 2 有一个为true就可以
 *  双或/短路或：||，高效，是指可以把2短路掉，省去执行2的过程  
    1 || 2 , 如果1是true，此时，结果必然会是true，2就会被短路

##### 6、三元运算符 #####

使用格式：

> 条件式?值1:值2;

运算规则为：若条件式的值为true，则整个表达式取值1，否则取值2。

练习二即为三元运算符的案例

##### 7、运算符优先级 #####

由高到低的顺序依次是：

*  增量和减量运算
 *  算术运算
 *  比较运算
 *  逻辑运算
 *  赋值运算

> 如果连个运算有相同的优先级，那么左边的表达式要比右边的表达式先被处理。

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

##### 8、练习 #####

***练习一：求两个数的大值***

package cn.tedu.hello.day03;
    
    //求两个数的最大值
    public class Test_Max { 
    	public static void main(String[] args) { 
    		//定义两个变量
    		int a = 5;
    		int b = 10;
    		
    		//取最大值 -- 三目运算符
    		//定义变量，记录最大值
    		int max = a > b ? a : b;
    		System.out.println(max);//10
    	}
    }

***练习二：求三个数的最大值***

package cn.tedu.hello.day03;
    
    import java.util.Scanner;
    
    //求两个数的最大值
    public class Test_Max { 
    	public static void main(String[] args) { 
    		//定义变量
    		int a = new Scanner(System.in).nextInt();
    		int b = new Scanner(System.in).nextInt();
    		int c = new Scanner(System.in).nextInt();
    
    // //取最大值 -- 三目运算符
    // //定义变量，记录最大值
    		int max = a > b ? a : b;
    		System.out.println("a和b最大值是："+max);
    		int result = max > c ? max : c;
    		System.out.println("a、b、c中的最大值是："+result);
    		
    		//方法二：定义三个变量
    // int a = new Scanner(System.in).nextInt();
    // int b = new Scanner(System.in).nextInt();
    // int c = new Scanner(System.in).nextInt();
    //
    // int max = (a>b)?(a>c?a:c):(b>c?b:c);
    // System.out.println(max);
    	}
    }

***练习三：平年闰年***

package cn.tedu.hello.day03;
    
    import java.util.Scanner;
    
    public class Test_RunNian { 
    	/* * 平年闰年判断条件 * 1、能被4整除，并且不能被100整除 * 2、或者能被400整除 */
    	public static void main(String[] args) { 
    		//1、接收用户输入的年号int
    		int year = new Scanner(System.in).nextInt();
    		
    		//2、判断年号是平年还是闰年
    		String desc = "平年";//设置默认是平年
    		
    		//开始判断，如果是闰年，默认修改desc的值
    		if ((year%4 == 0 && year%100 != 0) || year%400 == 0) { 
    			desc = "闰年";//修改desc的默认值
    		}
    		
    		System.out.println(year + "年是" + desc);
    	}
    }

### 二、流程控制 ###

##### （一）条件语句 #####

**1.1 if 条件语句**  
简单语法如下：

if(布尔表达式){ 
    	语句序列
    }

> 布尔表达式：必要参数，最后返回的结果必须是一个布尔值  
> 语句序列：可选参数。可以是一条或多条语句，当表达式为true的时候执行这些语句。

测试案例：  
接收用户输入的原价。满1000打9折。满2000打8折。满5000打5折。

package cn.tedu.hello.day03;
    
    import java.util.Scanner;
    
    public class Test_If { 
    	public static void main(String[] args) { 
    		//1.接收用户输入的原件double
    		double price = new Scanner(System.in).nextDouble();
    		
    		//定义变量，记录折后价
    		double discount = 0;
    		
    		//2.分析原价属于哪个档次，满1000打九折，满2000打八折，满5000打五折
    		if (price >= 5000) { 
    			discount = price * 0.5;
    		} else if(price >= 2000){ 
    			discount = price * 0.8;
    		} else if (price >= 1000) { 
    			discount = price * 0.9;
    		}
    		System.out.println("原价:"+price+"\n"+"折后价:"+discount);
    	}
    }

运行结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]  
执行过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]  
**1.2 if…else语句**  
if…else是最常用的一种形式，它会针对某种条件有选择的做出处理。

if(表达式){ 
    	若干语句
    }else{ 
    	若干语句
    }

案例展示：

package cn.tedu.hello.day03;
    
    import java.util.Scanner;
    
    public class Test { 
    	public static void main(String[] args) { 
    		int a = new Scanner(System.in).nextInt();
    		int b = new Scanner(System.in).nextInt();
    		if (a>b) { 
    			System.out.println("a>b");
    		}else { 
    			System.out.println("a<b");
    		}
    	}

执行过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 2]

> 对于if…else语句可以使用三目运算符进行简化，如下面的代码：
> 
>     if(a>0){ 
>     	b = a;
>     }else{ 
>     	b = -a;
>     }
> 
> 可以简写成 `java b = a > 0 ? a : -a;`  
> 使用三目运算符的好处是可以使代码简洁，并且有一个返回值。

**1.3 if…else if多分支语句**

if(条件表达式){ 
    	语句序列1
    }else if(条件表达式2){ 
    	语句序列2
    }
    ...
    else if(条件表达式n){ 
    	语句序列n
    }

案例展示：

package cn.tedu.hello.day03;
    
    import java.util.Scanner;
    
    public class Test_Score { 
    	public static void main(String[] args) { 
    		/** * 接收用户输入的分数 * 90分以上优秀 * 80-89 良好 * 70-79 中等 * 60-69 及格 * 60分及以下不及格 */
    
    		//接收用户输入的分数
    		int score = new Scanner(System.in).nextInt();
    		
    		if (score > 100 || score < 0) { 
    			System.out.println("请您输入合法的成绩");
    		}else { 
    			if (score >= 90 && score < 100) { 
    				System.out.println("优秀");
    			} else if (score >= 80 && score <= 89) { 
    				System.out.println("良好");
    			} else if (score >= 70 && score <= 79) { 
    				System.out.println("中等");
    			} else if (score >= 60 && score <= 69) { 
    				System.out.println("及格");
    			} else if(score < 60) { 
    				System.out.println("不及格");
    			}
    		}
    		System.out.println("程序执行完毕");
    	}
    }

运行结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]  
执行过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 3]

> **注意：if 语句只执行条件为真的命令语句，其他语句都不会执行。**

**1.4 switch 多分支语句**  
这个程序显得比较笨重，需要测试不同的值来输出语句。在Java中，可以用switch语句将动作组织起来，以一个简单明了的方式来实现“多选一”的选择。  
switch(expr1)中,expr1是一个整数表达式， 整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持。

> 注意： jdk1.7以后新增 String

简单语法：

switch (表达式) { 
    		case 常量值1:
    			语句块1
    			[break;]
    		...
    		case 常量值n:
    			语句块n
    			[break;]
    		default:
    			语句块n+1;
    			[break;]
    		}

> 1、switch 语句中表达式的值必须是整型、字符型或字符串类型，常量值1~n必须也是整型、字符型或字符串类型。  
> 2、switch首先计算表达式的值，如果表达式的值和某个case语句后面的变量值相同，则执行该case语句后的若干个语句直到遇到break语句为止。  
> 3、若没有一个常量的值和case语句后面的变量值相同，则执行default后面的语句。default语句可以不存在，若没有与之匹配的值，switch则不做任何处理。  
> 4、同一个switch语句中，case的值必须不同

测试案例：

package cn.tedu.hello.day03;
    
    //测试switch类
    public class Test_Switch { 
    	public static void main(String[] args) { 
    		int num = 4;
    		
    		switch (num) { 
    		case 'a':
    			System.out.println("jack");
    			break;
    		case 0:
    			System.out.println(0);
    			break;
    		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;
    		}
    	}
    }

执行过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 4]

> **注意：在switch语句中，case语句后面常量表达式的值可以是整数，但绝对不可以是实数。**

##### （二）循环语句 #####

**2.1 while 循环语句**  
也称为条件判断语句，他的循环方式为利用一个条件来控制是否要继续反复执行这个语句。  
`先判断，再执行`  
简单语法：

while(条件表达式){ 
    	执行语句
    }

案例展示：

package cn.tedu.hello.day03;
     
    import java.util.Random;
    import java.util.Scanner;
     
    public class Test5_猜数字 { 
        public static void main(String[] args) { 
            System.out.println("猜1~1000的随机数");
             //系统产生随机数，从0开始，要从1开始就加1
             int i = new Random().nextInt(1000)+1;
             System.out.println(i);
             
             while(true){ 
                 //接收用户输入的值
                 int sc = new Scanner(System.in).nextInt();
                 //判断
                 if(sc>i){ 
                        System.out.println("大");
                 }else if(sc<i){ 
                        System.out.println("小");
                 }else{ 
                        System.out.println("right");
                        break;
                 }
            }
        }
    }

控制台显示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]  
执行过程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 5]

> 注意：  
> 初学者经常犯得错误就是在while表达式的括号后面加`";"`.如：
> 
>     while(x == 5);
>     System.out.println("x的值为5");
> 
> 这时程序会认为是执行一条空语句，而进入无限循环，Java编译器又不会报错。可能会浪费很多的时间去调试，应该注意。

**2.2 do…while 循环语句**  
`先执行一次，再判断条件是否成立。也就是说do...while循环语句中，"{}"中的程序段，至少执行一次`  
简单语法：

do(){ 
    	执行语句
    }
    while(条件表达式);

案例展示：

package cn.tedu.hello.day03;
    
    public class Test_DoWhile { 
    	public static void main(String[] args) { 
    		int a = 100;
    		while (a == 60) { 
    			System.out.println("ok1");
    			a--;
    		}
    		int b = 100;
    		do { 
    			System.out.println("ok2");
    			b--;
    		} while (b == 60);
    	}
    }

控制台显示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]  
执行过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 6]  
**2.3 for 循环语句**  
最有用的循环语句之一，一个for循环可以用来重复执行某条语句，直到某个条件得到满足  
**2.3.1 for语句**  
简单语法：

for(表达式1,表达式2,表达式3){ 
    	语句序列
    }

> 表达式1：初始化表达式，负责完成变量的初始化  
> 表达式2：循环条件表达式，值为Boolean型的表达式，指定循环条件  
> 表达式3：循环后操作表达式，负责修整变量，改变循环条件

案例展示：

package cn.tedu.hello.day03;
    
    public class Test_For { 
    	public static void main(String[] args) { 
    		int sum = 0 ;
    		for (int i = 2; i < 100; i+=2) { 
    			sum = sum + i;
    		}
    		System.out.println("2-100之间的所有偶数和为："+sum);
    	}
    }

控制台展示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 4]  
执行过程  
![在这里插入图片描述][20200401223354820.png_pic_center]

> **小技巧！**  
> 在编码时，有时会使用for循环的特殊格式来实现无限循环，语法格式为：
> 
>     for( ; ; ){ 
>     	...
>     }
> 
> 对于这种无线循环可以通过break语句跳出循环。例如：
> 
>     for( ; ; ) { 
>     	if(x<20)
>     	break;
>     	x++;
>     }

**2.3.2 foreach语句**  
不能完全取代for语句，但是所有的foreach语句都可以改写成for语句的版本。  
语法如下：

for(元素变量x:遍历对象obj){ 
    	引用了x的Java语句
    }

> foreach语句中的元素变量x，不必对其进行初始化

案例展示：

package cn.tedu.hello.day03;
    
    import java.util.Scanner;
    
    public class Test { 
    	public static void main(String[] args) { 
    		int arr[] = { 7,10,1};
    		System.out.println("一维数组中的元素分别为：");
    		
    		for (int x:arr) { 
    			//foreach语句，int x引用的变量，arr指定要循环遍历的数组，最后将x输出
    			System.out.println(x);
    		}
    	}
    }

控制台显示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 5]

[2020040114503695.png_pic_center]: /images/20230528/afe4af8c79d5406db78ed329f7dfd9da.png
[20200401150321672.png_pic_center]: /images/20230528/51fab808ee1a45a686d2aa8393aa55a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/c62ccb4738404c95872dae705709eabc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]: /images/20230528/212f7255168e4a2ba316047f1508e55d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230528/4fbd97e76d014afb9e07e37c8bb2cde3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230528/b0c79d9d9d6847baa2d8002d8b14c5f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/10d71df733f14ce6bca907df8d96b01a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20230528/325aee0d05894f79b7cb4042abf6277b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20230528/8735672f8316404282a416269bb566f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/9ee5ef43760849baaf3ccb0e1660519f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20230528/a9a11b5e978a4607abb9ae415f69e54a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/de13842f213f49edb68037459525d800.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20230528/242b6bfd9a4f4176a538c5400e187dc5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 4]: /images/20230528/d515623ef9004069b1a402f253861d3f.png
[20200401223354820.png_pic_center]: /images/20230528/a1a568ffa9cb4d47a1eaca0ed8c73503.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 5]: /images/20230528/1e5ff52c1ee548208f399f0cdc9b4052.png