Java程序中的逻辑结构

曾经终败给现在 2024-03-27 15:46 57阅读 0赞

#### 文章目录 ####

*  前言
 *  一、顺序结构
 *  二、分支结构
 *   *  1.if语句
     *  2.switch语句
 *  三、循环结构
 *   *  1.while循环
     *  2.for循环
     *  3.do while 循环
     *  4.beak
     *  5.continue
 *  总结

--------------------

## 前言 ##

任何计算机程序设计语言，都离不开三大逻辑结构：顺序结构、分支结构、循环结构。这三大结构也是代码的组成方式。是支撑编程语言成功执行的核心。非常基础，也非常重要。但是，在使用的时候，不同语言还是有一些差别的。所以，这篇文章就来讨论讨论Java程序的逻辑结构。

--------------------

## 一、顺序结构 ##

顺序结构很好理解，很简单，就是按照代码的书写顺序一行一行执行。

System.out.println("aaa");
    System.out.println("bbb");
    System.out.println("ccc");
    // 运行结果
    aaa
    bbb
    ccc

同样，我们改变一下代码书写顺序，那执行顺序也会发生改变。

System.out.println("aaa");
    System.out.println("ccc");
    System.out.println("bbb");
    // 运行结果
    aaa
    ccc
    bbb

## 二、分支结构 ##

### 1.if语句 ###

*  **基本语法形式1**

if(布尔表达式){
        
        //条件满足时执行代码
    }

*  **基本语法形式2**

if(布尔表达式){
        
        //条件满足时执行代码
    }else{
        
        //条件不满足时执行代码
    }

**代码示例**：判断一个数是奇数还是偶数

int num = 10;
    if(num % 2 == 0){
        
       System.out.println("num是偶数");
    }else{
        
       System.out.println("num是奇数");
    }

*  **基本语法形式3**：多分支情况

（1）形式1

if(布尔表达式){
        
        //条件满足时执行代码
    }else if(布尔表达式){
        
        //条件满足时执行代码
    }else{
        
        //条件都不满足时执行代码
    }

**代码示例**：判断数字是正数还是负数

int num = 10;
    if (num > 0) {
        
        System.out.println("num 是正数");
    } else if (num < 0) {
        
        System.out.println("num 是负数");
    } else {
        
        System.out.println("num 是 0");
    }

（2）形式2

if(布尔表达式a){
        
        //条件满足时执行代码
    }
    if(布尔表达式b){
        
        //条件满足时执行代码
    }

那么问题来了，多分支的两种形式有什么区别呢？  
形式1中，永远只会执行满足其中一个表达式的代码块；而形式2，有可能出现一种情况，同时满足表达式a和表达式b,那么两个分支的代码块都会被执行。  
**找出1~100中出现数字9的数字的个数**  
上述问题中，我们应该使用哪种形式的分支来解决呢？很明显，要使用形式2，因为90~99，它们的十位出现数字9，如果使用形式1，就会把这种情况过滤掉了，就得到了错误的结果。所以，代码如下：

int num = 0;  //初始化一个计数器num,用来接收数字个数
    for(int i = 0;i <= 100;i ++){
          //先提前使用一下for循环，后面详细介绍
        if(i%10 == 9){
                     //计算个位出现9的数字个数
           num ++;
        }
        if(i/9 == 10){
                     //计算十位出现9的数字个数
           num ++;
        }
    }
    System.out.println("1~100中出现9的数字个数为：" + num);  //输出为19

*  代码练习：**判断某一年是否是闰年**

public class Test {
        
        public static void main(String[] args) {
        
            int year = 2000;
            if(year % 100 == 0){
        
                if(year % 400 == 0){
        
                    System.out.println("是闰年");
                }else {
        
                    System.out.println("不是闰年");
                }
            }else {
        
                if(year % 4 == 0){
        
                    System.out.println("是闰年");
                }else {
        
                    System.out.println("不是闰年");
                }
            }
        }
    }

很简单，其实上面的代码还可以这样改写一下

public class Test {
        
        public static void main(String[] args) {
        
            int year = 2000;
            if(year % 4 == 0 && year % 100 != 0){
        
                System.out.println("是普通闰年");
            }else if(year % 400 == 0){
        
                System.out.println("是世纪闰年");
            }else {
        
                System.out.println("不是闰年");
            }
        }
    }

但是，注意，作为Java初学者，在使用if分支嵌套的时候，if后面跟的条件表达式尽量简单一点，最好只有一个条件，哪怕多用几个分支，这样不容易出错。

*  **注意事项**  
    （1）悬垂else问题

int x = 10;
    int y = 10;
    if (x == 10)                     //这里if,else语句没有加大括号，在Java可以这么使用
     if (y == 10)                    //这里的条件如果改成y != 10,然后运行，什么情况就可以一目了然
     System.out.println("aaa");
    else
     System.out.println("bbb");

在Java中，if / else 语句中可以不加大括号 ， 但是也可以写语句(只能写一条语句)， 此时 else 是和最接近的 if 匹配（**最近匹配原则**）。  
但是实际开发中非常不建议这么写. 最好加上大括号。  
（2）代码风格问题  
现在的社会都是一个看脸的社会，同样，作为程序员，能写出优美的代码是我们终身追求的目标。

// 风格1
    int x = 10;
    if (x == 10) {
        
        // 满足条件
    } else {
        
        // 不满足条件
    }
    // 风格2
    int x = 10;
    if (x == 10)
    {
        
        // 满足条件
    }
    else
    {
        
        // 不满足条件
    }

**虽然两种风格方式都是合法的, 但是Java中更推荐使用风格1, \{ 放在 if / else 同一行**  
（3）分号问题  
一些Java初学者，往往都下意识地在每一行代码结束后加一个分号；注意，加分号就表示一段代码执行结束了。这是不敢乱加滴！！！

int x = 20;
    if (x == 10); {
            //看到没有，这里出现if条件后面加了一个分号，所以根本就没有按照if的条件来执行
        System.out.println("hehe");
    }
    // 运行结果
    hehe

此处多写了一个 分号, 导致分号成为了 if 语句的语句体, 而 \{ \} 中的代码已经成为了和一个 if 无关的代码块

### 2.switch语句 ###

在实际工程中，是不会用到switch的，但是作为Java学习，我们必须得知道有这种分支语句

*  **基本语法**

switch(整数|枚举|字符|字符串){
        
     case 内容1 : {
        
     内容满足时执行语句;
     [break;]
     }
     case 内容2 : {
        
     内容满足时执行语句;
     [break;]
     }
     ...
     default:{
        
     内容都不满足时执行语句;
     [break;]
     } 
    }

*  **代码示例**：根据Day的值输出星期

public class Test {
        
        public static void main(String[] args) {
        
            int Day = 4;
            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;
                default:
                    System.out.println("星期日");
                    break;
            }
        }
    }

（1）根据 switch 中值的不同, 会执行对应的 case 语句. 遇到 break 就会结束该 case 语句。  
（2）如果 switch 中的值没有匹配的 case, 就会执行 default 中的语句。  
（3）建议一个 switch 语句最好都要带上default。

*  **注意事项**  
    （1）break不要遗漏，否则会失去“多分支选择”的效果

int day = 1;
    switch(day) {
        
        case 1:
            System.out.println("星期一");
            // break;
        case 2:
            System.out.println("星期二");
            break;
    }
    // 运行结果
    星期一
    星期二

**可以发现，当不写break的时候，会从碰到满足条件的分支开始，一直向下执行，直至结束。**

（2）switch中的值只能是整数|枚举|字符|字符串

double num = 1.0;
    switch(num) {
        
        case 1.0:
            System.out.println("hehe");
            break;
        case 2.0:
            System.out.println("haha");
            break;
    }
    // 编译出错
    Test.java:4: 错误: 不兼容的类型: 从double转换到int可能会有损失

（3）switch不能表达复杂的条件

// 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
    // 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示. 
    if (num > 10 && num < 20) {
        
     System.out.println("hehe");
    }

（4）switch虽然支持嵌套，但是真的不美观

int x = 1; 
    int y = 1; 
    switch(x) {
                     //在实际应用中，根本不会用到关于switch的任何知识
        case 1: 
           switch(y) {
         
               case 1: 
               System.out.println("hehe"); 
               break; 
           } 
        break; 
        case 2: 
        System.out.println("haha"); 
        break; 
    }

可以发现，switch的局限性太大了。所以，在应用中，还是老老实实用if/else吧。

## 三、循环结构 ##

### 1.while循环 ###

*  **基本语法格式**

while(循环条件){
         
    循环语句; 
    }

**循环条件为true，则执行循环语句，否则循环结束**

*  **代码示例**

（1）**打印1~10的数字**

public class Test {
        
        public static void main(String[] args) {
        
            int num = 1;                 //num从1开始
            while (num <= 10){
                   //循环条件为num<=10,当num>10时，终止循环
                System.out.println(num);
                num ++;                  //whlie循环，每一次循环结束后，变量要加
            }
        }
    }

（2）**计算1~100的和**

public class Test {
        
        public static void main(String[] args) {
        
            int num = 1;               //初始化变量，从1开始
            int sum = 0;               //定义一个sum变量，用于存储1~100的和，这里是加，所以sum从0开始
            while (num <= 100){
                //循环条件
                sum += num;            //循环累加
                num ++;                //每一次循环结束后，变量要加，不要忘了
            }
            System.out.println(sum);
        }
    }

（3）**计算5的阶乘**

public class Test {
        
        public static void main(String[] args) {
        
            int num = 1;
            int sum = 1;         //因为这里是乘，所以sum从1开始
            while (num <= 5){
        
                sum *= num;      //循环累乘
                num ++;          //while循环++不能忘
            }
            System.out.println(sum);
        }
    }

（4）**计算1！+2！+3！+4！+5！**

public class Test {
        
        public static void main(String[] args) {
        
            int num = 1;
            int sum = 0;             //定义sum，初始值为0，用于存储阶乘和
            while (num <= 5){
                //外层循环计算和
                int sumTmp = 1;      //定义临时变量sumTmp，初始值为1，存储每个数的阶乘
                int tmp = 1;         //tmp用于临时存储每一个数
                while (tmp <= num){
          //内层循环计算阶乘
                    sumTmp *= tmp;   
                    tmp ++;
                }
                sum += sumTmp;       //最后将每一个数的阶乘加起来
                num ++;
            }
            System.out.println(sum);
        }
    }

这里我们发现, 当一个代码中带有多重循环的时候, 代码的复杂程度就大大提高了。而比较复杂的代码就更容易出错。

*  **注意事项**  
    （1）和 if 类似, while 下面的语句可以不写 \{ \} , 但是不写的时候只能支持一条语句. 建议还是加上 \{ \}。  
    （2）和 if 类似, while 后面的 \{ 建议和 while 写在同一行。  
    （3）和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行。

int num = 1; 
    while (num <= 10); {
         
     System.out.println(num); 
     num++; 
    } 
    // 执行结果
    [无任何输出, 程序死循环]

此时 ; 为 while 的语句体(这是一个空语句), 实际的 \{ \} 部分和循环无关. 此时循环条件 num <= 10 恒成立, 导致代码死循环了。

### 2.for循环 ###

*  **基本语法**

for(表达式1;表达式2;表达式3){
         
    循环体; 
    }

（1）表达式1: 用于初始化循环变量.  
（2）表达式2: 循环条件  
（3）表达式3: 更新循环变量  
**相比于 while 循环, for 循环将这三个部分合并在一起, 写代码时不容易遗漏**

*  **代码示例**  
    （1）**打印1~10的数字**

public class Test {
        
        public static void main(String[] args) {
        
            for (int i = 1; i <= 10; i++) {
             //for里面的循环表达式
                System.out.println(i);
            }
        }
    }

（2）**计算1~100的和**

public class Test {
        
        public static void main(String[] args) {
        
            int sum = 0;
            for (int i = 1; i <= 100; i++) {
             //for里面的循环表达式一次性覆盖所有
                sum += i;
            }
            System.out.println(sum);
        }
    }

（3）**计算5的阶乘**

public class Test {
        
        public static void main(String[] args) {
        
            int sum = 1;
            for (int i = 1; i <= 5; i++) {
             //for里面的循环表达式一次性覆盖所有
                sum *= i;
            }
            System.out.println(sum);
        }
    }

（4）**计算1！+2！+3！+4！+5！**

public class Test {
        
        public static void main(String[] args) {
        
            int sum = 0;
            for (int i = 1; i <= 5 ; i++) {
                    //外层循环计算阶乘和
                int sumTmp = 1;
                for (int j = 1; j <= i ; j++) {
                //内层循环计算每个数的阶乘
                    sumTmp *= j;
                }
                sum += sumTmp;                         //求和
            }
            System.out.println(sum);
        }
    }

**对比while循环，可以发现：while循环，不清楚循环的次数，但是一定知道循环的终止条件；for循环可以明确知道所有条件，相比之下，要比while循环清晰一些。同时while每次循环结束时，变量都需要累加一次，否则死循环或者出错。**

*  **注意事项**  
    （1）和 if 类似, for 下面的语句可以不写 \{ \} , 但是不写的时候只能支持一条语句. 建议还是加上 \{ \}。  
    （2）和 if 类似, for 后面的 \{ 建议和 for 写在同一行。  
    （3）和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行。

### 3.do while 循环 ###

*  **基本语法**

do{
         
    循环语句; 
    }while(循环条件);

**先执行循环语句，再判断循环条件**

*  **代码示例**：打印1~10的数字

public class Test {
        
        public static void main(String[] args) {
        
            int num = 1;
            do{
        
                System.out.println(num);     //循环语句
                num ++;
            }while (num <= 10);              //循环条件
        }
    }

*  **注意事项**  
    （1）do while 循环后面的分号，不能忘记了。  
    （2）在实际项目工程中很少用到do while，建议使用for和whilre。

### 4.beak ###

**break的功能是让循环提前结束**  
**代码示例**：找出100~200中第一个3的倍数

public class Test {
        
        public static void main(String[] args) {
        
            int num = 100;
            while (num <= 200){
        
                if(num % 3 == 0){
        
                    System.out.println(num);
                    break;                   //使用break，找到第一个3的倍数，就结束循环
                }
                num ++;
            }
        }
    }

**可以看到，执行break就会让循环结束**

### 5.continue ###

**continue的功能是结束本次循环，进入下次循环**  
**代码示例**：找出100~200中所有3的倍数

public class Test {
        
        public static void main(String[] args) {
        
            int num = 100;
            while (num <= 200){
        
                if(num % 3 != 0){
        
                    num ++;              //++不能忘，否则出现死循环
                    continue;            //使用continue，结束本次循环，立即执行下一次循环
                }
                System.out.println(num);
                num ++;
            }
        }
    }

**可以发现，执行到continue的时候，就会立即进入到下次循环（判断循环条件），而不会执行下面的打印语句**

--------------------

## 总结 ##

以上就是Java程序中的逻辑结构。每种计算机程序设计语言都遵循这三大结构。但是在使用时，会有所不同。这篇文章详细介绍了Java中这三种结构的使用。希望对初学Java的朋友有所帮助。