分支结构：基于条件执行某语句

if结构：1条路

语法：

 if(boolean){
         语句块
    }   

执行过程：
判断boolean的值:

• 若为true，则执行语句块1(if整个结束)
• 若为false，则if直接结束

//1)偶数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折:
double price = 300.0; //消费金额  带数(600.0,300.0)
if(price>=500){ //满500
    price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

//3)判断年龄是否在18到50之间，若满足则输出:"满足条件"
int age = 88;  //带数(25,5,88)
if(age>=18 && age<=50){
    System.out.println("年龄满足条件");
}
System.out.println("继续执行...");

if…else结构：2条路

语法：

  if(boolean){
         语句块1
    }else{
         语句块2
    }

执行过程：
判断boolean的值:

• 若为true，则执行语句块1(整个结束)
• 若为false，则执行语句块2(整个结束)
  说明：语句块1和语句块2，必走其中之一------------2选1

//1)偶数、奇数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}
System.out.println("继续执行...");

//2)满500打8折，不满500打9折:
double price = 300.0;  //带数(600.0,300.0)
if(price>=500){ //满500
    price *= 0.8;
}else{ //不满500
    price *= 0.9;
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩是否合法，合法则输出"该成绩合法"，否则输出"该成绩不合法":
int score = 560; //带数(95,-90,560)
if(score<0 || score>100){
    System.out.println("该成绩不合法");
}else{
    System.out.println("该成绩合法");
}
System.out.println("继续执行...");

if…else if结构：多条路

语法：

  if(boolean-1){
     语句块1
   }else if(boolean-2){
     语句块2
   }else if(boolean-3){
     语句块3
   }else{
     语句块4
   }

执行过程：

• 判断boolean-1，若为true则执行语句块1(结束)，若为false则
• 再判断boolean-2，若为true则执行语句块2(结束)，若为false则
• 再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束)
  说明： 语句块1/2/3/4，只能执行其中之一------------多选1

public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();

        //带数(-25,888,95,85,65,45)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }
    }
}

switch…case结构：多条路

• 优点：效率高、结构清晰
• 缺点：只能对整数判断相等
• break：跳出switch
• 常见面试题：switch可以作用于什么类型的数据上
  -------------------------byte,short,int,char,String,枚举类型

public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.取款  2.存款  3.查询余额  0.退卡");
        int command = scan.nextInt();

        switch(command){
            case 1:
                System.out.println("取款操作...");
                break;
            case 2:
                System.out.println("存款操作...");
                break;
            case 3:
                System.out.println("查询余额操作...");
                break;
            case 0:
                System.out.println("退卡操作...");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

循环：反复多次执行一段相同或相似的代码

循环三要素：

• 循环变量的初始化
• 循环的条件(以循环变量为基础)
• 循环变量的改变(向着循环的结束变)
  循环变量：在整个循环过程中所反复改变的那个数

//跑3圈:
循环变量:所跑圈数count
1)int count=0;
2)count<3
3)count++;
  count=0/1/2/ 3时结束

                     圈数为0
够3圈吗？ 不够  跑一圈  圈数为1
够3圈吗？ 不够  跑一圈  圈数为2
够3圈吗？ 不够  跑一圈  圈数为3
够3圈吗？ 够了

//打印机打印6份简历:
循环变量:所打份数num
1)int num=0;
2)num<6
3)num++;
  num=0/1/2/3/4/5/ 6时结束
                      份数为0
够6份吗？ 不够  打印一份  份数为1
够6份吗？ 不够  打印一份  份数为2
够6份吗？ 不够  打印一份  份数为3
够6份吗？ 不够  打印一份  份数为4
够6份吗？ 不够  打印一份  份数为5
够6份吗？ 不够  打印一份  份数为6
够6份吗？ 够了

循环结构：

while结构：先判断后执行，有可能一次都不执行
语法：

while(boolean){
      语句块-------------反复执行的代码
    }

执行过程：

• 判断boolean的值，若为true则执行语句块
• 再判断boolean的值，若为true则再执行语句块
• 再判断boolean的值，若为true则再执行语句块
• 如此反复，直到boolean的值为false时，while循环结束

//1)输出5次"行动是成功的阶梯":
int times = 0;  //1)循环变量的初始化
while(times<5){ //2)循环的条件
    System.out.println("行动是成功的阶梯");
    times++;    //3)循环变量的改变
}
System.out.println("继续执行...");

/*
  执行过程:----带数
                times=0
    true  输出  times=1
    true  输出  times=2
    true  输出  times=3
    true  输出  times=4
    true  输出  times=5
    false while循环结束
    输出继续执行...
 */

//2)输出9的乘法表:
int num = 1;     //3*9=27
while(num<=9){
    System.out.println(num+"*9="+num*9);
    num++;  //num+=2;
}
System.out.println("继续执行...");

猜数字小游戏代码：

public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //300(大),200(小),250(对)
        System.out.println("猜吧!");
        int guess = scan.nextInt(); //1.
        while(guess!=num){ //2.
            if(guess>num){
                System.out.println("太大了");
            }else{
                System.out.println("太小了");
            }
            System.out.println("猜吧!");
            guess = scan.nextInt(); //3.
        }
        System.out.println("恭喜你猜对了!");
    }
}

do…while结构：先执行后判断，至少执行一次

要素1与要素3相同时，首选do…while
语法：

  do{
     语句块
   }while(boolean);

执行过程：

• 先执行语句块，再判断boolean的值，若为true则
• 再执行语句块，再判断boolean的值，若为true则
• 再执行语句块，再判断boolean的值，若为true则
• 再执行语句块，如此反复，直到boolean的值为false，则 do…while结束
  猜数字小游戏代码：

public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //假设num=250
        //300(大),200(小),250(对)
        int guess;
        do{
            System.out.println("猜吧!");
            guess = scan.nextInt(); //1+3
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
        }while(guess!=num); //2
    }
}

for结构：应用率高、与次数相关的循环

语法：

      //  1     2    3
    for(要素1;要素2;要素3){
        语句块/循环体----------------反复执行的代码    4
     }

执行过程:1243243243243243243…2

//for循环中的循环变量i，作用域仅在当前for中
for(int i=1;i<=9;i++){
    System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;i+=2){
    System.out.println(i+"*9="+i*9);
}
for(int i=9;i>=1;i--){
    System.out.println(i+"*9="+i*9);
}

for(int times=0;times<5;times++){
    System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
/*
执行过程:
times=0  true  输出
    times=1  true  输出
    times=2  true  输出
    times=3  true  输出
    times=4  true  输出
    times=5  false for循环结束
    输出继续执行...
*/

//for的特殊格式:----------了解
int i=1;
for(;i<=9;i++){
    System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;){
    System.out.println(i+"*9="+i*9);
    i++;
}
for(;;){ //没有条件的循环就是一个死循环
    System.out.println("我要学习...");
}

for(int i=1,j=5;i<=5;i+=2,j-=2){
}
/*
  i=1,j=5  true
  i=3,j=3  true
  i=5,j=1  true
  i=7,j=-1 false
 */

三种循环结构的选择规则：

先看循环是否与次数相关：
若相关----------------------------直接上for
若无关，再看要素1与要素3是否相同：
若相同------------------------直接上do…while
若不同------------------------直接上while

补充：
break：跳出循环

for(int i=1;i<=9;i++){
    if(i==4){ //在某种特定条件下，提前结束循环
        break;
    }
    System.out.println(i+"*9="+i*9);
}
/* 
  i=1  true  1*9=9
  i=2  true  2*9=18
  i=3  true  3*9=27
  i=4  true
*/        

continue：跳过循环体中剩余语句而进入下一次循环

//输出9的乘法表，只要不能被3整除的
for(int i=1;i<=9;i++){
    if(i%3!=0){
        System.out.println(i+"*9="+i*9);
    }
}

//输出9的乘法表，跳过能被3整除的
for(int i=1;i<=9;i++){
    if(i%3==0){
        continue; //跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(i+"*9="+i*9);
}
/*
    i=1  1*9=9
    i=2  2*9=18
    i=3
    i=4  4*9=36
    i=5  5*9=45
    i=6
    i=7  7*9=63
    i=8  8*9=72
    i=9
    i=10
*/

变量的作用域/范围：从变量的声明开始，到包含它最近的大括号结束
任何复杂的程序逻辑都可以通过三种结构来实现：

• 顺序结构：从上往下逐行执行，每句必走
• 分支结构：有条件的执行某语句一次，并非每句必走
• 循环结构：有条件的执行某语句多次，并非每句必走

随机加法运算器案例：

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //总分
        for(int i=1;i<=10;i++) { //10次
            int a = (int)(Math.random()*100); //加数a，0到99之间
            int b = (int)(Math.random()*100); //加数b
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题

            System.out.println("算吧!----输入-1可提前结束");
            int answer = scan.nextInt(); //2)答题

            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

嵌套循环：

• 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
• 执行过程：外层循环走一次，内层循环走所有次
• 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
• break只能跳出当前一层循环

for(int num=1;num<=9;num++){ //控制行
    for(int i=1;i<=num;i++){ //控制列
        System.out.print(i+"*"+num+"="+i*num+"t");
    }
    System.out.println(); //换行
}
/*
  执行过程:
    num=3
      i=1  1*3=3
      i=2  2*3=6
      i=3  3*3=9
      i=4  false
      换行
    num=2
      i=1  1*2=2
      i=2  2*2=4
      i=3  false
      换行
    num=1
      i=1  1*1=1
      i=2  false
      换行
 */

最后

以上就是秀丽百褶裙为你收集整理的Day04 分支结构以及循环分支结构：基于条件执行某语句循环：反复多次执行一段相同或相似的代码的全部内容，希望文章能够帮你解决Day04 分支结构以及循环分支结构：基于条件执行某语句循环：反复多次执行一段相同或相似的代码所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。