【JAVA】程序的控制结构

程序的控制结构

顺序结构

　 　1> 程序是自上而下执行的，不需要借助任何特殊的语句就可以实现；

　　 2> 程序语句只能被执行一次　

 

package code;
import java.util.Scanner;   //实现从键盘输入

public class Demo{

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入两个整数：");
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        int sum = x + y;
        System.out.println("求和：sum = " + sum);

    }
}

 

编译结果：　　

 

 

分支结构

if 条件语句

　　1> 依次从上到下执行，表达式成立 执行{}内语句，不成立不执行

// 语法
if (表达式){
  表达式成立时执行的语句；  
}else if（表达式）{
　　语句；
}else if（表达式）{
　　语句；
}else{
　　语句；
}

 

if…… else if …… else if …… else……

package code;
import java.util.Scanner;   //实现从键盘输入

public class Demo{

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入两个整数：");
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        if (x<y){
            int sum = x + y;
            System.out.println("当x<y时，x+y = " + sum);
        }else if(x>y){
            int jianfa = x-y;
            System.out.println("当x>y时，x-y = " + jianfa);
        }else {
            System.out.println("不满足计算条件，x=y");
        }

    }
}

 

编译结果：　　

  

空语句

package code;
import java.util.Scanner;   //实现从键盘输入

public class Demo{

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入两个整数：");
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        if (x == y);
    }
}

 

编译结果：　　

 

 

switch case

　　判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

　　　　1>  case从上到下执行,当表达式的值与case中的值相同时,则执行该case中的语句块；

　　　　2>  case可以0~n个

　　　　3>  case后需要加break,如果不加break，会从第一个case开始执行,直到遇到break为止;

　　　　4>  default的位置可以放在与case并列的任何一个位置上；

// 语法结构
switch(variable){
            case "value" :
                //语句
                break; //跳出判断
            case "value" :
                //语句
                break; //跳出判断
            default : //其他值
                //语句
        }

 

package code;

public class Demo{

    public static void main(String[] args) {

        String grade = "B";

        switch(grade){
            case "A" :
                System.out.println("等级为A：优秀");
            case "B" :
                System.out.println("等级为B：良好");
//                break; //不跳出，执行后续语句
            case "C" :
                System.out.println("等级为C：不及格");
                break;  // 跳出，不执行后续语句
            default :
                System.out.println("未定级");
        }
    }
}

 

编译结果：　　

 

 

 

 

  

循环结构

 while 循环

　　1> 满足表达式，执行循环，直到不满足

　　2> 不满足表达式，则不进入循环

// 语法结构
while( 表达式 ) {
  //循环内容
}

 

package code;

public class Demo{

    public static void main(String[] args) {

        int a = 8;
        
        while (a<12){
            System.out.println("a = " + a);
            a++;
        }
    }
}

 

编译结果：　　

 

 

 

do while 循环

　　1> 至少执行1次循环

　　2> 不满足条件 则不执行循环，满足条件再次执行循环

// 语法结构
do {
       //代码语句
}while(布尔表达式);

 

package code;

public class Demo{

    public static void main(String[] args) {

        int a = 12;

       do{
            System.out.println("a = " + a);
            a++;
        } while (a<12);
    }
}

 

编译结果：　　

 

 

for 循环

　　1> 初始化：可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句

　　2> 表达式：表达式为真时执行循环体语句，否则执行后续语句

　　3> 更新：变量更新

// 语法结构
for(初始化; 布尔表达式; 更新) {
    //代码语句
}

 

package code;

public class Demo{

    public static void main(String[] args) {

        for (int i = 5; i<10; i++){
            System.out.println("i = " + i);
       }
    }
}

 

编译结果：　　

 

 

2> 
        变量初始化
        for(;条件;步长)
        {
            //循环体
        }
    3>   
        变量初始化
        for(;条件;)
        {
            //循环体
            步长
        }
 
    4>
        变量初始化
        for(;;)
        {
            //步长            
            //自己判断结束条件
            if(i > 1000)
               break;
        }

 

 

数组的增强型 for 循环

　　1> 声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

　　2> 表达式是要访问的数组名，或者是返回值为数组的方法

// 语法结构
for(声明语句 : 表达式)
{
   //代码句子
}

 

package code;

public class Demo{

    public static void main(String[] args) {
        int [] arr = {5, 6, 10, 100};

        for (int a:arr){
            System.out.println(a);
        }
    }
}

 

编译结果：　　 

 

 

 

 

break

　　1> 跳出最里层循环

　　2> 在循环语句或switch 语句中，用来跳出整个语句块

 

package code;

public class Demo{

    public static void main(String[] args) {
        int [] arr = {5, 6, 10, 100};

        for (int i=5; i<8; i++){
           System.out.println("《《《《外层循环》》》》");
            for (int a:arr) {
                System.out.println(a);
                if (a == 6) {
                    System.out.println("跳出内层循环");
                    break;
                }
            }
        }
    }
}

 

编译结果：　　

 

 

 

continue

 　　1> 在 for 循环中，continue 语句使程序立即跳转到更新语句。

　　 2> 在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

package code;

public class Demo{

    public static void main(String[] args) {
        int [] arr = {5, 6, 10, 100};

        for (int i=5; i<8; i++){

            if (i == 6){
                continue;
            }else {
                System.out.println("《《《《外层循环》》》》 " + i);
            }
            for (int a:arr) {
                System.out.println(a);
                if (a == 6) {
                    System.out.println(a + " = 6 跳出内层循环");
                    break;
                }

            }
        }
    }
}

 

编译结果：