初识Java（Java流程控制-复合语句）

我就是我 2022-05-29 11:29 202阅读 0赞

### 一、复合语句 ###

Java 语言的符合语句是以整个块区为单位的语句，所以又称块语句。复合语句由开括号“ \{ ”开始，闭括号“ \} ”结束。

复合语句中的每个语句都是从上到下被执行。复合语句以整个块为单位，可以用在任何一个单位语句可以用到的地方，并且复合语句中还可以嵌套复合语句。

public class Compound {
        public static void main(String [] args) {
            int x = 20;
            {                                       //第一个复合语句 开始
                int y = 40;
                System.out.println(y);
                int z = 245;
                boolean b; 
                {                                   //第二个复合语句开始
                    b = y>z;
                    System.out.println(b); }        //第二个复合语句结束
            }                                       //第一个复合语句结束
            String word = "hello java";
            System.out.println(word);
        }
    }

运行结果： 40 false hello java

二、条件语句

2.1 if 条件语句

if 条件语句是一个重要的编程语句，用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句。

使用 if 条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字 if 之后是作为条件的“布尔表达式”，如果该表达式返回的结果为 true ，则执行其后的语句；若为 false ，则不执行 if 条件之后的语句。if 条件语句可分为简单的 if 条件语句、 if ... else 语句和 if ... else if 多分支语句。

2.1.1 简单的 if 条件语句

语法： if ( 布尔表达式 ) \{ 语句序列 \}

布尔表达式：必要参数，表示它最后返回的结果必须是一个布尔值。可以是一个单纯的布尔变量或常量，也可以是使用关系或布尔运算符的表达式。

语句序列：可选参数。可以是一条或多条语句，当表达式为 true 时执行这些语句。若语句序列中仅有一条语句，则可以省略条件语句中的“ \{ \} ”。

int a = 100;
    if(a==100)  //省略“ {  } ”没有语法错误，为了程序的可读性最好不好省略
    System.out.println("a 的值是 100");

条件语句后的语句序列省略时，则可以保留外面的大括号，也可以省略大括号。然后再末尾添加分号“ ; ”。

boolean b = false;
    if( b );
    boolean b = false;
    if( b ) { }

public class Getif{                                     //创建类
        public static void main(String [] args){            //主方法
            int x = 45;                                     //声明 int 型变量 x ，并赋给初值
            int y = 12;                                     //声明 int 型变量 y ，并赋给初值
            if( x > y ){                                    //判断 x 是否大于 y 
                System.out.println("变量 x 大于变量 y ");    //如果条件成立，输出信息
            }
            if( x < y ){                                    //判断 x 是否小于 y 
                System.out.println("变量 x 小于变量 y ");    //如果条件成立，输出信息
            }
       }
    }

运行结果为： 变量 x 大于变量 y

2.1.2 if ... else 语句

if ... else 语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。

语法： if ( 表达式 ) \{

若干语句

\}else\{

若干语句

if 后面 ( ) 内的表达式的值必须是 boolean 型的。如果表达式的值为 true ，则执行紧跟 if 语句的复合语句；如果表达式的值为 false ，则执行 else 后面的复合语句。

public class Getifelse{                         //创建类
        public static void main(String [] args){    //主方法
            int math = 95;                          //声明 int 型局部变量，并赋给初值95
            int english = 56;                       //声明 int 型变量，并赋给初值56
            if( math > 60 ){                        //使用 if 语句判断 math 是否大于 60
                System.out.println("数学及格了");    //条件成立时输出信息
            }else{
                System.out.println("数学没有及格");  //条件不成立时输出信息
            }
            if( english > 60 ){                     //判断英语成绩是否大于 60
                System.out.println("英语及格了");    //条件成立时输出信息
            }else{
                Syste,.out.printn("英语没有及格");   //条件不成立时输出信息;
            }
        }
    }

运行结果： 数学及格了 英语没有及格

2.1.3 if ... else if 多分支语句

if ... else if 多分支语句用于针对某一时间的多种情况进行处理。通常表现为“如果满足某种条件就进行某种处理，否则如果满足另一种条件则执行另一种处理”。

语法： if ( 条件表达式1 ) \{

语句序列 1

\} else if ( 条件表达式2 )\{

语句序列 2

\} ...

\}else if ( 表达式 n ) \{

语句序列 n

条件表达式 1~ 条件表达式 n ：必要参数。可以由多个表达式组成，但最后返回的结果一定要为 boolean 类型。

语句序列：可以是一条或多条语句，当条件表达式 1 的值为 true 时，执行语句序列 1 ；当条件表达式 2 的值为 true 时，执行语句序列 2 ，以此类推。

public class GetTerm{                                             //创建类
        public static void main(String [] args){                      //主方法
            int x = 20;                                               //声明 int 型局部变量
            if( x > 30 ){                                             // 判断变量 x 是否大于 30
                System.out.println("变量 x 大于 30 ");                 //条件成立时输出信息
            }else if( x > 10 ){                                       // 判断 x 是否大于 10 
                System.out.println("变量 x 的值大于 10，但小于30 ");    //条件成立时输出信息
            }else if (x > 0){                                         //判断变量 x 是否大于 0
                System.out.println("变量 x 的值大于 0，但小于10");      //条件成立时输出信息
            }else {                                                   //当以上条件都不成立时，执行的语句序列
                Syste,.out.println("变量 x 的值小于 0");               //输出信息
            }
        }
    }

运行结果为：变量 x 的值大于 10 ，但小于30

2.2 switch 多分支语句

在编程中一个常见的问题就是检测一个变量是否符号某个条件，如果不符合，在用另一个值来检测，以此类推。

使用 if 语句检测变量是否符合某个条件

if( grade == "A" ){
        System.out.println( "真棒" );
    }
    if( grade == "b" ){
        System.out.println( "做的不错" );
    }

使用 switch 语句检测变量是否符合某个条件

switch(表达式){
        case 常量值1:
            语句块 1
            [break;]
        ...
        case 常量值n:
            语句块 n
            [break;]
        default:
            语句块 n+1;
            [break;]
    }

switch 语句中表达式的值必须是整形、字符型或字符串类型，常量值1~n 必须也是整形、字符型或字符串类型。 switch 语句首先计算表达式的值，如果表达式的值和某个 case 后面的变量值相同，则执行该 case 语句后的若干个语句直到遇到 break 为止。此时如果该 case 语句中没有 break 语句，将继续执行后面 case 中若干个语句，直到遇到 break 语句为止。若没有一个常量的值与表达式的值相同，则执行 default 后面的语句。 default 语句为可选的，如果它不存在，且 switch 语句中表达式的值不与任何 case 的常量值相同， switch 则不做任何处理。

publice class GetSwitch{                       //创建类
        public static void main(String[] args){    //主方法
            int week =2;                           //定义 int 型变量 week 
            switch(week){                          //指定 switch 语句的表达式为变量 week 
            case 1:                                //定义 case 语句中的常量为 1
                System.out.println("Monday");      //输出信息
                break;
            case 2:                                //定义 case 语句中的常量为 2
                System.out.println("Tuesday");     //输出信息
                break;
            case 3:                                //定义 case 语句中的常量为 3
                System.out.println("Wednesday");   //输出信息
                break;
            case 4:                                //定义 case 语句中的常量为 4
                System.out.println("Thursday");    //输出信息
                break;
            case 5:                                //定义 case 语句中的常量为 5
                System.out.println("Friday");      //输出信息
                break;
            case 6:                                //定义 case 语句中的常量为 6
                System.out.println("Saturday ");   //输出信息
                break;
            case 7:                                //定义 case 语句中的常量为 7
                System.out.println("Sunday");      //输出信息
                break;
            default:                               // default 语句
                System.out.println("Sorry , I don't konw!");
            }
        }
    }

运行结果为：Tuesday

对于学习Java，看书，看视频，看官方文档，看API，多练，多想。

要时刻学习，更新很快，要学习新技术，好好加油，祝终成大神。