首页 > 编程语言> 文章详细

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

2021-10-30 22:32:20 阅读：205 来源： 互联网

标签：Java Scanner int System 第五章程序控制 println public out

简单介绍

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

（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,Scanner,int,System,第五章,程序控制,println,public,out
来源： https://blog.csdn.net/a2649432564/article/details/121057548

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

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