Java程序猿必学第二篇——分支语句(if else Switch)

//1.运算符(重点)
//===================赋值运算符===================
//赋值运算符：=  += -= *= /= %=
//基本赋值： =
//复合赋值： += -= *= /= %=
int a = 3;  //定义变量时赋值(初始化赋值)
a = 5;     //基本赋值
System.out.println(a);  //5

a += 3;  //8 等价：a=a+3  先加再赋值
System.out.println(a);  //8
a *= 2;  //16 等价：a=a*2 先乘在赋值
System.out.println(a);  //16


//===================关系运算符（重点）===================
//关系运算符：> >= < <= == != (注意：两个==是等于，一个=是赋值)
//关系运算符的结果为boolean类型  成立则为true，不成立则为false
System.out.println(3>2);  //true
System.out.println(3>=2); //true
System.out.println(3<2);  //false
System.out.println(3<=2); //false
System.out.println(3==2); //false
System.out.println(3!=2); //true

//应用场景：在后续的分支语句，循环语句中都需要用到关系运算符



//===================逻辑运算符===================
/*
	逻辑运算符： && || ！
	规则： 
	   逻辑与&&：操作数两边，如果有一边为false，则最终结果为false
	   逻辑或||: 操作数两边，如果有一边为true，则最终结果为true
	   逻辑非!:  只有一个操作数，如果值为false，则取反后为true;如果值为true，取反后为false
*/
System.out.println((3>2)&&(5<3));  //false

System.out.println(false&&true);   //false
System.out.println(false||true);   //true
System.out.println(!false);        //true

//扩展：  逻辑与&   逻辑或| --规则和上面的&&  ||是一样的 
System.out.println(false&true);   //false
System.out.println(false|true);   //true

//区别：
//&&：如果第一个操作数为false，则不执行第二个操作数
//&:  如果第一个操作数为false，还会执行第二个操作数

//||: 如果第一个操作数为true，则不执行第二个操作数
//|： 如果第一个操作数为true，还会执行第二个操作数

//验证结果:
boolean b = false;
//System.out.println(false&(b=true));  
System.out.println(false&&(b=true));
System.out.println("b="+b);   //b=false

//结论：后续操作基本上使用&&，||； 因为效率更高

//应用场景： 数学中的式子： 10<x<20;
int x = 15;
//System.out.println(10<x<20);  //true
System.out.println((x>10)&&(x<20));   //true


//===================三目运算符===================
/*
	三目运算符： 拥有三个操作数的运算符     
	格式： (关系表达式)?操作数1:操作数2
	说明： 关系表达式如果成立，最终结果为操作数1；不成立，最终结果为操作数2
	应用场景：往往用在求最大值和最小值
*/

int a = (5<3)?5:3;
System.out.println(a);  //3

//案例：求两个变量，x，y的最大值
int x = 5;
int y = 8;
System.out.println((x>y)?x:y);  //8 最大值
System.out.println((x<y)?x:y);  //5 最小值

/*

    ===================表达式===================
    表达式：由操作数和运算符组成的式子
    例如：关系运算符参与的式子--->关系表达式
          算数运算符参与的式子--->算数表达式


    ==================自动类型的提升=================
    1.算数运算的最终结果，为操作数中最大的那个类型
    2.操作数中为byte和short类型，最终运算结果提升为int
    3.String类型和任意类型拼接(+),都为String类型 

*/

//2. 控制台录入

/*
    控制台录入：从命令提示符中输入一个值，传给变量
    步骤：
    1. 导包  2.实例化对象  3.接收录入的值  
*/
import java.util.Scanner;  //1.导包
public class Control{
	public static void main(String[] args){
		//2.实例化对象
		Scanner sc = new Scanner(System.in);
		//3.调用方法，接收录入的值
		int num = sc.nextInt();  //接收int类型值(常用)   阻塞方法
		//double num = sc.nextDouble();  //接收double类型值
		//String num = sc.next();  //接收字符串类型值(常用)
		//char num = sc.next().charAt(0);  //接收字符串的第0个字符，下标从0开始
		System.out.println("输出："+num);  //打印接收的值
		
		//注意：如果控制台录入的值不匹配，则会提示InputMismatchException
	}
}
   

//3. 选择结构（重点）
/*
    ===================生活中的执行结构===================
    1.顺序性：早上起床->刷牙->吃早餐->上学
    2.选择性：上学做地铁或步行或坐飞机等
    3.重复性：每天敲代码等

    ===================程序中的执行结构===================
    1.顺序性：目前所写的代码，都是自上而下顺序性编写和执行的
    2.选择性：多种判断条件，选择一种(现在学)
    3.重复性：循环地执行某一段代码(明天学)
*/


//===================if单分支结构===================
//if单分支语句：
//语句结构:
/*
if(关系表达式){
   语句；
}
执行流程：如果关系表达式成立，则执行{}里面的语句
*/
//案例：如果祝黄雨鹏考试及格，那么请全班吃饭
System.out.print("请输入祝黄雨鹏的考试成绩:");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=60){
	System.out.println("请全班吃饭~");
}
//案例2：如果今天消费超过100，则提示超支
//案例3：如果超过8点50到校，则迟到了



//===================if双分支结构===================

//if.else双分支结构---2选1
/*
	语法结构：
	if(关系表达式){
		语句体1;
	}else{
		语句体2；
	}
	执行流程：如果关系表达式成立，则执行语句体1；不成立则执行语句体2
*/
//案例：兰翔如果月薪过万，则请全班吃饭；否则全班请他
System.out.print("请输入兰翔的就业薪资：");
Scanner sc = new Scanner(System.in);
double salary = sc.nextDouble();
if(salary>=10000){
	System.out.println("月薪过万，请全班吃饭");
}else{
	System.out.println("全班含泪请兰翔");
}

//案例2：如果考试100分，明天放假；否则，继续学习
//案例3：如果钱包有100块，明天吃肯德基；否则，吃泡面



//===================if多分支结构===================
/*
	if多分支： 多选一
	语法结构:
	if(关系表达式1){
		语句体1;
	}else if(关系表达式2){
		语句体2；
	}...
	else if(关系表达式n){
		语句体n;
	}else{
		语句体n+1;
	}
	执行流程：如果表达式1成立，则执行语句体1；否则如果表达式2成立，则执行语句体2...
			  如果前面都不成立，则执行最后的else
*/
//案例1：滴滴打车，如果有100块，那么打商务车；
//如果60块钱，就打快车；如果30块，则拼车；否则步行

//案例2：如果今天星期一则吃肯德基；如果是星期二，则吃麦丹劳；
		//如果星期三则沙县；否则黄焖鸡

//案例：如果考试超过90分，则A等级； 超过80，B等级  超过70，C等级
		//超过60则D等级； 否则E等级
System.out.print("请输入你的百分制分数:");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=90&&score<=100){
	System.out.println("A");
}else if(score>=80&&score<90){
	System.out.println("B");
}else if(score>=70&&score<80){
	System.out.println("C");
}else if(score>=60&&score<70){
	System.out.println("D");
}else{
	System.out.println("E");
}



//===================if嵌套===================

//if嵌套：if中包含if

//案例：如果考试超过90分，则A等级； 超过80，B等级  超过70，C等级
		//超过60则D等级； 否则E等级

System.out.print("请输入你的百分制分数:");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=0&&score<=100){
	/* 完整写法，建议初学者都写全
	if(score>=90&&score<=100){
		System.out.println("A");
	}else if(score>=80&&score<90){
		System.out.println("B");
	}else if(score>=70&&score<80){
		System.out.println("C");
	}else if(score>=60&&score<70){
		System.out.println("D");
	}else{
		System.out.println("E");
	}*/
	
	//简化写法：
	if(score>=90){
		System.out.println("A");
	}else if(score>=80){ //隐含了score<90
		System.out.println("B");
	}else if(score>=70){ //隐含了score<80
		System.out.println("C");
	}else if(score>=60){  //隐含了score<70
		System.out.println("D");
	}else{  //隐含了score<60
		System.out.println("E");
	}
	
}else{
	System.out.println("超出了百分制范围！");
}

//应用场景：判断一个范围，要么从小到大，要么从大到小判断


//4. switch分支结构

//===================switch案例1===================
//switch语句：叫标号跳转语句
/*
	语法结构:
	switch(变量){
		case 值1:
			语句体1;  //注意：如果匹配了某个case值，则会一直往下执行，直到遇到break
			break;    //跳出switch结构
		case 值2：
			语句体2；
			break; 
		...
		case 值n
			语句体n;
			break;
		default:    //类似于if多分支的else判断
			语句体n+1;		
			break;
	}
*/
//案例：请输入周一到周五吃饭的问题：
System.out.print("请输入周一到周五吃什么:(1~5)");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
switch(week){
	case 1:
		System.out.println("鲍鱼龙虾");
		break;
	case 2:
		System.out.println("水煮牛肉");
		break;
	case 3:
		System.out.println("肯德基");
		break;
	case 4:
	case 5:
		System.out.println("泡面");
		break;
	default:
		System.out.println("减肥...");
		break;
}




//===================switch案例2===================
//案例：请输入月份，打印对应的天数；2月直接打印28天即可
System.out.print("请输入月份:");
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
switch(month){
	case 1:
	case 3:
	case 5:
	case 7:
	case 8:
	case 10:
	case 12:
		System.out.println("31");
		break;
	case 4:
	case 6:
	case 9:
	case 11:
		System.out.println("30");
		break;
	case 2:
		System.out.println("28");
		break;
	default:
		System.out.println("您的月份输入有误");
		break;
}

//注意：在jdk1.7之后，变量匹配的类型可以是 byte,short,int,char,String


//===================switch案例3===================
//switch：匹配的变量为String类型
//案例：请输入四大天王姓名，对应打印输出特点
System.out.print("请输入四大天王姓名：");
Scanner sc = new Scanner(System.in);
String name = sc.next();
switch(name){
	case "刘德华":
		System.out.println("全能艺人");
		break;
	case "张学友":
		System.out.println("歌神");
		break;
	case "郭富城":
		System.out.println("舞蹈天王");
		break;
	case "黎明":
		System.out.println("除了帅没什么可说的");
		break;
	default:
		System.out.println("输入有误~");
		break;
}

//总结：if多分支与switch都是分支语句结构，应用场景？
//if多分支：倾向于用在判断一个范围
//switch：  倾向于用在等值判断中


//5.局部变量
//局部变量：现在所学的变量，都属于局部变量，必须先赋值，再使用
//int a=3;
//System.out.println(a);
//局部变量的作用域(有效范围)，在定义变量处，到}结束前

//关于局部变量重名冲突问题: 在重叠作用域中不能有相同变量名
{
	int a = 5;
}

{
	int a = 3;
}



//6.循环语句
//生活中循环：跑道故事，从1圈开始跑，循环跑完25圈，结束
//程序中循环：条件成立，循环执行一段代码，指定条件不满足，则跳出循环
//while循环:
/*
	语法结构：
	初始化语句---1
	while(条件判断){--2
		循环体语句--3
		增量语句--4
	}
	
	//执行流程：
	1.初始化语句，只执行一次
	2.条件判断,如果成立则执行循环体操作；否则，跳出循环
	3.循环体操作
	4.增量语句 再跳到第2句的条件判断 
*/
//案例：从第1圈开始跑，循环跑完25圈结束
int i=1;  //1.初始为第1圈
while(i<=25){  //条件判断
	System.out.println("已经跑完了第"+i+"圈");  //循环体
	i++;   //增量语句-用于改变条件判断的变量
}
//System.out.println(i);  //26