动力节点——语句（三）——1

一： 语句结构概述

1，语句：程序是由语句组成的

2，语句结构：

if（重点）

        if结构  1

        if结构  2        if  else

        if结构  3        if         else if         else  

        if嵌套代码结构

switch（喜欢在笔试出题）

        for（重点）

        while（重点）

        do............while（喜欢在笔试出题）

二：语句——if结构1

1，语法：

if（判断条件）{

        语句体

}

2，语法执行流程

A：先执行判定条件，判定条件的结果肯定是一个布尔值。

B：如果在A中是true，则执行语句体，执行后if结构结束，程序继续按照顺序结构往下执行。

C：如果在B中是false，则if结构结束，程序继续按照顺序结构往下执行。

eg：

class  IfDemo{

        public  static void main（String[]  args）{

                //定义 x 一个变量赋值为11及初始化

                int  x=11;

                //如果  x 的值大于10，则输出  x大于10.

                if（x>10）{

                        System.out.println("x大于10")；

                }

                System.out.println("自学java");

        }

}

3，if结构1的简写形式：

A：使用简写形式的前提。

if结构的语句只有一条语句

B：if简写语句形式：

if（判定条件）语句体

eg：

class  IfDemo1{

        public  static  void  main(String[]  args){

                //使用变量表示温度

                //如果温度低于0度，则需要添加衣服

                //定义 wenDu 变量赋值为-10.5及初始化

                //double  wenDu=-10.5；

                //if(wenDu<0){

                        //System.out.println("需要添加衣服");

                //}

                

                //把以上结构修改成简写代码

                //请问下面的代码会输出什么？

                //定义 wenDu 变量赋值为-10.5及初始化

                double  wenDu=10.5；

                if(wenDu<0)

                        //在if结构之内，因为判定条件是false，所以不执行。

                        System.out.println("需要添加衣服");   

                      

                        System.out.println("需要穿厚点衣服");//实际这条代码是在if结构之外，if结束必须执行。

                System.out.println("自学java");

        }

}

三：if结构2

1，语法：

if（判定条件）{

        语句体1

}else{

        语句体2

}

2，语法执行流程

A：先执行判定条件，判定条件的结果肯定是一个布尔值。

B：如果在A中是true，则执行语句体1，执行后if结构结束，程序继续按照顺序结构往下执行。

C：如果在B中是false，则if结构结束2，程序继续按照顺序结构往下执行。

eg：

class  IfDemo2{

        public  static  void  main(String[]  args){

                //需求：如果成绩大于60分就及格，不大于就不及格

                //定义一个变量表示分数

                //定义score变量赋值为60.5及初始化

                double  score=60.5;

                

                //按照if结构2完成成绩大于60分就及格，不大于就不及格

                if（score>=60）{

                        //大于60分

                        System.out.println("成绩及格")；

                }else{

                        //小于60分

                        System.out.println("成绩不及格")；

                }

        }

}

四：if结构3

1，语法

if（判定条件）{

        语句体1

}else if{

        语句体2

}else if{

        语句体3

}……else  if……

else{

        else语句

}

2，语句执行流程

A：先执行判定条件1，判定条件的结果肯定是一个布尔值。

B：如果在A中是true，则执行语句体1，执行后if结构结束，程序继续按照顺序结构往下执行。

C：如果A中是false，则开始执行判定条件2.

D：如果在C中是true，则执行语句体2，执行后if结构结束，程序继续按照顺序结构往下执行。

E：如果C中是false，则开始执行判定条件3.

F：如果在E中是true，则执行语句体3，执行后if结构结束，程序继续按照顺序结构往下执行。

G：如果E中是false，则开始执行下一个else  if的执行判定条件。

H：如果所有的if和else  if的判定条件都是false，则执行else语句体，if结构结束，程序继续按

照顺序结构往下执行。

eg:

class  IfDemo3{

        public  static  void  main(String[]  args){

                //定义一个变量表示成绩

                //按照成绩的不同，显示   优，良，中，及格，不及格

                //成绩  90-10优  80-90良   70-80中   60-70及格   60以下不及格

                //定义成绩变量               

                double  score=95.5； //定义score变量赋值为95.5及初始化

                按照需求使用if语句3来完成成绩的   优，良，中，及格，不及格

                if((score>90)&(score<=100)){

                        //90-100优

                        System.out.println("优")；

                }else  if((score>80)&(score<=90)){

                        //80-90良

                        System.out.println("良")；

                }else  if((score>70)&(score<=80)){

                        //70-80中

                        System.out.println("中")；

                }else  if((score>=60){

                        //60-70及格

                        System.out.println("及格")；

                }else{

                        //60以下不及格

                        System.out.println("不及格")；

                }

        }

}

五：if语句的嵌套结构

在单一的if结构中，某个选择分支中还包含有if结构，就叫做if嵌套

eg：

class  IfDemo4{

        public  static  void  main(String[]  args){

                //求三个整数的最大值

                //解题步骤：

                //    1，先把任选的两个数做比较

                //    2，再把1中的较大的数再和剩下的那个数比较

                //剩下的就是三个数的最大值

                //定义三个整型变量赋值及初始化

                int  a=10；

                int  b=20；

                int  c=30；

                

                //先用a和b比较

                if(a>=b){

                        //a大    再使用a和c比较

                        if(a>=c){

                                //a大    a就是最大值

                                System.out.println("三个数的最大值是"+a)；

                        }else{

                                //c大    c就是最大值

                                 System.out.println("三个数的最大值是"+c)；

                        }

                }else{

                        //b大    再使用b和c比较

                        if(b>=c){

                                 //b大    b就是最大值

                                 System.out.println("三个数的最大值是"+b)；

                        }else{

                                   //c大    c就是最大值

                                    System.out.println("三个数的最大值是"+c)；

                        }

                }

        }

}

六：选择结构——switch语句

1，语法结构

switch(表达式){

        case  待比较值1 :

                语句体1

                break；

        case  待比较值2 ：

                语句体2

                break：

        ……case……；

        default：

                default语句体

                break；

}

2，语法执行流程

A：计算表达式的值（通常是直接给一个变量的值）。

B：使用A中的表达式的值和每一个case语句块的待比较值进行判等运算。

C：如果存在某个case语句块的待比较值和A中的值相等，

则执行这个case语句块的语句体，执行完语句体之后，程序继续往下执行。

直到碰到第一个break，则表示switch结束，程序按照顺序结构往下继续执行。

D：如果A中的值和所有的case语句块中的待比较值都不相等，

则执行default语句体，执行完语句体之后，程序继续往下执行。

直到碰到第一个break，则表示switch结束，程序按照顺序结构往下继续执行。

eg：

class  SwitchDemo{

        public  static  void  main(String[]  args){

                //根据变量month的值显示对应的月份             

                int  month=6；//定义month变量赋值为6及初始化

                //使用switch结构完成变量month的值，显示对应的月份

                switch（month）{

                        case  1：

                                System.out.println("1月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  2：

                                System.out.println("2月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  3：

                                System.out.println("3月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  4：

                                System.out.println("4月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  5：

                                System.out.println("5月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  6：

                                System.out.println("6月份")；//month的值和待比较值相等，输出的是6月份。

                                break；

                        case  7：

                                System.out.println("7月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  8：

                                System.out.println("8月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  9：

                                System.out.println("9月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  10：

                                System.out.println("10月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break；

                        case  11：

                                System.out.println("11月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break：

                        case  12：

                                System.out.println("12月份")；//如果month的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break：

                        default ：

                                //控制month变量值超出范围。

                                System.out.println("没有对应的月份")；

                                break；

                }

        }

}

3，switch语句的特点

A：switch后的表达式的值都可以是什么类型。

switch（表达式）其中的表达式的值可以是什么类型

基础的:      byte    short    int    char

扩展的：   字符串                    jdk7.0之后

特殊的：    枚举                        enum（后面课程讲解）

eg：

class  SwitchDemo1{

        public  static  void  main(String[]  args){

                //用byte    int    short做表达式的值

                //定义一个ing类型变量

                int  x=1；  //定义  x变量赋值为1及初始化

                switch（x）{

                        case  1：

                                System.out.println("x="+1);//如果  x  的值和case的待比较值相等，输出x=1。

                                break;

                        case  2:

                                System.out.println("x="+2);//如果 x 的值和case的待比较值相等就输出，否则就执行下一个case语句体。

                                break;

                        default :

                                // 控制 x 变量值超出范围。

                                System.out.println("default语句块");

                                break;

                }

                //char做表达式值

                //1，表达式的值和case的待比较值都是char类型，可以执行

                //2，表达式的值是char，待比较值是int类型，可以执行

                //3，表达式的值是int，待比较值是char类型，可以执行

                //定义一个char类型变量

                char  x='a';//定义  x 变量赋值为a及初始化

              

              //1，表达式的值和case的待比较值都是char类型，可以执行

                switch（x）{

                        case 'a' :

                                System.out.println("x="+a);

                                break;

                        case  'b' :

                                System.out.println("x="+b);

                                break;

                        default :

                                System.out.println("default语句体")

                }

               //2，表达式的值是char，待比较值是int类型，可以执行

               int  x=97;    

               switch（'a'）{

                        case 97 :

                                System.out.println("x="+1);

                                break;

                        case  98 :

                                System.out.println("x="+2);

                                break;

                        default :

                                System.out.println("default语句体")

                }

                //3，表达式的值是int，待比较值是char类型，可以执行

                

               int  x='a';    

               switch（97）{

                        case 'a' :

                                System.out.println("x="+1);

                                break;

                        case  'b' :

                                System.out.println("x="+2);

                                break;

                        default :

                                System.out.println("default语句体")

                }

        }

}

B：case  相关

B_1：case后的待比较值必须是常量表达式（不能是变量或者变量表达式）。

B_2：在一个switch结构中，所有的case代码块的待比较值都不能相同。

B_3：case和其后的待比较值是一个整体。

eg：

class  SwitchDemo2{

        public  static  void  main(String[]  args){

                //定义两个整型int变量

                //定义两个变量赋值及初始化

                int x=1；

                int y=2；

                switch（x）{

                        case  1：

                                System.out.println("x="+1);

                                break;

                        case  2:

                        //case  y ://需要常量表达式，不能是变量。

                                System .out.println("x="+2);

                                break;

                        //case  2://标签重复

                                //System.out.println("x="+2);

                                //break;

                        default  :

                                System.out.println(default语句块);

                                break；

                }

        }

}

C：break 相关（重点）

switch结构中的break语句是否可以不写？

break可以不写，但是如果不写，会发生语句穿透。

建议要写，如果有特殊需求，可能不写break更会提高编码效率（后面例题）

break是switch结束的标志，但是如果switch中没有语句可以执行了，一样

switch结构结束。

D：default  相关

default是必须卸载switch的最后一句吗？

不是必须，default和switch中的case代码块是同级别的，可以写在每一个case代码块外的任何地方。

但是default语句块写在什么地方，都不会影响switch语法结构的执行流程。

eg：

class  SwitchDemo3{

        public  static  void  main(String[]  args){

                //定义一个变量

                int  x=1；//定义  x 变量赋值及初始化

                switch（x）{

                        //default可以写在前面，也可以写在后面、或者中间。

                        //default ：

                                //System.out.println("default语句块")；

                                //break;

                        case  1：

                                System.out.println("x=1");

                                //break;//语句穿透

                        case  2:

                                System.out.println("x=2");

                                //break;

                        default  :

                                System.out.println("default语句块")；

                                //break；

             }

                System.out.println("game  over");

        }

}

4，switch语句中break不写练习题。

switch结构在break不写，是符合某些特殊要求的。

break不写不可以认为是一种代码错误，实际上生活中有很多需求可以使用

语句穿透更符合编码要求。

eg:

class  SwitchDemo4{

        public  static  void  main(String[]  args){

                //使用变量表示月份，输出这个月所在的季度

                //定义一个月份变量

                int  month =4；//定义month变量赋值及初始化

                //使用switch语句去判断month的变量值对应的季度

                case  1：

                case  2：

                case  3：

                        System.out.println("1季度");

                        break;

                case  4:

                case  5:

                case  6:

                        System.out.println("2季度");

                        break;

                case  7;

                case  8;

                case  9:

                        System.out.println("3季度");

                        break;

                case  10:

                case  11:

                case  12:

                        System.out.println("4季度");

                        break;

                default  :

                        System.out.println("没有对应的季度")；

                        break；

        }

}

四：switch语句练习

需求：

使用dos窗口和永福交互，可以让用户从dos窗口做以下的选择题（既可以让用户

从dos窗口输入选择项，程序可以接受，并作出回应）

问题描述：

请从如下选择项中选出您喜欢的球类运动（只能单选）

1，足球        2，篮球        3，羽毛球        4，乒乓球

问题解析：

1，需要让用户能够从dos窗口看到问题描述。

按照目前所学，只能使用输出语句。

2，用户可以从dos窗口直接输入选项（1,2,3,4）。

从dos窗口输入值，main方法中可以直接使用。

3，程序吧用户选项对应的选项内容作为反馈信息，输入到窗口。

按照目前所学，只能使用输出语句。

//导入类

import  java.util.Scanner;

class  SwitchDemo5{

        public  static  void  main(String[]  args){

                //解析问题：

                //1，需要让用户能够从dos窗口看到问题描述。

             //按照目前所学，只能使用输出语句。

                System.out.println("请从如下选择项中选出您喜欢的球类运动（只能单选）");

                System.out.println("1，足球");

                System.out.println("2，篮球");

                System.out.println("3，羽毛球");

                System.out.println("4，乒乓球");

                

                //解析问题：

                //2，用户可以从dos窗口直接输入选项（1,2,3,4）。

                //从dos窗口输入值，main方法中可以直接使用。

                //  A:要给程序导入类：import  java.util.Scanner;

                //以上这就话写在java代码中class的上面。

                //   B：创建Scanner类的对象：Scanner  xx=new  Scanner（System.in）；

                Scanner  xx=new  Scanner（System.in）；

                //Scanner是变量  xx 的数据类型，xx就是变量名称

                //new  Scanner（System.in）；就是xx变量的初始化值。（这个是没有学习对象之前的理解）

                //  C：接收用户从dos窗口的输入选择项

                //因为选项是（1,2,3,4），所以用来接收选项的变量就是int类型

                int  choice=xx.nextInt（）；

                

                //测试从dos窗口接收用户输入值是否正确

                //System.out.println("choice="+choice)；

                

                //解析问题：

                //3，程序吧用户选项对应的选项内容作为反馈信息，输入到窗口。

                //按照目前所学，只能使用输出语句。

                //开始使用switch结构，根据接收到的用户输入选择项choice的值来

                //判断用户喜欢的球类运动。

                switch（choice）{

                        case  1：

                                System.out.println（"您喜欢的球类运动是："足球）;

                                break;

                     case  2:

                             System.out.println（"您喜欢的球类运动是："篮球）;

                                break;

                        case  3:

                                System.out.println（"您喜欢的球类运动是："羽毛球）;

                                break;

                        case  4:

                                System.out.println（"您喜欢的球类运动是："乒乓球）;

                                break;

                        default  :

                                System.out.println（"您输入有误“）;

                             break;

                }

        }

}

五：if和switch结构的区别：

1，if结构因为有1-3结构，所以单从语法结构上，if结构比switch结构的使用场景更广。

2，if结构一般用于对某个范围的分只选择，

而switch只是比较单值是否相等。

3，能用switch解决的问题，if结构也能解决。

在编码中，通常用if。

在考题中，喜欢考switch结构的语句穿透问题。