Java基础第五章程序控制结构（空心金字塔）

2021/10/30 22:39:54

编程Tag： Java int out system public Scanner println 第五章程序控制

本文主要是介绍Java基础第五章程序控制结构（空心金字塔），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

简单介绍

在程序中，程序运行的流程控制决定程序是如何执行的，主要有三大流程控制语句

（1）顺序控制

（2）分支控制

（3）循环控制

顺序控制

程序从上到下逐行地执行，中间没有任何判断和跳转

Java中定义变量时采用合法的前向引用如：

public class Test{
    int num1 = 1;
    int num2 = num1 + 2;
    //这句话的意思就是说，只有前面先定义了，后面才能用
}

分支控制

单分支

基本语法

if（条件表达式）{

执行代码块

}

例：编写一个程序，可以输入人的年龄，如果输入的年龄大于18，则输出“年龄大于18，要对自己的行为负责，否则送入监狱”

import java.util.Scanner;
public class If01{
    public static void main(String[] args){
        Scanner Input = new Scanner(System.in);
        int age = Input.nextInt;
        if(age > 18){
            System.out.println("年龄大于18，要对自己的行为负责，送入监狱");
        }
        System.out.println("请再次输入");
    }
}

双分支

基本语法

if（条件表达式）{

执行代码块1；

}else{

执行代码块2；

}
例：编写一个程序，可以输入人的年龄，如果输入的年龄大于18，则输出“年龄大于18，要对自己的行为负责，送入监狱”，否则，输出“你的年龄不够大，这次先放过你”

import java.util.Scanner;
public class If02{
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        int age = myScanner.nextInt();
        if(age>18){
            System.out.println("年龄大于18，要对自己的行为负责，送入监狱");
        }else{
            System.out.println("你的年龄不够大，这次先放过你");
        }
    }
}

单双分支练习题

（1）编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第二个数小于20.0,打印两数之和

import java.util.Scanner;
public class IfExercise01{
    public static void main(String[] args){
        Scanner myScanner =new Scanner(System.in);
        double d1 = myScanner.nextDouble();
        double d2 = myScanner.nextDouble();
        if(d1 > 10.0 && d2 <20.0){
            System.out.println(d1+d2);
        }
        
    }
}

（2）定义两个变量int，判断二者之和，是否能被3又被5整除，打印提示信息

public class IfExercise02{
    public static void main(String[] args){
        int a = 10;
        int b = 5;
        int c = a+b;
        if(c % 3 == 0 && c % 5 == 0){
            System.out.println("您真棒");
        }else{
            System.out.println("这个数字不符合要求")；
        }
    }
}

（3）判断一个年份是否是闰年

//闰年的条件是 符合下面二者之一：
//（1）年份能被4整除，但不能被100整除；（2）能被400整除
public class IfExercise03{
    public static void main(String[] args){
        int year = 2023;
        if((year%4 == 0 && year%100 !=0) || year%400 == 0){
            System.out.println("这一年是闰年");
        }else{
            System.out.println("这一年不是闰年")；;
        }
    }
}

多分枝

基本语法

if(条件表达式1){

执行代码块1；

}else if（条件代码块2）{

执行代码块2；

}……

else{

执行代码块3；

}

特别说明：

（1）多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有

（2）如果有else，如果所有的条件表达式都不成立，则默认执行else代码块

例：输入报国同志的信用分：如果（1）信用分为100，输出信用极好

（2）信用分为（80，99】时，输出信用优秀

（3）信用分为（60，80】时，输出信用一般

（4）其他情况，输出信用不及格

（5）请从键盘输入报国的芝麻信用分，并加以判断

import java.util.Scanner;
public class IfExercise04{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入信用分(1-100)");
		double  score = myScanner.nextDouble();
		if (score >= 1 && score <= 100)//输入的约束条件，在一个双分支里嵌套一个多分枝 {
		if(score == 100){
			System.out.println("信用极好");
		}else if(score > 80 && score <= 99){
			System.out.println("信用优秀");
		}else if(score > 60 && score <= 80){
			System.out.println("信用一般");
		}else{
			System.out.println("信用不及格");
		}

		}else{
			System.out.println("输入有误，请重新输入:)");
		}
	}
}

嵌套分支（套娃:)）

基本介绍：在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支。建议：不要嵌套超过三层。（代码可读性变差）
基本语法：

if（）{

if（）{

//if-else……

}else{}

}else
例：参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断和输出信息

import java.util.Scanner;
public class IfExercise05{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入分数（1—10）以及性别");
		double score = myScanner.nextDouble();
		char gender = myScanner.next().charAt(0);
		if(score >= 0 && score <= 10){
		if(score >= 8.0){
			if(gender == '女'){
				System.out.println("恭喜你成功进入女生组");
			}else{
				System.out.println("恭喜你成功进入男生组");
			}
		}else{
		System.out.println("很遗憾，你没能进入到下一阶段的比赛");
	}
}else{
	System.out.println("输入错误，请从新输入：）");
}
	}
}

例2：出票系统：根据淡旺季的月份和年龄，打印票价

4—10旺季：

成人（18-60）：60

儿童（<18）：半价

老人（>60）:1/3

淡季：

成人：40

其他：20

import java.util.Scanner;
public class IfExercise06{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入您想去的月份（1—12）");
		
		int month = myScanner.nextInt();
		
		if(month > 0 && month < 12){
			System.out.println("请输入您的年龄");
			int age = myScanner.nextInt();
		if(month >= 4 && month <= 10){
			if(age >= 18 && age <=60){
				System.out.println("您的票价为60元");
			}else if(age < 18){
				System.out.println("您享受半价活动，只需30元");
			}else if(age > 60){
				System.out.println("您只需支付原价的1/3,20元");

			}else{
				System.out.println("您输入的年龄错误，请重新输入");
			}

		} else{
			if(age >= 18 && age <= 60){
				System.out.println("您的票价为40元");
			}else{
				System.out.println("您的票价为20元");
			}
		}
	}else{
		System.out.println("您输入的月份有误，请重新输入");
	}
	}
}

switch分支结构

基本语法：

switch（表达式）{

case 常量1：

语句块1；

break；

case 常量2：

语句块2；

break；

……
```
   default：
```
default语句块；

break；

}

注意

如果判断结束后的语句块没有写break，那么将执行剩余所有的语句块，直到遇到break为止。

switch细节：

（1）表达式数据类型应和case后的常量类型一致，或者可以自动转换成可以相互比较的类型，比如输入的字符，而常量是int，此时就会报错。

（2）switch中表达式的返回值必须是：（byte，short，int，char，enum（枚举），String）

（3）case子句中的值必须是常量，而不能是变量

（4）default子句时可选的，当没有匹配的case时，执行default

（5）break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾，除非遇到break。
练习

（1）使用switch把小写类型的char转为大写（键盘输入）。只转换a，b，c。其他输出other。

import java.util.Scanner;
public class Switch01{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个字母");
		char eng = myScanner.next().charAt(0);
		switch(eng){
			case 'a':
				System.out.println("A");
				break;
			case 'b':
				System.out.println("B");
				break;
			case 'c':
				System.out.println("C");
			default:
				System.out.println("other");

		}
	}
}

（2）对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”（注：输入的成绩不能大于100）。

import java.util.Scanner;
public class Switch02{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入您的成绩");
		int score = myScanner.nextInt();
		int score1 =score / 60;//大于60的成绩得到1，小于60的成绩得到0
		if (score >=0 && score <=100){
		switch(score1){
			case 1:
				System.out.println("您已及格");
				break;
			case 0:
			System.out.println("您未及格");
			break;
			default:
				System.out.println("您输入的成绩有误");
		}
	}else{
		System.out.println("您输入的成绩无效");
	}
}
}

（3）根据用于指定月份，打印该月份所属季节。（使用穿透）

import java.util.Scanner;
public class Switch03{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个月份");
		int month = myScanner.nextInt();
		if(month > 0 && month <=12){
			switch(month){
				case 3:
				case 4:
				case 5:
					System.out.println("现在是春季");
					break;
				case 6:
				case 7:
				case 8:
					System.out.println("现在是夏季");
					break;
				case 9:
				case 10:
				case 11:
					System.out.println("现在使秋季");
					break;
				case 12:
				case 1:
				case 2:
					System.out.println("现在是冬季");
					break;
			}
		}else{
			System.out.println("您输入的月份有误");
		}
	}
}

for循环控制

基本语法：

for（循环变量初始化；循环条件；循环变量迭代）{

循环操作（语句）；}
例：打印10句“你真帅”

public class Hello{
public static void main(String[] args){
	int i = 10;
	for(i = 0;i<10;i++){
	System.out.println("你真帅");
	}
}	
}

细节

（1）循环条件是返回一个布尔值的表达式

（2）for（；循环判断条件；）中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略。

（3）循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

例：打印1~100之间所有是9的倍数，统计个数及总和

public class ForExercise01{
    public static void main(String[] args){
		int j = 0;//一定要记得定义初始值
		int sum = 0; 
        //把起始值和结束值变成变量
        //int star = 1；
        //int end = 100；
        for(int i = 1/*star*/; i <= 100/*end*/ ; i++){
            if(i % 9 == 0){ 
                System.out.println(i);
                j++;
				sum +=i;
            }
        }
		System.out.println("个数为" + j+'\n' +"总和为" + sum);
    }
}

（2）完成下面表达式的输出：

0+5=5

1+4=5

2+3=5

3+2=5

4+1=5

5+0=5

public class ForExercise02{
	public static void main(String[] args){

		for (int i=0,j=5;i<6;i++,j--){
			int sum = 0;
			sum = i + j;
			System.out.println(i + "+" + j +"="+sum);
		}
	}
}

while循环控制（先问再打）

基本语法：

循环变量初始化；

while（循环条件）{

循环体（语句）；

循环变量迭代；

}

注意：（1）while循环也有四要素，只是四要素放的位置和for不一样

（2）循环条件是返回一个布尔值的表达式

（3）while 循环是先判断再执行语句

练习

（1）打印1--100之间所有能被3整除的数

public class WhileExercise01{
    public static void main(String[] args){
        int i = 1;
        while(i <= 100){
           if(i % 3 == 0){
               System.out.println("i=" + 1);
           }
            i++;
        }
    }
}

（2）打印40--200之间所有的偶数

public class WhileExercise02{
    public static void main(String[] args){
        int j = 40;
        while(j<200){
            if(j % 2 ==0){
                System.out.println("偶数=" + j);
            }
            j++;
        }
    }
}

do..while循环控制（先打再问）

基本语法
循环变量初始化；

do{

循环体（语句）；

循环变量迭代；

}while（循环条件）；
说明：

（1）do while是关键字

（2）也有循环四要素

（3）先执行，再判断，也就是说，一定会执行一次

（4）while最后有一个分号
例：输出10句“你真帅”

public class DoWhileExercise01{
    public static void main(String[] args){
        int i = 0;
        do{
            System.out.println("你真帅");
        }while(i<10);
        System.out.println("退出程序");
    }
}

例：统计1--200之间能被5整除但不能被3整除的个数

public class DoWhileExercise02{
    public static void main(String[] args){
        int i=1;
		int count =0;
        do{
            if(i % 5 == 0 && i % 3 != 0){
                System.out.println(i);
                
				count++;
            }
			i++;//注意
        }while(i<=200);
        System.out.println("程序正在运行...");
    }
}

例：如果李三不还钱，则老程将一直使出打狗棍，直到李三说还钱为止

import java.util.Scanner;
public class Hello{
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
       char answer =' ';
        do{
            System.out.println("老程使出打狗棍");
            System.out.println("接着问，李三你到底还不还钱y/n");
            answer = myScanner.next().charAt(0);
            System.out.println("李三的回答是"+answer);
           
        }while(answer != 'y');
        System.out.println("你可终于还钱了");
    }
}

多重循环控制

简单介绍

（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中for，while，do......while均可作为外层循环和内层循环。（建议一般使用两层，否则代码的可读性很差）

（2）实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
例：（1）统计3个班成绩情况，每个班5名同学，求出各个班的平均分和所有班级的平均分,并统计三个班的及格人数【学生的成绩从键盘输入】

import java.util.Scanner;
public class MulForExercise01{
    public static void main(String[] args){         
        int num = 0//定义一个变量用来统计人数
        double totalscore = 0.0; //还得定义一个变量统计所有学生的成绩
        Scanner myScanner = new Scanner(System.in);
        for(int j = 1;j <= 3;j++){
            double sum = 0;//用来统计总和
            System.out.println("接下来请输入第"+j+"个班学生的成绩");
                for(int i = 1;i <= 5;i++){ //先计算一个班五个同学的成绩
                System.out.println("请输入第"+j+"个班的第"+i+"个学生的成绩");
                double score = myScanner.nextDouble();
                    if(score>=60){
                        num++;
                    }
                 sum += score;//对成绩求和
        }
         double average = 0.0;
         average = sum/5.0;
         System.out.println("第"+j+"个班五名同学的平均分是"+average);
            totalscore += sum;
        }                     
        System.out.println("全体同学的平均分是："+totalscore/(3*5)+"分");
        }
    }

例（2）打印出九九乘法表

public class MulForExercise02{
    public static void main(String[] args){
        for(int i = 1;i <= 9; i++){
        for(int j = 1;j <= i; j++){
            System.out.print(j + "*"+ i + "="+ j*i+'\t');
        }
            System.out.println('\n');
        }
    }
}

例（3）经典的打印金字塔

public class MulForExercise03{
    public static void main(String[] args){
        for(int i = 1; i <= 5;i++){
            for(int j = 1;j<=2*i-1;j++){
                for(int k = 5;k<=k-1;k--){
                    System.out.print('\t');
                }
                System.out.print("*");
            }
            System.out.println('\n');
        }
    }
}

例（4）打印空心金字塔（行数由输入确定）

import java.util.Scanner;
public class MulForExercise04{
  public static void main(String[] args){
    System.out.println("请输入您需要空心菱形的行数");
    Scanner myScanner = new Scanner(System.in);
    int num = myScanner.nextInt();
        for(int i = 1; i <= num;i++){
            for(int k = 1;k<=num-i;k++){
                    System.out.print(' ');
                }
            for(int j = 1;j<=2*i-1;j++){              
                if(j == 1 || j == 2*i-1 || i == num){
                System.out.print("*");}
                else{
                    System.out.print(' ');
                }
                
            }
            System.out.println('\n');
        }
    }
}

例（5）例（4）进阶版：打印空心菱形

import java.util.Scanner;
public class Hello{
  public static void main(String[] args){
    System.out.println("请输入您需要空心菱形的行数");
    Scanner myScanner = new Scanner(System.in);
    int num = myScanner.nextInt();
        for(int i = 1; i <= num;i++){
            for(int k = 1;k<=num-i;k++){
                    System.out.print(' ');
                }
            for(int j = 1;j<=2*i-1;j++){              
                if(j == 1 || j == 2*i-1 ){
                System.out.print("*");}
                else{
                    System.out.print(' ');
                }
                
            }
            System.out.println('\n');
        }
         for(int x = num-1; x >= 1;x--){
            for(int y = 1;y <= num-1-(x-1);y++){
                    System.out.print(' ');
                }
            for(int z = 1;z<=2*x-1;z++){              
                if(z == 1 || z == 2*x-1 ){
                System.out.print("*");}
                else{
                    System.out.print(' ');
                }
                
            }
            System.out.println('\n');
        }
    }
}

break

例1随机生成1-100的一个数，直到生成了97这个数，看看一共用了几次

public class BreakExercise01{
    public static void main(String[] args){
        int count = 0;
        for(int i = 1;i<=10;i++){
             int num = (int)(Math.random()*100)+1;
            count++;
            while(num == 97){
            System.out.println(count);
				break;				
        }					
		}
		System.out.println("这一轮没有生成97");
    }
}

注意事项：

（1）break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块。例：

public class BreakLable{
    public static void main(String[] args){
        lable:
        for(int j = 0; j < 4;j++){
            lable2:
            for(int i = 1;i < 10;i++){
                if(i == 2){
                    break lable1;
                }
                System.out.println("i="+i);
            }
        }
    }
}

小细节

（1）break语句可以指定退出哪层

（2）建议在实际开发中，不要使用标签

（3）如果没有指定break，默认退出最近的循环体
例：（1）1-100以内的数求和，求出当和第一次大于20的当前数

public class BreakExercise01{
    public static void main(String[] args){
		int sum = 0;
        for(int i=1 ;i <=100;i++){           
            sum += i;
            if(sum > 20){
                System.out.println("累加和已经大于20" + '\n'+ i);
                break;
            }
        }
    }
}

例（2）实现登录验证，有三次机会，如果用户名为”karry“，密码为”0921“提示登陆成功，否则提示还有几次机会

import java.util.Scanner;
public class BreakExercise02{
    public static void main(String[] args){
         Scanner myScanner = new Scanner(System.in);     
         int chance=3;  
        for(int i = 1;i<=3;i++){
      System.out.println("请输入您的用户名");
            String username = myScanner.next();
       System.out.println("请输入您的密码");
            String password = myScanner.next();
        if("karry".equals(username) && "0921".equals(password)){//equals用来比较字符串是否相等
            System.out.println("恭喜你，成功登录"); 
            break;
        }else{
            
            chance--;
            if(chance > 0){
            System.out.println("您输入的信息有误，请重新输入,您还有"+chance+"次登录机会");}
            else{
                System.out.println("您的机会已用完，账号冻结");
            }
        }
        }
    }
}

continue

基本介绍

（1）continue语句用于结束本次循环，继续执行下一次循环。

（2）continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环。

return

return使用在方法时，表示跳出所在方法。

public class Return{
    public static void main(String[] args){
        for(int i = 1;i <= 5;i++){
            if(i==3){
                System.out.println("今天天气真好");
            }
            System.out.println("今天心情真好");
        }
        System.out.println("今天是个好日子");
    }
}
//输出的结果是：今天心情真好
             //今天心情真好
             //今天天气真好

本章作业

（1）某人有100000元，每经过一次路口都需要缴费，规则如下：

1）当现金>50000时，每次交5%

2）当现金<=50000时，每次交1000

编程计算该人可以经过多少次路口

public class Homework01{
    public static void main(String[] args){
        double money = 100000;
        int count =0;
        while(true){
            if(money > 50000){
                money*=0.95;
                count++;
            }else if(money >=1000){
                money-=1000;
                count++;
            }else{
                break;
            }
        }
        System.out.println("一共通过了"+count+"个路口");
        System.out.println("还剩"+money)；
        }
    }

（2）实现判断一个一个整数，属于那个范围：大于0；小于0；等于0；

import java.util.Scanner;
public class HomeWork02{
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in)
        System.out.println("请输入您想要判断的数");
        int num = myScanner.nextInt();
        if(num>0){
            System.out.println("这是一个大于0的整数");}
            if(num<0){
                System.out.println("这是一个小于0的数");}
                if(num==0){
                    System.out.println("这个数为0");
                           
        }
    }
}

（3）判断一个年份是否为闰年

import java.util.Scanner;
public class Homework03{
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in)
        System.out.println("请输入您想要判断的年份");
        int year = myScanner.nextInt();
        if(year % 4 == 0 && year % 100 != 0 || year % 400 ==0){
            System.out.println("这一年是闰年");
        }
        System.out.println("这一年不是闰年");
    }
}

（4）判断一个数字是否是水仙花数，所谓水仙花数是指一个三位数，其各个位上数字立方和等于其本身

import java.util.Scanner;
public class HomeWork04{
    public static void main(String[] args){
        System.out.println("请输入一个三位数");
        Scanner myScanner = new Scanner(System.in);
        int i = myScanner.nextInt();
        if(i>99 && i<=999){
        int a=i / 100;
        int b=(i % 100)/10;
        int c=(i%10);
        if((a*a*a + b*b*b + c*c*c) == i){
            System.out.println("这是一个水仙花数");
        }else{
            System.out.println("这不是一个水仙花数");
        }
    }
    System.out.println("您输入的数字有误，请看清要求");
    }
}

（5）输出1-100之间不能被5整除的数，每五个一行

public class HomeWork05{
   public static void main(String[] args){
        int count = 0;
        for(int i = 1;i <= 100;i++){
            if(i % 5 != 0){                
                    System.out.print(i + "\t");
                    count++;
                    if(count % 5 == 0){
                        System.out.println();
                    }
            }
        }
    }
}

（6）输出小写的a-z以及大写的Z-A

public class HomeWork06{
   public static void main(String[] args){
        for(char c1 = 'a';c1 <= 'z';c1++ ){//字符是可以比较大小的
            System.out.print(c1 +" ");}
            System.out.print("\n");
        for(char c2 = 'Z';c2 >='A';c2--){
            System.out.print(c2 + " ");
        }
    }
}

（7）求出1-1/2+1/3+……+1/100的和

public class HomeWork07{
   public static void main(String[] args){
            int sum = 0;            
        for(int i = 1;i <= 100;i++){
           for(int j =1; j <= i;j++){
            sum += j;
           }           
        }
        System.out.println(sum);        
    }
}

这篇关于Java基础第五章程序控制结构（空心金字塔）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java基础 第五章 程序控制结构（空心金字塔）