1-2 Java运算符和分支

作业

断下列程序的运行结果：
	class A {
		public static void main(String[] args) {
			int number = 10;//定义了一个变量并对变量进行赋值
			System.out.println(number);
		}
	}
	
	结果：10

	class A {
		public static void main(String[] args) {
            //先定义了一个变量number赋初值10
			int number = 10;
            //对number的变量进行修改，将原有10覆盖掉存储新的20这个值
			number = 20;
			System.out.println(number);
		}
	}
	
	结果：20
    
        
        
//改错        
public static void main(String[] agrs){
    //没有错，定义了一个i和j变量 i是有初始值1的
	int i = 1 , j;
    //错误，因为Java默认小数类型是double，所以如果明确声明float需要在小数后面添加f
	float f1 = 0.1; //修改 float f1 = 0.1f;  float f1 = (float)0.1; double f1 = 0.1
    //没有错误，虽然是给float赋值，但是不是小数，是整数，Java中默认整数int类型，所以自动类型转换
    //float和double即可以存储小数 也可以存储 整数    
	float f2 = 123;
    // float和double即可以存储小数 也可以存储 整数   
    // 浮点（小数）类型，底层是科学计数法，所以允许在存储小数类型的时候使用e代替10进行科学计数法存储    
	double d1 = 2e20 , d2 = 124;
    //b1和b2这个连个变量的操作没有任何问题，b3这个变量存储的值是129 超出了byte存储的范围【-128~127】
        //所以129是无法存储到byte类型中，因为b3存储129不是说无法存储，若要存需要强制类型转换，需要面临
        //一个问题精度缺失，修改b3 = (byte)129;
	byte b1 = 1 , b2 = 2 ,b3 = 129;
    //j变量时一个局部变量，所以局部变量在没有赋值的前提下是无法使用，所以这个操作是错误，若要修改，就需要对j变量进行初始化赋值
	j = j + 10;    
    //没错，i=0  Java中整数除以整数只能得到整数  得到结果是0，而0是整数所以这句话没有问题    
	i = i / 10;
    //错误，因为最终赋值结果是int类型存储，但是计算流程中出现小数，0.1就是double 
    // int 和 double的数据进行计算，计算结果会存储在大数据类型中，即最终结果值是一个double
    //把计算结果大范围的数据存储到小范围中，需要强制类型转换
    /*
    这样修改是不允许的i = (int)i*0.1
    需要这样修改，认为后面计算表达式是一个整体，所以i*0.1认为就是一个double
    i = (int)(i*0.1)
    还可以这样修改
    i = i * (int)0.1;
    */
	i = i * 0.1; 
    //没有问题，因为就是一个表达式计算，不会给任何变量进行赋值操作，所以结果会直接输出，不需要进行任何强制类型转换    
	System.out.println(i*0.1); 
    /*
    char是字符类型，默认存储范围是一个无符号的存储范围即0~65535结束
    根据这个存储范围char类型是允许存整数，char要遵守一个规则
    基础规则是ASCII码表从整数0开始到127结束，会根据十进制的值取查找对应想字符
    因为ASCII码有局限性，在美国范围内是可以表示所有的字符和字母的，在全世界范围内就有会选表示不足的问题
    提供一个新的字符集--》万国码unicode--》包含了全世界的所有文字-->这个2万国码中也包含ASCII
    最典型的中文编码集是UTF-8 --》包含了所有中文 范围\u0000~\uFFFF   
    */
	char c1='a',c2=125;
    //没有问题，c2输出的不是数字，而是ASCII码表对应字符    
	System.out.println(c2);
    //在计算过程 byte，short，char会默认提升为int类型，所以在计算的时候需要注意类型转换问题
    //错误:因为b1和b2在计算时候会被提升为int类型，所以b1-b2得到结果就是一个int，存储会byte就需要强制类型转换了  byte b = (byte)(b1-b2);
	byte b = b1-b2;
    //错误：原因是因为表达式计算结果是一个int，存储的时候是char，需要强制类型转换
    //char c = (char)(c1+c2-1)    
	char c = c1+c2-1; 
    //如果在f1没有修改的前提下有错，f1中存储的式double，如果修改了是没有问题
   // float类型在计算的时候不会默认提升为double    
	float f3 = f1+f2;
    //错了,0.1是double，所以表达式计算结果的导向是double，存储类型是float，存储会出错
    /*
    float f4 = f1+f2*0.1f;
    或
    float f4 =(float)(f1+f2*0.1)
    */    
	float f4 = f1+f2*0.1;
    //没错   
	double d= d1 * i + j; 
}    
	

Java表达式和运算符

表达式：是有运算符和变量或常量组成的式子，这个式子会得到一个结果值，这个结果值是根据运算符决定的

算数运算符

组成：【+ - * / %】

在记录char类型时候需要纪录几个特殊的字符

a~z  A~Z  0~9
PS：0~9是字符不是数字
    需要记录字符对应十进制
    a ~> 97
    A ~> 65
    0 ~> 48
    后续的每一个字符，十进制逐渐+1即可
    大小写字母之间的关联值，a和A即大小写对等为位置存在一个差值 32
    例如：
    将一个大写A变成一个小写a
    char ch = 'A'; //首先计算中是存不了字符的，因为存储数据都是0,1，存储都是一个十进制转换二进制
                   //通过这个字符A寻找ASCII表中对应十进制数值，然后转换
    char cha = (char)(ch+32);// ch相当获取的式存储的二进制的值，然后转换成十进制参与计算
                             //十进制+十进制 得到是整数int 类型
                            //将这个十进制转换为char，寻找ASCII码中对应十进制对应字符存储到char
    将一个小写b转换为一个大写B
    char ch = 'b';
    char chB = (char)(ch-32);

赋值运算符和复合运算符

赋值运算符

java中如果需要判断两数据是否相当，不能使用 = 
等号在java中表示赋值运算的一个符号
使用规则：
1. = 是一个右结合【先计算等号右边然后在计算等号的左边】
2. 等号的左边只能是【变量或定义常量（使用final修饰符修饰的）】
3. 等号的右边可以是【变量、常量、表达式】
例如：
    int a = 1;
	int b = 2;
    int sum = a+b;
PS:上面这些操作一定是先计算右边然后在计算左边

复合运算符

组成： += -= *= /= %=
常用：+= -= *=
复合运算符相当于是计算表达式的一个缩写，当通过计算表达式计算的结果在赋值给原有存在在计算表达式中变量
例如：
    求出a+b变量的和并赋值a变量
    int a = 1;
    int b = 2;
    a = a+b;
   对上面的计算逻辑进行优化
    a += b 
    拆解
   a+=b --》将a+ 移动到=的右边 --》a+= a+b --》等号的左边只保留变量 --》 a = a+b
   剩余的复合运算符和当前计算逻辑是一致
       
PS：如果在使用复合运算符的时候等号的右边是一个表达式，那么会优先计算表达式值，然后在于变量参与运算
    例如：
       int a = 7;
       a *= 3+5;
    拆解
    a *= 3+5 --》将a*移动到=右边 --》a* = a*3+5 --》等号的左边只保留变量，但是等号右边优先计算表达式的值 --》a = a*(3+5)    

关系运算符和逻辑运算符

PS：无论是关系运算符还是逻辑运算符组成的表达式，结果只有true和false，而true和false是boolean数据类型值，所以称为关系或逻辑表达式为 --》【布尔表达式】

关系运算符

组成： >(大于)  >=(大于等于) <(小于)  <=(小于等于)  ==(恒等于) !=(不等于)
PS：>= 和 <= 只需要满足其中一个条件即可
    无论是>=还是<= 是一个或者关系即   > 满足即可 或 =满足即可      < 满足即可 或 =满足即可
    例如：
    int a = 1;
    int b = 2;
    boolean res = a >= b;
    拆解：
    a>=b -->就相当于得到这样一个表达式 --> a > b 或者 a == b -->只要满足一个条件即可
    PS:通俗说：要么a大于b，要么a等于b
    <=是同理
    
    关系表达式计算的结果只有true和false 所以可以用boolean类型的变量来接收
    
    在Java中如果判断两"数值"是否相等,不能使用=，而是使用 == 进行判断
    数值主要指的是：基本数据类型即【byte，short,int,long,float,double,char,boolean】
    需要注意： == 不可以用来判断【引用类型是否相等】
    int[] arr1 = {1,2,3};
    int[] arr2 = {1,2,3};
    System.out.println(arr1 == arr2);//false
    System.out.println(Arrays.equals(arr1,arr2));//true
    字符串是会出现相等，但是是特殊情况，包装类
   
PS：关系运算符除了，可以判断谁大谁之外，在循环中关系运算符可以作为"范围判断"    

逻辑运算符

组成：  &（与） |（或） ！（非）
PS:重点掌握 &&（短路与） ||（短路或） ！（非）    
    &&和||为什么会成为短路，主要在判断中满足其中一个条件，剩余的条件都不会判断，直接返回表达式的结果
   
    & 和 |  与 && 和 || 有什么区别
    & 和 |将所有的条件都判断完成才会返回最终的结果值，无论是否有条件不成立，依旧会判断
    
例如：
    int a = 1;
    int b = 2;
    a>b & a<b
PS： 逻辑运算符一般是和关系运算符一起使用，组成一个表达式，它说代表的式一个整体，计算结果也是一个整体结果
     逻辑运算符遵守从左向右计算
     先计算 a>b 成立？  --》 1>2 --> false  
     在计算 a<b 成立？  --》 1<2 --> true
     最后计算  false & true --》&原则是之后所有条件都是true才会返回true，否则返回false
     表达式的结果值就是false
     
     a>b | a<b
ps: 逻辑运算符遵守从左向右计算     
     先计算 a>b 成立？  --》 1>2 --> false  
     在计算 a<b 成立？  --》 1<2 --> true
     最后计算  false | true --》|原则是主要有一个条件为true返回结果为true，否则全为false才返回false
     表达式的结果值就是true
    
    
&& 和 ||   
    
例如：
    int a = 1;
    int b = 2;
    a>b && a<b
PS： 逻辑运算符一般是和关系运算符一起使用，组成一个表达式，它说代表的式一个整体，计算结果也是一个整体结果
     逻辑运算符遵守从左向右计算
     先计算 a>b 成立？  --》 1>2 --> false  
     此时会触发短路与的逻辑，只要其中有一个表达式的计算结果false，剩余所有条件都不判断直接返回，只有所有条件都成立，才会返回true。
      最后直接得到表达式的结论 false 剩余a<b不会判断  
     
     a<b || a>b
ps: 逻辑运算符遵守从左向右计算     
     先计算 a<b 成立？  --》 1<2 --> true
     此时会触发短路或的逻辑，只要有一个表达式的值为true，剩余表达式都不判断，直接返回true，只有所有条件为false才会返回false值
      最后直接得到结论 true 剩余 a>b就不判断了
    
结果记录值：
    短路与（&&）
     表达式1  && 表达式2  	结果
      true       true   	true
      true       false  	false
      false		 true       false
      false      false      false
    总结： && 所有条件都成立才得到true否则false 
    短路或(||)
     表达式1  || 表达式2  	结果
      true       true   	true
      true       false  	true
      false		 true       true
      false      false      false
    总结： || 只要有一个条件为true就得到true，否则就是false
    
    
！（非） --》 取其相反值（获取当前表达式对立面的逻辑）
   例如： 
    表达式1的值为true 对其 取非 【false】
    表达式1的值为false 对其 取非 【true】
    判断13大于100
    13>100   --> 等价于 --> !(13<100)【就相当于是当计算即判断 13是否大于100】

练习：使用关系和逻辑表达式来完成下列条件

1.参加少年运动会运动员的年龄在13~17之间

age>=13 && age<=17

2.动物园参观小于12岁，大于65岁的人免票

age<12 ||  age>65

3.年龄不小于18岁可以观影

 age>=18     等价     !(age<18)

4.判断下面条件表达式是true还是false

（100>3） && (‘a’>‘c’)

100 > 3 成立（true）
'a' > 'c' 字符之间比较大小比较的式ASCII码  97 > 99  不成立(false)   
最终结果是false    

(100>3) || (‘a’ >‘c’)

100 > 3 成立（true）
触发短路或的逻辑，只要一个条件为true，剩余条件都不判断，直接返回
最终结果是true

!(100<3)

先判断小括号中的表达式  100<3 成立吗？  得到false
在使用！ 对这个计算记过取值
 ！false   -->  true
最终结果值就是true
上面这个表达式相当于判断 100>3    

5.number等于或大于90，但小于100

number>=90 && number<100

6.ch你不是字符q也不是字符k

ch != 'q' && ch != 'k'

7.number界于1到9之间（包括1但是不包括9），但是不等于5

(numebr>=1 && numebr <9) && number != 5

8.number不在1到9之间

number < 1 || number > 9  等价于  !(number>=1 && number<=9)

位运算符（了解）

ps:Java中位运算符支持7个，将计算的数值转换为二进制进行计算，然后在转换为十进制展示结果

&按位与

计算原则  
1 1 得 1
0 0 得 0 
1 0 得 0
代码中实现一个位运算
System.out.println( 5 & 9);//1
计算逻辑：
    0000 0101  5
    0000 1001  9
&-------------------
    0000 0001  1

|按位或

计算原则  
1 1 得 1
0 0 得 0 
1 0 得 1
代码中实现一个位运算
System.out.println( 5 | 9);//13
计算逻辑：
    0000 0101  5
    0000 1001  9
|-------------------
    0000 1101  13…

^ 按位异或

ps：异或的特点 一个数据对另外一个数据异或两次，该数本身不变

计算原则：
1 1 得 0
1 0 得 1
0 0 得 0
代码中实现一个位运算
System.out.println( 5 ^ 9);//12
计算逻辑：
    0000 0101  5
    0000 1001  9
^ -------------------
    0000 1100  12
    
    
例如：
    int a = 1;
    int b = 2;
  System.out.println( a ^ b ^ b);   // 1
   //第一次
    0001   1
    0010   2
 ^-------------
    0011   3
   
   //第二次
    0011         
    0010
 ^--------------
    0001    1    
  System.out.println( a ^ b ^ a);   // 2

~按位取反

int a = -5
System.out.println(~d)
 		1 000 0101 原
 		1 111 1010 反
 		1 111 1011 补
取反----------------------    
        0 000 0100 4 取反之后的结果

>> 向右位移
System.out.println( 5 >> 2);
最高位是0，左边补0  0000 0101 --》 0000 0001
最高位是1，左边不1    
<< 向左位移
System.out.println( 2 << 2);  
左边的最高位会被丢弃，右边补0    0000 0010   --》 0000 1000
面试题：如何快速算出2的3次方法   
>>> 无符号向右位移

++ – 运算符

PS：无论是++ 还是 - -，计算的变量需要自身进行一次+1 或-1操作

区分一下++和–运算符是出现在变量之前还是之后

如果：++运算符或–运算符出现在变量之前，我们称为 【前++或前–】

特点：需要先对变量自身进行一次+1或-1操作，然后在使用变量参与到其他运算中

例如：
    int i = 1;
    前++  --》  ++i
    前--  --》  --i    

如果：++运算符或–运算符出现在变量之后，我们称为**【后++或后–】**

特点：需要先让变量参与其他运算，然后变量在进行自身+1或-1操作

例如：
	int i = 1;
    后++  --》 i++
    后--  --》 i--    

作业为讲解案例

a=3，b=4；
(1):(a++)/3+(--b)*2-(a--)%6+(b++)*3-(b--) 
 a    4               3
 b            3               4      3
 等式：3/3+3*2-4%6+3*3-4  = 1+6-4+9-4 = 8
 最终a = 3   b = 3    最终结果值： 8 
    
a=3，b=4
(2):(++b)*2-(a--)%4+(a++)*5-(--b)/2+(--a) 
 a            2      3                2
 b   5						  4
 等式：5*2-3%4+2*5-4/2+2 = 17
 最终a =  2  b =  4   最终结果值：  17

 a=3，b=4；
(3):(a--)*6+(b++)/3-(--a)*2-(--b)*2+(++a)
 a    2               1               2
 b            5               4   
 等式：3*6+4/3-1*2-4*2+2= 11
 最终a = 2  b =  3  最终结果值： 11   

扩展:超出存储范围问题

public class Test {
    public static void main(String[] args) {
       //int 类型最大值
        int max = Integer.MAX_VALUE;//存储的就是int类型最大值
        max = max + 1;//让当前整数最大值+1
        System.out.println(max); // 是当前int类型最小值-2147483648
        /*
        存储数据使用补码形式  最高位是符号位 0是整数 1是负数
        0 1111111 11111111 11111111 11111111   int最大值
        0 0000000 00000000 00000000 00000001    1值
      +--------------------------------------------------
        1 0000000 00000000 00000000 00000000    正好是最小值                             
         */

    }
}

Java中的分支

什么是分支？分支可以做什么？

现在我们书写的代码都是从上至下逐行执行，这种方式称为【顺序执行（顺序结构）】

如果当程序出现一个选择问题的时候：

例如：当你编写一个程序时，如果玩家获得1000分，可以让玩家进入第二关卡，否则就在当前关卡进行游戏

这个例子中顺序结构就无法实现，因为有一个条件执行到另外一段代码【编程逻辑】，只要达到1000分

当Java程度中出现选择判断条件的时候，顺序执行无法满足，我们就需要使用到Java中所提供的分支结构

if分支

if单分支

if单分支语法组成

if 是一个关键字
 语法：
    if(选择条件){
     	执行语句   
    }
选择条件可以写什么？--》选择条件是当程序遇到某种判断条件时进行执行判断
                    一般来说选择条件在程序中的表达方式就是一个"表达式"
                    而这个"表达式"一般是由"关系和逻辑"运算符组成式子
                    所以：这个选择条件的到结果只有 true 【成立】 和 false 【不成立】
    
执行语句可以写什么？--》满足选择条件之后，你做的逻辑 【计算，继续判断，循环执行等等】   
    
执行过程： 当程序执行if分支的时候，首先会先判断选择条件是否成立【是否为true】，如果成立，就执行{}执行语句，然后if分支结束，如果选择条件不成立，跳过if分支语句继续向后执行    

基础案例：

输入两个不等数，输出最大值？
    import java.util.Scanner;

/**
 *  if单分支
 */
public class IfDemo {
    public static void main(String[] args) {
         //输入两个不等数，按照从小到大顺序输出
        //1.在控制台上获取数据 Scanner的使用需要在类的最上面导入一个包
        //包的导入需要使用到一个关键字 import
        //java.util.Scanner
        Scanner input = new Scanner(System.in);
        //2.获取两个变量
        System.out.println("请输入第一个数字：");
        int a = input.nextInt();//可以获取控制台上输入的整数
        System.out.println("请输入第二个数字：");
        int b = input.nextInt();

        if(a > b){ //证明 a大 b小
            System.out.println(b + " "+a);
        }
        if(b > a){ //证明 a小 b大
            System.out.println(a+ " "+b);
        }

    }
}

需求: 将a始终表示最小，b始终表示最大，只使用一个if完成

扩展：两个交换

在Java中两个数的交换有3种方式

1.通过算数运算符进行进行来得到交换的方式【这个不要使用局限性太大（只能对数值类型起作用）】
    int a = 1;
    int b = 2;
    int sum = 0;
    //交换 a和b存储的变量值即 a最终得到2  z最终得到1
    sum = a+b; // 1+2 = 3 sum = 3
    a = sum -a;// a = 3-1  a = 2
    b = sum -b;// b = 3-2  b = 1
    
2.使用第三方变量作为中间值，进行交换【开发使用最多（即支持值类型也支持引用类型）】
    int a = 1;
    int b = 2;
    int tmp = 0;//第三方变量
    tmp = a; // tmp 中就会存储a的值 即 tmp = 1
    a = b;   //将b中存储数据存储到a中 即 a = 2
    b = tmp; //将原本a中存储在tmp中值获取出来，存储到b变量中  b = 1

3.异或交换【在笔试中出现最多(开发中存在局限，必须是数字和第一种情况一样)】
异或计算逻辑：  1^1 = 0  1^0=1  0^1= 1 0^0 = 0
    穷举计算
 1^1^1 = 1
 1^1^0 = 0
 1^0^1 = 0
 0^1^1 = 0
 1^0^0 = 1
 0^1^0 = 1
 0^0^1 = 1
 0^0^0 = 0
  推断:任意1或0出现两次，即可以被互相抵消 ，从而可以得到一个结论
       一个数异或同一个数两次，结果还是那个数
  int a = 1;
  int b = 2;
  a = a ^ b 
  0000 0001  1值
  0000 0010  2值
^--------------------
  0000 0011   3   //a中存储的值就是3
  b = b ^ a     
  0000 0010  2值
  0000 0011  3值    
^-------------------
  0000 0001  1  //就相当于将原有a中存储的1值赋值给了b
 a = a ^ b  
   0000 0011 3值
   0000 0001 1值
^-------------------
   0000 0010 2 //就相当于将原有存储在b中2这个是赋值给a

 总结两个数使用异或交换通用公式
  a = a ^ b
  b = b ^ a
  a = a ^ b    
    

修改案例：

import java.util.Scanner;

/**
 *  if单分支
 */
public class IfDemo2 {
    public static void main(String[] args) {
         //输入两个不等数，按照从小到大顺序输出
        //1.在控制台上获取数据 Scanner的使用需要在类的最上面导入一个包
        //包的导入需要使用到一个关键字 import
        //java.util.Scanner
        Scanner input = new Scanner(System.in);
        //2.获取两个变量
        System.out.println("请输入第一个数字：");
        int a = input.nextInt();//可以获取控制台上输入的整数
        System.out.println("请输入第二个数字：");
        int b = input.nextInt();

       // 始终固定a最小 b最大
//        int tmp = 0 ;//三方变量
//        if(a > b){
//            tmp = a;
//            a = b;
//            b = tmp;
//        }
        if(a > b){
            a = a^b;
            b = b^a;
            a = a^b;
        }

        System.out.println(a+ " "+ b);

    }
}

if-else

if-else语法组成

语法：
    if(选择条件){
     	执行语句;   
    }else{
        执行语句；
    }
PS: else 是一个关键字  else 相当于是if选择条件的相反方向
     例子：如果if（1>2） else 就相当于是判断 1<2
         
选择条件可以写什么？--》选择条件是当程序遇到某种判断条件时进行执行判断
                    一般来说选择条件在程序中的表达方式就是一个"表达式"
                    而这个"表达式"一般是由"关系和逻辑"运算符组成式子
                    所以：这个选择条件的到结果只有 true 【成立】 和 false 【不成立】
    
执行语句可以写什么？--》满足选择条件之后，你做的逻辑 【计算，继续判断，循环执行等等】   
    
执行过程：当程序执行到if-else分支的时候，首先会先判断if后面的选择条件，如果选择条件"成立"，那么就执行"if"后面{}里面执行语句，"然后if-else分支结束"，如果if后面选择条件"不成立"，那么就行"else"后面的执行语句，"然后if-else分支结束"

基础案例：

输入一个年份，判断你这个年份是不是闰年？【典型二选一，要是就是， 那么就不是】
import java.util.Scanner;

/**
 * if-else案例
 */
public class IFElseDemo {
    public static void main(String[] args) {
        //获取控制台上输入一个年份
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个年份：");
        int year = input.nextInt();
        //判断闰年【闰年能被4整除，但是不能被100整数 或者 能被400整除】
        if((year%4==0 && year%100!=0) || (year%400 ==0)){
            System.out.println("是闰年："+year);
        }else{ //这个else间接的省略了一个判断条件，就是不是闰年的判断
            System.out.println("不是闰年:"+year);
        }
    }
}
    
    

条件运算符【三目，三元】

组成【？：】

PS：Java中条件运算符，在做计算的时候必须得到返回值，不可以在条件运算符中直接打印

错误写法：
    1 == 1 ? System.out.println(1是等于1的):System.out.println(1不是等于1的);

PS：条件运算符的逻辑和if-else的逻辑类似，基本上if-else语句都可以改为条件运算符的形式

语法：

表达式1 ? 表达式2 : 表达式3;
说明：
 1.表达式1 --》一般是关系或逻辑运算符组成表达式，主要是进行判断得到结果【选择条件】
 2.表达式2 --》即可以是一个变量、常量或另外一个表达式【必须在有值】
              主要作用就是当"表达式1成立"的时候可以得到"表达式2的值”   
 3.表达式3 --》即可以是一个变量、常量或另外一个表达式【必须在有值】
              主要作用就是当"表达式1不成立"的时候可以得到"表达式3的值"  
 执行流程：
    当程序执行到表达式1的时候先判断表达式1的真假【是否成立】，如果表达式1成立，那么就返回表达式2的值作为整个表达式【条件运算符组成的表达式】，条件运算符结束运算。如果表达式1不成立，那么就返回表达式3的值作为整个表达式的值返回，条件运算符结束运算
   

通过条件运算符修改闰年判断

import java.util.Scanner;

/**
 * 修改if-else案例 为条件运算符
 */
public class IFElseDemo2 {
    public static void main(String[] args) {
        //获取控制台上输入一个年份
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个年份：");
        int year = input.nextInt();
        //判断闰年【闰年能被4整除，但是不能被100整数 或者 能被400整除】
        boolean res  = ((year%4==0 && year%100!=0) || (year%400 ==0)) ? true : false;
        System.out.println(year+"是否是闰年？"+res);

    }
}

if-else if

PS: if-else if只要有一个条件满足，剩余的条件判断都不会执行

语法：

if(选择条件1){
	执行语句1；    
}else if(选择条件2){
    执行语句2；
}else if(选择条件3){
 	执行语句3；   
}else{
    最后的执行语句；   
}

说明： else if 语句理论中是可以无限的，在实际开发要写多少个 else if 决定权在于有多少个条件要判断
      最后的 else 相当于是 else if 最后一种情况，上面所有条件都不成立，才会执行 else
      这里的 else 相当于省略一个 else if 条件，理论中是可以不写，需要将所有条件都书写，可以不写 else
      实际开发中建议大家写 else ，所有条件都写了，剩下的最后一种情况就使用 else 代替即可  
          
选择条件可以写什么？--》选择条件是当程序遇到某种判断条件时进行执行判断
                    一般来说选择条件在程序中的表达方式就是一个"表达式"
                    而这个"表达式"一般是由"关系和逻辑"运算符组成式子
                    所以：这个选择条件的到结果只有 true 【成立】 和 false 【不成立】
    
执行语句可以写什么？--》满足选择条件之后，你做的逻辑 【计算，继续判断，循环执行等等】    
          
执行流程: 当程序执行到 if-else if 的时候，首先会先判断if后面条件语句 ，如果条件成立，那么就执行对应{}中执行语句，"然后if-else if结束"，如果选择条件不成立，那么就执行后学 else if 中选择条件判断，如果 else if 中条件没有满足，就执行最后else， 只要有一个条件满足，就执行对应的执行语句，"无论执行哪一个步骤，只要有一个满足，if-else if就结束"          

基础案例：

输入一个成绩，输出对应的结果值
A ，B ，C ，D ，E 五个等级对应 90以上，80~89,70~79,60~69，60以下
import java.util.Scanner;

/**
 * if-else if 案例
 */
public class IFElseIfDemo {
    public static void main(String[] args) {
        //1.获取用户输入
        Scanner input = new Scanner(System.in);
        //2.获取分数
        System.out.println("请输入一个分数：");
        int fs = input.nextInt();
        /*
        对当前代码中判断条件进行了修改，原有是fs>=80 && fs<=89 修改为了fs>=80
        这样做是可以的原因在于，当输入的分数是90~100之间的时候，会被第一个if条件所判断，进入不了后续的条件
        当输入的分数是85的时候 第一个条件是不满足的因为不在90~100之间，判断第二个条件而第二个条件是满足的，原因是
        85是大于80，所以条件成立会打印B这个值。
        综上所述：现在这个条件判断，是一个“联级判断”，所有的条件之间是彼此呼应即，刚刚的条件，就是一个典型体现
                 第二个条件的上限是第一个条件限制，第二个条件的下限是写出来的，所以条件之间是“联级”关系
        PS：这个判断有一个问题，必须是顺序书写，不能更改顺序，否则会问题
         */
        if (fs >= 90 && fs<=100){
            System.out.println("A");
        }else if(fs>=80){
            System.out.println("B");
        }else if(fs>=70){
            System.out.println("C");
        }else if(fs>=60){
            System.out.println("D");
        }//如果在这里补全最后一个else if情况，else就可以不写
         //如果直接写else 就相当于是 简写了最后一种情况， 还是建议写else
        else{ //就相当于低于60分的人
            System.out.println("E");
        }
    }
}

    

完整总结：

1.如果是一个条件判断，建议使用if单分支

2.如果是一个“非黑即白”判断【如果…那么】，建议使用if-else分支

3.如果是一个多个条件判断【只需要判断一个条件满足】，建议使用if-else if

如果多个条件满足，建议使用if单分支结合if-else

4.所有if分支的选择条件都是一个boolean类型表达式

5.Java程序的组成是【顺序，分支，？】

switch-case分支

PS：swithc-case是Java中另外一种分支，它和if-else if很类似

语法：

关键字： switch  case  break  default
 
switch(常量){
	case 常量1：执行语句; break;
    case 常量2：执行语句; break;
    case 常量3：执行语句; break;
    case 常量4：执行语句; break;
    default : 执行语句; break;
}
PS: 在Java中分支语句只有switch可以使用break关键字

 常量值是一个"泛指",指switch后面可以添加【整数（int）、字符、字符串、枚举、算数运算符组成的表达式】
 特别注意：绝对不允许方boolean表达式
 case 常量值是 和 switch 后面常量值进行匹配的 case 后面常量值 不能重复
 
执行流程：
    首先程序会先执行到switch语句的位置，计算小括号中的常量值，计算完毕之后会和case后面常量值进行匹配，如果匹配成功，就执行对应case后面执行语句，然后执行break，"switch-case分支结束",如果，所有的case常量值都匹配不成功，那么就执行default后面的执行语句，然后"switch-case分支结束"
 
PS：switch-case语句支持字符串是从JDK7开始，就是因为switch-case支持了字符串，所以枚举的作用就大大减少     

标准switch

需求：输入1~7之间数字，输出对应的日期

import java.util.Scanner;

/**
 * 标准版本switch-case
 */
public class SwitchCaseDemo {
    public static void main(String[] args) {
        //1.获取用户输入
        Scanner input = new Scanner(System.in);
        System.out.println("请输入1~7之间的数据：");
        //2.获取数据
        int day = input.nextInt();
        switch (day){
            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;
            default:
                System.out.println("不好意思没有这个星期！！！！");
                break;
        }
    }
}

贯穿switch

PS：在case语句后面不添加break，此时case会继续向下执行**【不会管后续case的条件】**，直到碰到break或执行到末尾default，这个时候才会停止

需求:输出对应月份，输出对应月份的天数【不考虑闰年问题】

import java.util.Scanner;

/**
 * 贯穿版本switch-case
 */
public class SwitchCaseDemo2 {
    public static void main(String[] args) {
        //1.获取用户输入
        Scanner input = new Scanner(System.in);
        System.out.println("请输入1~12之间的数据：");
        //2.获取数据
        int month = input.nextInt();
        /*
        如果这个需求使用标准的switch-case那么就需要写12case语句
        就可以利用switch的贯穿特性，来完成一个需求
        2月份是最特殊的 28
        1 3 5 7 8 10 12 月份是31天
        4 6 9 11 月份是30天
         */
        switch (month){
            case 2:
                System.out.println("28天");
                break;
              //这里一旦法生贯穿，不管后续什么条件只做一件事情，继续向下执行直到遇到break或程序结束为止
             //贯穿的出现，就是case后面不使用break就会出现贯穿
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println("30天");
                break;
            default:
                System.out.println("31天");
                break;
        }
    }
}

总结：

当判断条件是一个值的时候【整数，字符串，字符或枚举】，建议使用switch