JAVA基本语法(二):运算符+流程控制+循环

1.运算符

1.1概述

1.1.2 测试自增自减 (重难点)

/*
一,运算符
--1,算数运算符: + - / * ++ -- %(模)
--2,比较运算符(结果是boolean类型):== != 
--3,逻辑运算符(结果是boolean类型):+ !(取反) & |
--4,三元运算符: 1 ? 2 : 3
		--结果是2或者是3,到底是2还是3要看1的结果了,1如果描述的成立,结果是2.1如果描述不成立,结果是3.
--5,赋值运算符: = += -= *= /=
--6,逻辑运算符 & | 
	--逻辑&:表示并且关系
		1 & 2 :如果最终运算的结果,想要是true,要求1和2,必须都是true
	--短路与/双与&&:表示并且关系 -- 高效
		1 && 2 :
			2的位置可能会发生短路,当1的位置判断完得到false时,结果就已经注定了是false,此时2可以不参与运算(发生短路).可以提高效率.
		
	--逻辑|:表示或者关系
		1 | 2 :如果最终运算的结果,想要是true,要求1和2中,有一个true就行
	--短路或/双或||:表示或者关系  -- 高效	
		1 || 2 :
			2的位置可能会发生短路,当1的位置判断完得到true时,结果早都注定了是true,此时2可以不参与运算(发生短路).用来提高效率.	
*/
	public class Test1_ZIzeng {
		public static void main(String[] args) {
			int a = 1;
			//符号在后,先使用再变化
			System.out.println(a++);//1
			
			int b = 1;
			//符号在前,先变化再使用
			System.out.println(++b);//2
			
			System.out.println(++b+b+a++);//3+3+2=8
			
			int c = 1;
			//符号在后,先使用再变化
			System.out.println(c--);//1
			
			int d = 1;
			//符号在前,先变化再使用
			System.out.println(--d);//0
			System.out.println(--c-c-d--);//-1-(-1)-0=0
		}
	}

1.1.3 三元运算符求最大值

//这个类用来测试 三元运算符
		public class Test2_MaxValue {
			public static void main(String[] args) {
				int a = new Scanner(System.in).nextInt();
				int b = new Scanner(System.in).nextInt();

				// 两个数里的大值:max记录的值可能是a也可能是b,到底是a还是b呢?--要看a>b判断成立不
				int max = a > b ? a : b;
				System.out.println("a b里的大值是:" + max);

				// 三个数里的大值:
				int c = new Scanner(System.in).nextInt();
				
				//res记录着max和c里的大值
				int res = max  > c ? max : c ;
				System.out.println("a b c里的大值是:"+res);
				
				//TODO 优化:一步到位
				//int res = a > b ? 2 : 3 ;
				//int res = a > b ? a大 : b大 ;
				int res = a > b ? ( a > c ? a : c ) : ( b > c ? b : c ) ;
				System.out.println("a b c里的大值是:"+res);
				}
		}

1.1.4 逻辑运算符求平年闰年

--需求:1、能被4整除，并且不能被100整除
	   2、或者能被400整除
			
		package cn.tedu.basic;
		import java.util.Scanner;
		//这个类用来测试 平年闰年
		public class Test3_Runnian {
			public static void main(String[] args) {
				//1,接收键盘输入的年号
				int year = new Scanner(System.in).nextInt();
				
				String desc = "平年";//设置默认值
				//2,判断   : if(判断条件){满足条件的代码}
				//条件1、能被4整除，并且不能被100整除    ||    条件2、能被400整除
				//能被4整除    &&    不能被100整除    ||   能被400整除
				//if(判断条件){满足条件的代码}
				//if(能被4整除    &&  不能被100整除    ||  能被400整除){满足条件的代码}
				if( year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ){
					desc = "闰年";//修改desc的值是闰年
				}
				
				//System.out.println("2020年是闰年");
				System.out.println(year+"年是"+desc);
				
			}
			
		}

2.分支结构

2.1 if

2.1.1 概述

顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。
分支结构是相对于顺序结构而言的.顺序结构只能一行一行顺序的从上往下执行.但是无法完成先判断再执行的需求.

2.1.2 语法

2.1.2.1 单分支

if(判断条件){
满足了条件代码
}

2.1.2.2 多分支

多分支:
if(判断条件){
满足了条件代码
}else{
不满足了条件代码
}

2.1.2.3 嵌套分支

if(判断条件1){
满足了条件代码1
}else if(判断条件2){
满足了条件代码2
}else if(判断条件3){
满足了条件代码3
}else{
上面的谁都不满足才要执行的代码4
}

2.1.3 测试 if >>>>商品打折<<<<

//这个类用来测试 if
			public class Test4_IF {
				public static void main(String[] args) {
					//1,接收用户输入的原价
					double price = new Scanner(System.in).nextDouble();
					
					double discount = price;//定义变量,记录折后价
					//2,开始计算折后价,并输出
					if(price >= 5000) {//满5000打5折
						discount = price * 0.5 ;
					}else if(price >= 2000) {//满2000打8折
						discount = price * 0.8 ;
					}else if(price >= 1000) {//满1000打9折
						discount = price * 0.9 ;
					}
					//3,输出
					System.out.println("原价是:"+price+",折后价是:"+discount);
					
				}
				
			}

2.2 switch (了解)

2.2.1 概述

当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。

2.2.2 语法

switch(判断条件){
case 0 : syso(0) ; break;
case 1 : syso(1) ;
case ‘x’ : syso(2) ;
case “java” : syso(3) ;
default:syso(100) ;
}

2.2.3 测试

特点一:当一个case成立，从这个case向后穿透所有case，包括default

特点二: 直到程序结束或者遇到break程序才结束

3.循环结构

3.1 for循环

–1,概述
是指在程序中,需要重复执行很多次的某些功能.
–2,语法
for(循环的开始位置;循环的判断条件;循环的更改条件){循环体}

3.1.1 测试一

public class Test01 {
		public static void main(String[] args) {
			//需求:打印100次----->我爱java
			for(int a=1;a<=100; a++) {
				System.out.println("我爱java");
			}
		}
	}

3.1.2测试二

public class Test01 {
		//需求:打印8,88,888,8888
		public static void main(String[] args) {
			for(int a=8;a<=8888;a=a*10+8) {
				System.out.println(a);
			}
			
		}
	}

//需求:求[0,100]偶数的和
		//方式一:
		public static void main(String[] args) {
			int sum=0;
			for(int a=0;a<=100;a+=2) {
				sum=sum+a;
			}
			System.out.println(sum);
		}

public class Test01 {
		//需求:求[0,100]偶数的和
		//方式二:
		public static void main(String[] args) {
			int sum=0;
			for(int a=0;a<=100;a++) {
				if(a%2==0) {
					sum=sum+a;
				}
			}
			System.out.println(sum);
		}
	}

3.2 嵌套for循环

3.2.1

根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。。
–1,语法
for(开始位置;判断条件;更改条件){//外循环
循环体
for(开始位置;判断条件;更改条件){//内循环
循环体
}
}

3.2.2,特点

外循环执行1次，内循环执行多次
外循环控制行，内循环控制列

3.2.3 入门案例

案例 1:

public static void main(String[] args) {
				//1, 总结:外循环执行1次，内循环执行多次
				// 当i=1时,输出外循环i的值1,输出内循环j的所有值1 2 3 4 5
				// 当i=2时,输出外循环i的值2,输出内循环j的所有值1 2 3 4 5
				// 当i=3时,输出外循环i的值3,输出内循环j的所有值1 2 3 4 5
				for(int i = 1 ; i <= 3 ; i++ ) {// 外循环,执行3次
					System.out.println(i);
					
					for(int j = 1 ; j <= 5; j++) {// 内循环,执行5次
						System.out.println(j);
					}
					
				}
		}

案例 2:

案例 3:

案例 4:

4. break和continue

用于结束程序,可以用两种形式
1.break
2.continue

4.1 break: 中断当前循环，简单粗暴

4.2continue：跳出本次循环，进入下一轮

注 : 二者必须放在循环结构里面才能使用,但如果break用在switch里表示结束该语句;break和continue之后不要出现代码,一旦出现代码就会报错

案例 1:

5. while循环结构与do-while

while先判断后执行,do-while先执行后判断

5.1 案例测试

案例 1: >>>>>while
案例2: 改造案例1 >>>>>死循环

案例 3: 改造案例 1 >>>>>>>do-while

总结:

总结三种循环的异同:–可以互相替换
–相同点:都是为了解决程序中,需要重复的做相同的事情的需求
–不同点:
–for:知道循环的开始位置,知道循环的次数
for(开始位置;循环条件;更条件){循环体}
–while:可以不知道开始位置,可以不知道数据的规律
while(循环条件){循环体}
–do…while:可以不知道开始位置,可以不知道数据的规律
可以保证循环体最少执行1次.
do…while(循环条件){循环体}