主题：课件4下载——Java的控制语句之一

Java的控制语句

任何程序逻辑都含有三种类型的语句，分别为顺序语句、分支语句和循环语句，通过这三种语句可以表达任何程序逻辑。

1 顺序语句
所谓顺序语句就是一行一行的Java语句，所有的代码在运行期间都会被而且只会被执行一遍。
注意所有的语句后面都要以分号结尾，在格式上要有详细的注释，合理的缩进结构等。

2 分支语句
所谓分支语句是指在代码运行期间，按照条件的真假，只有此语句块中的一部分代码才会被执行到，而且只会被执行一遍。
常见的分支语句结构有if，if else，else if和switch等。

2、1 if语句
if语句是最为简单的一种，只能判断一种情况。
如判断成绩是否为90以上（含90分），如为真，屏幕显示A
public class exec
{      
    public static void main(String args[])
    {
        int grade=95;
                
        if(grade>=90)
        {
                System.out.println("A");
        }                      
    }
}
输出为A

注意此时可以简写为：
public class exec
{      
    public static void main(String args[])
    {
        int grade=95;
                
        if(grade>=90)
                System.out.println("A");
    }
}

提示：if语句中只有一条子语句才能省略花括号

2、2 if else语句
if else语句可以用来判断两者情况。
如判断成绩是否为90以上（含90分），如为真，屏幕显示A；否则屏幕显示B。
public class exec
{      
    public static void main(String args[])
    {
        int grade=95;
                
                if(grade>=90)
                {
                        System.out.println("A");
                }              
                else
                {
                        System.out.println("B");
                }      
    }
}
输出为A

注意此时可以简写为：
public class exec
{      
    public static void main(String args[])
    {
        int grade=95;
                
        if(grade>=90)
                System.out.println("A");
        else
                System.out.println("B");
    }
}

上述程序功能等价于下面的程序功能：
public class exec
{      
    public static void main(String args[])
    {
        int grade=95;
                
                if(grade>=90)
                {
                        System.out.println("A");
                }              
                if(grade<90)
                {
                        System.out.println("B");
                }      
    }
}

但是显然前者较好，因为后者程序一定要进行两次判断，也就是说，即使第一个条件满足了，程序也要进行第二个条件的判断；而前者不会，一旦判断出条件的真假，就没有必要在作其他的判断了。

2、3 else if
下例为判断成绩的等级，规则为
90——100：A
80——89：B
70——79：C
0——69：D

直接使用if语句的表达方式效率不高，会导致程序即使在前面条件判断为真的情况下，还会继续判断其他的条件（显然并无必要）
public class exec
{      
    public static void main(String args[])
    {
        int grade=85;
                
                if(grade>=90 && grade<=100)
                        System.out.println("A");
                        
                if(grade>=80 && grade<90)
                        System.out.println("B");
                
                if(grade>=70 && grade<80)
                        System.out.println("C");
                
                if(grade<70 && grade>=0)
                        System.out.println("D");
                
                if(grade<0 || grade>100)
                        System.out.println("Error in Grade!");
        }
}

对于判断条件多于两个的情况，可以考虑使用嵌套分支判断语句（但是写法相当复杂）。
public class exec
{      
    public static void main(String args[])
    {
        int grade=85;
                
                if(grade>=90 && grade<=100)
                        System.out.println("A");
                else
                        if(grade>=80 && grade<90)
                                System.out.println("B");
                        else
                                if(grade>=70 && grade<80)
                                        System.out.println("C");
                                else
                                        if(grade<70 && grade>=0)
                                                System.out.println("D");
                                        else
                                                System.out.println("Error in Grade!");
        }
}

所以有效的表达方式应该是多重分支语句，它可以被理解为嵌套方式的一种简化。
public class exec
{      
    public static void main(String args[])
    {
        int grade=85;
                
                if(grade>=90 && grade<=100)
                        System.out.println("A");
                else if(grade>=80 && grade<90)
                        System.out.println("B");
                else if(grade>=70 && grade<80)
                        System.out.println("C");
                else if(grade<70 && grade>=0)
                        System.out.println("D");
                else
                        System.out.println("Error in Grade!");
        }
}

注意：良好的程序嵌套结构和缩进结构有助于写出正确易读的程序，反之容易产生难以发现的逻辑错误。

下面程序功能为判断成绩是否及格，请问运行情况如何？
public class exec
{      
    public static void main(String args[])
    {
        int grade=50;
                
        if(grade>=60)
                if(grade<=100)
                        System.out.println("及格");
        else
                System.out.println("不及格");
    }
}

提示：程序没有语法错误，但是没有输出，原因在于else子句其实和第二个if配套，虽然感觉和第一个if对齐（编译时会忽略所有的程序缩进空格）

所以上述写法真正意思是：
public class exec
{      
    public static void main(String args[])
    {
        int grade=50;
                
        if(grade>=60)
                if(grade<=100)
                        System.out.println("及格");
                else
                        System.out.println("不及格");
    }
}

要想实现最初的目的，真正的写法应该是：
public class exec
{      
    public static void main(String args[])
    {
        int grade=50;
                
        if(grade>=60)
        {
                if(grade<=100)
                        System.out.println("及格");
        }
        else
                System.out.println("不及格");
    }
}

2、4 switch语句
它是典型的多重分支判断语句，如：
public class exec
{      
    public static void main(String args[])
    {
        int i=1;
        switch(i)
        {
                case 0:System.out.println("A");break;
                case 1:System.out.println("B");break;
                case 2:System.out.println("C");break;
                default:System.out.println("Other!");break;
        }              
    }
}
输出为B

注意：如果不使用break，会产生“穿透”效果，如
public class exec
{      
    public static void main(String args[])
    {
        int i=1;
        switch(i)
        {
                case 0:System.out.println("A");
                case 1:System.out.println("B");
                case 2:System.out.println("C");
        }              
    }
}
输出为
B
C

和上述的else if多重分支判断语句相比，switch只能判断点的取值，也就是说，不能判断范围，所以上述判断成绩等级的程序不能直接写为：
public class exec
{      
    public static void main(String args[])
    {
        int grade=85;
        switch(grade)
        {
                case grade>=90 && grade<=100:System.out.println("A");break;
                case grade>=80 && grade<90:System.out.println("B");break;
                case grade>=70 && grade<80:System.out.println("C");break;
                case grade>=0 && grade<70:System.out.println("D");break;
                default:System.out.println("Error in Grade!");break;
        }              
        }
}
错误为：incompatible types，found : boolean，required : int

但是可以巧妙的使用取十位数字来进行判断：
public class exec
{      
    public static void main(String args[])
    {
        int grade=85;
        switch(grade/10)
        {
                case 10:                        
                case 9:
                        System.out.println("A");break;
                case 8:
                        System.out.println("B");break;
                case 7:
                        System.out.println("C");break;
                case 6:
                case 5:
                case 4:
                case 3:
                case 2:
                case 1:
                case 0:
                        System.out.println("D");break;
                default:
                        System.out.println("Error in Grade!");break;                    
                }
        }
}

这个程序有个小小的bug，你能发现吗？
提示：设置grade为-5看看输出是什么？为什么？

所以，应该重新设计程序：
public class exec
{      
    public static void main(String args[])
    {
        int grade=85;
        
        //check the grade
        if(grade<0 || grade>100)
        {
                System.out.println("Error in Grade!");
                return;//exit the program
        }
        
        //process the valid grade
        switch(grade/10)
        {
                case 10:                        
                case 9:
                        System.out.println("A");break;
                case 8:
                                System.out.println("B");break;
                        case 7:
                                System.out.println("C");break;
                        default:
                                System.out.println("D");break;                  
                }
        }
}

另外，还要注意switch不能判断浮点型数据，如
public class exec
{      
    public static void main(String args[])
    {
        double i=1;
        switch(i)
        {
                case 0:System.out.println("A");break;
                case 1:System.out.println("B");break;
                case 2:System.out.println("C");break;
                default:System.out.println("Other!");break;
        }              
    }
}
程序编译报错：possible loss of precision
原因在于浮点型数据的存储值并非是确定的，总是存在精度上的误差，如1.00000000也可以保存为0.99999999，所以，不能直接判断两者是否相等，只能通过相减的差值是否位于一个较小的范围内来判断，所以一般使用else if更为合适，如
public class exec
{      
    public static void main(String args[])
    {
        double i=1;
        
        if(Math.abs(i-0)<0.0001)
                System.out.println("A");
        else if(Math.abs(i-1)<0.0001)
                System.out.println("B");
        else if(Math.abs(i-2)<0.0001)
                System.out.println("C");
        else    
                        System.out.println("Other!");  
        }      
}