首先我们来看前三者的使用区别
 
1. if型
 
结构是:
 
if(某个条件)
	语句;
 
使用场景:
 当满足这个条件时,执行某个操作,而不满足该条件时,什么都不做.在这种情况下就可以使用这种结构
 
2. if else型
 
if(某个条件)
	语句1;
else
	语句2;
 
使用场景:
 当满足这个条件时,执行某个操作,当不满足这个条件时,执行另一个操作(和if型区别是如果不满足条件一个是执行另一个操作,而一个是什么都不做)
 
3. if else if else型
 
if(条件1)
	语句1;
else if(条件2)
	语句2;
else if(条件3)
	语句3;
	.
	.
	.
else
	语句4;
 
1.使用场景:
 这种形式的if语句,最终只有一个出口.即当满足条件1时,执行语句1.当不满足条件1时,往下走,判断是否满足条件2,如果还是不满足,则继续往下走,一直走到else语句,说明之前的条件都不满足,最终执行语句4;
 这个和之前两个的区别是:它存在了多种情况的分析,而之前两个仅仅只有一种情况的分析.
 
2.if elseif else 与if 嵌套的区别:
 if套if,是当外面条件不满足时,里面的if不会执行
 而if else if else,是当第一个条件不满足时,判断第二个条件
 
最后我们来看看多个if的类型
 
if(条件1)
	语句1;
if(条件2)
	语句2;
if(条件3)
	语句3;
 
解释一下:有没有发现特别像if else if else型,但是二者是有区别的.
 分析一下多个if:当满足条件1时,执行语句1.当不满足条件1时,往下走,判断条件2,如果还是不满足,再判断条件3.这么看好像和if else if else型没什么区别.
 我们看个例子就明白了
 
多个if型:

int a=0;
if(a==0){
	a++;
	printf("aaa");
}      
if(a==1)
	printf("bbb");
if(a==2)
	printf("ccc");   

最终输出:aaabbb,在多个if语句中,所有的if都会进行判断,无论是否满足情况.所以在满足a==0时,执行了a++,a就变成了1,当进行a==1判断时,也符合,故也执行了printf("bbb")
-------------------------------------------------
if else if else型:

int a=0;
if(a==0){
	a++;
	printf("aaa");
}      
else if(a==1)
	printf("bbb");
else
	printf("ccc");   

最终只输出了aaa.在if else if else中,只要有一个条件满足,则其余条件不用判断,直接跳过即可,所以a++,a=1之后不会去判断else if中的a==1,所以也就不会执行printf("bbb")

在Java中多个 if-else 之间的执行顺序有什么区别呢？
 
对于 if-else 语句，它是 单条件双分支语句，即程序的执行流程是根据 一个条件来控制的；
 
如下代码演示了存在多个 if - else 时的执行顺序：
 
                int test11 = 2;
		if (test11 > 1) {    // if语句判断
			int test21 = 10;
			test11 = test21;
			System.out.println(test11); // if表达式的值为true，则输出test1为10
		}else{
			int test31 = 100;
			test11 = test31;
			System.out.println(test11); // if表达式的值为false，则输出test1为100
		}
		if (test11 < 1) {    // if语句判断
			int test21 = 10;
			test11 = test21;
			System.out.println(test11); // if表达式的值为true，则输出test1为10
		}else{
			int test31 = 100;
			test11 = test31;
			System.out.println(test11); // if表达式的值为false，则输出test1为100
		}
 
一、在代码中，存在两个 if-else 语句 ，程序执行时他们相互之间是独立的，互不干扰的；
 
二、这两个 if - else 执行顺序为：
 
1、先执行第一个 if - else 语句中的 if ( test11 > 1 ) ，当表达式 test11 > 1 为 true 时，则执行其 { } 里面的若干语句，在这里是执行三条语句；当执行完 { } 中的三条语句后，就结束第一个 if - else 语句了 ， else {} 部分是不会再执行了，即：
 
else{
             int test31 = 100;
             test11 = test31;
             System.out.println(test11); // if表达式的值为false，则输出test1为100
         }
 
 是不再执行的；反之，当表达式 test11 > 1 为 false 时 ，则不会执行其 { } 里面的三条语句 ，而是执行 else 后面的 { } 中三条语句 ，执行完三条语句后，就结束第一个 if - else 语句了 ；
 
2、当第一个 if - else 结束后，执行顺序就到 第二个 if - else 语句，和第一个 if - else 一样，先判断语句 if (test11 < 1) 中表达式的值，当表达式 test11 < 1 为 true 时，则执行其 { } 里面的若干语句，并结束第二个 if - else 语句 ，否则执行 else 后面的 { } 中的语句，并结束第二个 if - else 语句；
 
3、以上代码演示最终输出为：10  100 ；
 
4、if - else 总结：对于 if - else 语句 就是 ，先判断表达式的值，为true则执行其 { } 中若干语句，并结束语句，为false则执行其 else 后面的 { }中的语句，并结束语句；
 
再次强调：
 
对于 多个 if - else 语句，程序执行时是从第一个 if - else 开始判断的，只有当执行完第一个 if - else ，程序才会继续往下执行第二个，第三个，第四个 if - else 语句，而且每个 if - else 语句之间是独立的，互不干扰的，你执行你的 if - else ，我执行我的 if - else ；
 

在Java中 if-else 与 if-else if-else之间不同执行顺序：
 
一、首先要了解 if - else 与 if - else if - else 之间的本质是不一样的：
 
1、if - else 是 单条件双分支 语句； if - else if - else  是 多条件分支 语句 ；
 
if - else 单条件双分支 语句是：
 
一个条件控制两个分支语句执行顺序，当条件为 true 则执行其对应的一个分支语句，而另外一个分支就不再执行了，当条件为 false 则执行其对应的一个分支语句，而另外一个分支也不会再执行了；
 
if - else if - else 多条件分支 语句是：
 
语句中有多个条件，每一个条件控制自己一个分支语句，语句执行时，先从第一个 if ( ) 中的表达式开始判断，当表达式中值为 true 则执行该 { } 中若干语句，并结束当前整个 if - else if - else ，也就是后面的 else if - else 都不会再继续判断和执行了；
当第一个 if ( ) 中的表达式的值为false时，则往下对 else if 进行判断，一直到多个条件中有表达式的值为true，才结束语句；
若多个条件都为false时，则执行最后 else 后面 { } 中的若干语句，并结束当前整个 if - else if - else ；
如下代码进行演示：
代码中每个 if () 中表达式的值都是 false ，所以最后只执行 else {} 中的若干语句，并结束当前语句，程序输出为 100000 ；
                int test1 = 10 ;
		if(test1<1){
			test1 = 100;
			System.out.println(test1);  // 当表达式 test<1 为true，则输出 test1 的值为100
		}else if(test1<2){
			test1 = 1000;
			System.out.println(test1);  // 当表达式 test<2 为true，则输出 test1 的值为 1000
		}else{
			test1 = 100000;
			System.out.println(test1);  
// 当以上表达式都为false时，则输出 test1 的值为 100000，并结束该if-else if-else语句
		}
 

那么 if-else 与 if-else if-else之间不同执行顺序是：
 
对于 if - else 语句，系统程序只会进行一次表达式的判断，当表达式的值为 true 则执行其 { } 中的若干语句，并结束当前整个语句，后面的 else 不再执行了；若表达式的值为 false 则执行其 else { } 中的若干语句，并结束当前整个语句；
对于 if - else if - else 语句，系统程序会进行多次表达式的判断，直到其中有一个表达式的值为 true ，才会执行其对应的若干语句，并结束当前整个语句；若全部表达式的值都为 false 时，则执行其最后 else { } 中的若干语句，并结束当前整个语句；

需要注意的是：有多个 else if 语句的情况下，如 if - else if - else if - else if - else ：
 
要是 if 中表达式为  false ，下面三个 else if 的表达式的值都是 true 那要怎么执行呢？
 
其实很简单，当 三个 else if 的表达式的值都是 true 时，系统程序只会执行第一个 else if 中表达式的值为true的若干语句，并结束当前整个语句，而后面两个 else if 是不会被执行的； 如下代码进行演示：
 
                int test1 = 10 ;
		if(test1<1){
			test1 = 100;
			System.out.println(test1);  // 当表达式 test<1 为true，则输出 test1 的值为100
		}else if(test1>2){
			test1 = 1000;
			System.out.println(test1);  // 当表达式 test<2 为true，则输出 test1 的值为 1000
		}else if(test1>3){
			test1 = 10000;
			System.out.println(test1);  // 当表达式 test<3 为true，则输出 test1 的值为 10000
		}else if(test1>4){
			test1 = 100000;
			System.out.println(test1);  // 当表达式 test<3 为true，则输出 test1 的值为 100000
		}else{
			test1 = 0;
			System.out.println(0);  // 当以上表达式都为false时，则输出 test1 的值为 0，并结束当前整个语句
		}
 
在代码中，test1 > 2 , test1 > 3 , test1 > 4 都是为true的，但是程序只会执行第一个表达式 test1 > 2 的若干语句，并结束整个语句了，后面的 test1 > 3 , test1 > 4 都不会在判断和执行了；
 

以下单独对 if 语句、if else语句、if - else if - else 语句、switch开关语句进行逐一分析：
 
一、if语句是单条件单分支语句，根据一个条件来控制程序执行的流程；
 
1、if语句的语法格式：
 
if(表达式){
  若干语句
}
 
2、if语句中表达式的值必须是boolean类型的，当值为 true 时，则执行 {} 中的 若干语句 ；当值为 false 时则结束当前 if 语句；
 
以下代码进行演示： 表达式 test>1 为真，所以执行 {} 中的三条语句，最后结果输出 100 ；
 
                int test = 10 ;
		if(test>1){                  //if语句判断
			int tests = 100 ; 
			test = tests ;
			System.out.println(test);    //输出test为100
		}
 
3、if语句中，当 {} 中的语句只有一条时，可以省略 {} , 但是为了增强代码的可读性，建议大家不要省略；如下演示：
 
        int test = 10 , tests = 100 ;                
        if(test>1){
	   System.out.println(test);  // test>1为真，输出test
	}
        if(tests<1)
           tests = test ;
	System.out.println(tests); // tests<1为假，则不进行tests = test ;语句，输出tests为100
 
二、if-else语句是单条件双分支语句，与if语句一样根据一个条件来控制程序执行的流程；
 
1、if-else语句的语法格式：
 
if(表达式){
  若干语句
}else{
  若干语句
}
 
2、if-else语句中表达式的值必须是boolean类型的，当值为 true 时，则执行紧跟 () 后面的 {} 中的若干语句 ；当值为 false 时则执行紧跟 关键字else 后面的 {} 中的若干语句 ；
 
以下代码进行演示： 表达式 test > 1 为真，所以执行紧跟 () 后面的 {} 中的语句，最后结果输出 10 ；
 
                int test1 = 2;
		if (test1 > 1) {    // if语句判断
			int test2 = 10;
			test1 = test2;
			System.out.println(test1); // if表达式的值为true，则输出test1为10
		}else{
			int test3 = 100;
			test1 = test3;
			System.out.println(test1); // if表达式的值为false，则输出test1为100
		} 
 
3、if-else语句中，当 {} 中的语句只有一条时，可以省略 {} , 但是为了增强代码的可读性，建议大家不要省略；如下演示：
 
        int test1 = 2;
	if (test1 > 1)     // if语句判断
	    test1 = 10;    // if表达式的值为true，则输出test1为10
	else
	    test1 = 100;   // if表达式的值为false，则输出test1为100
	System.out.println(test1); // 此输出语句，不属于上面的 if-else 语句当中 ; 用于输出test1的值
 
特别注意：以下代码是错误的，报错：Syntax error on token "else", delete this token
 
        int test1 = 2;
	if (test1 > 1)     // if语句判断
	    test1 = 10;
	    System.out.println(test1); // if表达式的值为true，则输出test1为10
	else
	    test1 = 100;
	    System.out.println(test1); // 此输出语句，不属于上面的 if-else 语句当中 ; 用于输出test1的值
 
因为：该 if-else 语句中，紧跟 () 后面的语句已经不止一条了，所以程序报错，对于else后面的 方法调用语句 System.out.println(test1) ;  是不属于该 if-else 语句中的，程序通过；
 
解决：去掉 test1 = 10 ; 或者 方法调用语句 System.out.println(test1) ;  即可
 
三、if - else if - else 语句是多条件分支语句，即多个条件来控制程序执行的流程；
 
1、if - else if - else 语句的语法格式：
 
if(表达式){
  若干语句
}else if(表达式){
  若干语句
}else if(表达式){
  若干语句
}
.
.
.
else{
  若干语句
}

 
2、if - else if - else 语句中每个 if 后面中表达式的值必须是boolean类型的，当值为 true 时，则执行紧跟该if的 () 后面的 {} 中的若干语句 ；当值为 false 时则继续判断下一个 else if 的 () 中表达式的值，以此类推，直到结束该  if - else if - else 语句 ；
 
以下代码进行演示： 当每个if后面的表达式都为 false 时，则执行最后 else 中的若干语句，最后输出test1为 100000 ；
 
                int test1 = 10 ;
		if(test1<1){
			test1 = 100;
			System.out.println(test1);  // 当表达式 test<1 为true，则输出 test1 的值为 100
		}else if(test1<2){
			test1 = 1000;
			System.out.println(test1);  // 当表达式 test<2 为true，则输出 test1 的值为 1000
		}else if(test1<3){
			test1 = 10000;
			System.out.println(test1);  // 当表达式 test<3 为true，则输出 test1 的值为 10000
		}else{
			test1 = 100000;
			System.out.println(test1);  
// 当以上表达式都为false时，则输出 test1 的值为 100000，并结束该if-else if-else语句
		}
 
3、if - else if - else 语句中，当每个 if 后面 {} 中的语句只有一条时，可以省略 {} , 但是为了增强代码的可读性，建议大家不要省略；和以上 if 语句、if - else 语句 是一样的；
 
4、需要注意的是，对于 if - else if - else 语句中没有最后的 else 且 每个if 后面的表达式都为 false 时，则结束当前的 if - else if - else 语句；
 
四、switch 开关语句是单条件多分支语句；
 
1、switch 语句的语法格式：其中 break 是可选的，用于结束当前 switch 开关语句；
 
switch(表达式){
  case 常量值1: 若干语句 break;
  case 常量值2: 若干语句 break;
  case 常量值3: 若干语句 break;
  ...
  case 常量值n: 若干语句 break;
  default:
         若干语句
}
 
2、switch 语句的执行流程：
 
switch首先判断表达式的值，要是表达式中的值 与 case 后面的常量值相等，就执行该 case 里的若干语句直到遇见break语句为止；
若执行该 case 里的若干语句没有break语句时，则程序不止执行该 case 里的若干语句，还会继续执行后继的 case 里的若干语句，直到遇见 break 语句 ；
若 switch 语句中 表达式的值 与 属于 case 后面的常量值都不相等，则执行 default 后面的若干语句 ；其中 default 是可以不要的；
若 switch 语句中 表达式的值 与 属于 case 后面的常量值都不相等，并且没有 default 时，该 switch 语句不执行任何操作；
如下演示：因为 case 1: 后面没有 break 语句，所以会继续执行后继的 case 里的若干语句，直到遇见break语句，结果输出为 1 2 11 ；
                int test = 1 ;
		switch(test){
		 case 1: test = 1 ;System.out.println(test); 
		 case 2: test = 2 ;System.out.println(test); 
		 case 11: test = 11 ;System.out.println(test); break;
                 case 12: test = 12 ;System.out.println(test); 
		 default: test = 0 ;
		}
 
3、switch 语句中 () 里 “ 表达式 ” 的值可以是byte、short、int、char类型的值；如下演示：
 
                int test = 11 ;
		double testd = 100 ;
		switch(test){
		 case 1: test = 1 ;System.out.println(test); break; 
		 case 2: test = 2 ;System.out.println(test); break; 
		 case 11: test = 11 ;System.out.println(test); break; 
		 default: test = 0 ;
		}
 
需要注意的是，switch 中 () 里 “ 表达式 ” 的值不可以是 long、float、double 类型的值，否则报错：
 
Cannot switch on a value of type double. Only convertible int values, strings or enum variables are permitted
 
4、switch 语句中 case 常量值: 中常量值也可以是byte、short、int、char类型的值，而且是互不相同的；如下演示：
 
                int test = 1 ;
		switch(test){
		 case 1: test = 1 ;System.out.println(test); 
		 case 2: test = 2 ;System.out.println(test); 
		 case 'a': test = 11 ;System.out.println(test); break; 
		 case (byte)10: test = 12 ;System.out.println(test); 
		 default: test = 0 ;
		}
 
总结 if、if-else、if-else if-else语句 与 switch 开关语句 之间的异同点：
 
1、if、if-else、if- else if- else 语句 之间的共同点是程序根据 一个条件执行一个分支操作，而不是选择执行多个分支操作；
 
2、与上面 if、if-else、if- else if- else 语句 不同的是， 在switch语句中，可以通过合理地使用 break 语句，达到一个条件执行一个分支的操作（即只执行一个case后面的若干语句），也可以达到多个操作的操作（即执行多个case后面的若干语句，如以上第2点的代码演示）；
 
代码练习： 使用switch语句实现 判断用户从键盘输入一个整数是否为中奖号码；
 
      System.out.println("请输入一个整数进行抽奖，并按回车键(Enter)结束输入：");
		Scanner inputs = new Scanner(System.in);
		int number = inputs.nextInt();
		switch(number){
		 case 11: System.out.println("恭喜中特等奖！中奖号码为："+number);break;
		 case 12: 
		 case 13: System.out.println("恭喜中一等奖！中奖号码为："+number);break;
		 case 14:
		 case 15:
		 case 19: System.out.println("恭喜中二等奖！中奖号码为："+number);break;
		 case 22:
                 case 23:
                 case 24:
		 case 25: System.out.println("恭喜中三等奖！中奖号码为："+number);break;
		 default: System.out.println("很遗憾"+number+"没有中奖");
		}
 
其中：特等奖为一名，一等奖为两名，二等奖为三名，三等奖为四名；
 
 
 
 
 
 

Shell if else语句
 
if 语句通过关系运算符判断表达式的真假来决定执行哪个分支。Shell 有三种 if ... else 语句：
 
if ... fi 语句；
if ... else ... fi 语句；
if ... elif ... else ... fi 语句。
1) if ... else 语句
 
if ... else 语句的语法：
 
if [ expression ]
then
   Statement(s) to be executed if expression is true
fi
 
如果 expression 返回 true，then 后边的语句将会被执行；如果返回 false，不会执行任何语句。

 最后必须以 fi 来结尾闭合 if，fi 就是 if 倒过来拼写，后面也会遇见。

 注意：expression 和方括号([ ])之间必须有空格，否则会有语法错误。

 举个例子：
 
#!/bin/sh
 
a=10
b=20
 
if [ $a == $b ]
then
echo "a is equal to b"
fi
 
if [ $a != $b ]
then
echo "a is not equal to b"
fi
运行结果：
 
a is not equal to b
 
2) if ... else ... fi 语句
 
if ... else ... fi 语句的语法：
 
if [ expression ]
then
   Statement(s) to be executed if expression is true
else
   Statement(s) to be executed if expression is not true
fi
 
如果 expression 返回 true，那么 then 后边的语句将会被执行；否则，执行 else 后边的语句。

 举个例子：
 
#!/bin/sh
 
a=10
b=20
 
if [ $a == $b ]
then
echo "a is equal to b"
else
echo "a is not equal to b"
fi
执行结果：
 
a is not equal to b
 
3) if ... elif ... fi 语句
 
if ... elif ... fi 语句可以对多个条件进行判断，语法为：
 
if [ expression 1 ]
then
   Statement(s) to be executed if expression 1 is true
elif [ expression 2 ]
then
   Statement(s) to be executed if expression 2 is true
elif [ expression 3 ]
then
   Statement(s) to be executed if expression 3 is true
else
   Statement(s) to be executed if no expression is true
fi
 
哪一个 expression 的值为 true，就执行哪个 expression 后面的语句；如果都为 false，那么不执行任何语句。

 举个例子：
 
#!/bin/sh
 
a=10
b=20
 
if [ $a == $b ]
then
echo "a is equal to b"
elif [ $a -gt $b ]
then
echo "a is greater than b"
elif [ $a -lt $b ]
then
echo "a is less than b"
else
echo "None of the condition met"
fi
运行结果：
 
a is less than b
 

 if ... else 语句也可以写成一行，以命令的方式来运行，像这样：
 
if test $[2*3] -eq $[1+5]; then echo 'The two numbers are equal!'; fi;

 if ... else 语句也经常与 test 命令结合使用，如下所示：
 
num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
then
echo 'The two numbers are equal!'
else
echo 'The two numbers are not equal!'
fi
输出：
 
The two numbers are equal!
 
test 命令用于检查某个条件是否成立，与方括号([ ])类似。

答：必须。
 
使用idea开发时，使用elseif作为结束，结果代码爆红，添加上else之后，红警解除。