06 分支结构，switch结构，for循环，while及do while循环

于 2021-09-08 16:30:54 发布
阅读量311 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whatfuswd/article/details/120060019
版权

1 分支结构

1.1 概述

顺序结构的程序虽然能解决计算、输出等问题
但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构

1.2 形式

1.2.1 单分支结构
if (判断条件）{
            代码
}
1.2.2 多分支结构
if (判断条件）{
满足判断条件，执行代码1
}  else {
不满足判断条件，执行代码2
}
1.2.3 嵌套分支结构
if （判断条件1）{
满足判断条件1，执行代码1
} else if （判断条件2） {
满足判断条件2，执行代码2
} else if （判断条件3） {
满足判断条件2，执行代码2
}
.......
1.2.4 练习:商品打折案例

在包day03下创建类TestDiscount.java；
需求: 接收用户输入的原价。满1000打9折;满2000打8折;满5000打5折

package day03;

import java.util.Scanner;

/**需求：接收用户输入的原价，满1000打9折，满2000打8折,满5000打5折*/
public class TestDiscount {
	public static void main(String[] args) {
		//1.提示用户输入原价
		System.out.println("请输入商品原价:");
		//2.接收用户输入的原价
		double price = new Scanner(System.in).nextDouble();                     
		//3.计算打折后的价格
		//3.1定义变量用来保存打折后的价格
		double count = price;//初始值是商品的原价
		//3.2判断用户的打折段位并打折
		if(price >= 5000) {//满5000
			count = price *0.5;//打5折
		}else if(price >= 2000) {//满2000
			count = price * 0.8;//打折8折
		}else if(price >= 1000) {//满1000
			count = price *0.9;//打9折
		}
		//3.3输出用户实际支付的价格
		System.out.println("您实际应该支付:"+count);
	}
}
1.2.5 练习：统计学生分数阶段情况

在包day03下创建类testScore.java；
需求: 练习分支结构，求学员的分数段位，并判断数据的正确性；90分以上优秀；80分以上良好；70分以上一般； 60分以上及格；60分以下不及格；

package day03;

import java.util.Scanner;

/**本类用于练习分支结构，求学员的分数段位，并判断数据的正确性*/
public class testScore {
	//创建程序的入口函数
	public static void main(String[] args) {
		//提示学员输入成绩
		System.out.println("请输入您的分数");
		//接受学员输入的成绩数据,注意记得Scanner要导包
		double cort = new Scanner(System.in).nextDouble();
		
		/**
		 * 90分以上优秀
		 * 80分以上良好
		 * 70分以上一般
		 * 60分以上及格
		 * 60分以下不及格
		 */
		if(cort>100 || cort<0){
			System.out.println("输入的数据有误，请重新输入");
		}else if (cort>=90){
			System.out.println("您的成绩为"+"优秀");
		}else if (cort>=80){
			System.out.println("您的成绩为"+"良好");
		}else if (cort>=70){
			System.out.println("您的成绩为"+"一般");
		}else if (cort>=60){
			System.out.println("您的成绩为"+"及格");
		}else{
			System.out.println("您的成绩为"+"不及格");
		}	
	}
}

2 switch结构

switch case 语句用来判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束
switch-case语句是根据一个整数的不同取值，去判断执行不同的代码。简单来说，该语句是一个只能判断是否相等的分支语句。

2.1 形式

switch( 整数变量 ){
case 值1：语句1；break;
case 值2：语句2；break;
case 值3：语句3；break;
…
default：语句n；
}
注意：
①、如果case语句没有break的话，会发生穿透现象；如果有break语句，程序只会执行该case语句；
②、如果所有case语句都不成立，则执行default语句；通常情况下，default都写在case语句之后，如果写在case之前的话，必须在default语句中使用break语句。
③、在JDK8.0版本以及8.0以上的版本中，switch-case语句可以根据一个字符串的不同，来判断执行不同的代码。

2.2.1 练习-switch基本语句形式
package day03;
//此类是用于练习switch结构
public class testSwitch {
	//创造程序入口函数
	public static void main(String[] args) {
		//定义变量初始值
		int a = 3;
		switch(a) {
		case 1 : System.out.println(1);
		case 2 : System.out.println(2);
		case 3 : System.out.println(3);
		case 4 : System.out.println(4);
		default : System.out.println("没有对应的值");
		//此时没有break语句，所以发生穿透现象，输出了3,4,没有对应的值三个结果；
		}		
	}
}
2.2.2 练习-根据用户输入信息，告知用户一周内的饮食安排，注意识别用户输入的错误值
package day03;
import java.util.Scanner;
/**
 * 本类用于switch的巩固练习
 * 根据用户输入信息，告知用户一周内的饮食安排，注意识别用户输入的错误值
 */
public class testSwitch2 {
	//创建程序的入口函数
	public static void main(String[] args) {
		System.out.println("请输入星期几：");
		String weeked = new  Scanner(System.in).next();
		/*
		 * nextInt() 只能输入整型数据
		 * nextFloat() 能输入整型数据或者浮点型数据
		 * nextDouble() 能输入整型数据或者浮点型数据
		 * nextBoolean() 只能输入true或者false （此处大小写随意 TrUE FAlse都可以）
		 * next() 将数据当字符串接收，返回一个字符串
		 */		
		switch(weeked) {
		case "星期一" : System.out.println("星期一吃火锅");break;  //case中的类型必须和switch中的类型一致，因为前后要进行对比，不一致的无法对比
		case "星期二" : System.out.println("星期二吃炸鸡"); break;
		case "星期三" : System.out.println("星期三吃烧烤"); break;
		case "星期四" : System.out.println("星期四吃羊蝎子"); break;
		case "星期五" : System.out.println("星期五吃川菜"); break;
		case "星期六" : System.out.println("星期六吃粤菜"); break;
		case "星期七" : System.out.println("星期七吃港菜"); break;
		
		default : System.out.println("地球爆炸了？一周不是7天了？");
		}
	}
}
2.2.3 switch结构的注意事项
  1. switch 语句中的变量类型可以是： byte、short、int 、char、String(jdk1.7以后支持)
  2. switch 语句可以拥有多个 case 语句
  3. 每个 case 后面跟一个要比较的值和冒号,且此值的数据类型必须与变量的数据类型一致
  4. 当变量值与 case 语句值相等时，开始执行此case 语句的内容,执行完会判断此行代码是否有break,如果有,结束执行,如果没有,会继续向后执行穿透所有case,包括default
  5. switch 语句可以包含一个 default 分支，该分支一般是写在switch 语句的最后
  6. 如果在default之前的case有break,则default不会执行

3. for循环结构

3.1 概述

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

3.2 形式

for(开始条件；循环条件；更改条件）{
                   循环体
}

3.3 for循环执行顺序

package day03;
/**
 * 本类用于循环引用
 * @author Administrator
 *
 */

public class demo {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++ ) {
			System.out.println(i);
		}		
	}
}

结果输出为：
1    // 从i=1时开始执行循环，判断i是否小于等于10，如果小于等于10，打印输出结果为1，然后自增1；
2    // 自增1后，i=2，判断i是否小于等于10，如果小于等于10，打印输出结果为2，然后自增1；
3    // 自增1后，i=3，判断i是否小于等于10，如果小于等于10，打印输出结果为3，然后自增1；
4    // 自增1后，i=4，判断i是否小于等于10，如果小于等于10，打印输出结果为4，然后自增1；
5    // 自增1后，i=5，判断i是否小于等于10，如果小于等于10，打印输出结果为5，然后自增1；
6    // 自增1后，i=6，判断i是否小于等于10，如果小于等于10，打印输出结果为6，然后自增1；
7    // 自增1后，i=7，判断i是否小于等于10，如果小于等于10，打印输出结果为7，然后自增1；
8    // 自增1后，i=8，判断i是否小于等于10，如果小于等于10，打印输出结果为8，然后自增1；
9    // 自增1后，i=9，判断i是否小于等于10，如果小于等于10，打印输出结果为9，然后自增1；
10    // 自增1后，i=10，判断i是否小于等于10，如果小于等于10，打印输出结果为10，然后自增1；
        //自增1后，i=11，判断i是否小于等于10，11大于10.停止循环，不执行输出结果

3.4 尝试使用for循环打印0-10

package day03;

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

3.5 尝试使用for循环打印10-0

package day03;

public class homework1 {
	public static void main(String[] args) {
		for (int i = 10; i >=0; i--) {
			System.out.println(i);
		}
	}
}

```java
或者可以使用

```java
package day03;

public class homework1 {
	public static void main(String[] args) {
		for (int i = 10; i >=0; --i) {
			System.out.println(i);
		}
	}
}

3.5 思考练习打印输出结果100次

for (int i = 1; i <= 100; i++ ){
System.out.println("循环100次");
}

3.6 思考练习输出打印 8 ，88 ， 888 ， 8888， 这4个结果

	for (int i = 8; i <= 8888; i = i*10+8) {
		System.out.print(i+",");
	}

3.7 for 循环的熟练度练习

		//求出1-100所有的数相加的结果
		int sum = 0;
		for (int i = 1; i <=100; i++) {
			
			sum = sum +i; //把每轮循环到的i累加到sum中
			
		}
		System.out.println(sum);
		
		
		//求1-100以内所有偶数的和
		int sum2 = 0;
		for (int i = 1; i <= 100; i++) {
			if (i%2==0) {
				sum2 = sum2+i;
			}
		}
		System.out.println(sum2);
		
		
		//求1-100以内，所有奇数的和
		int num3 = 0;
		for (int i = 0; i<=100; i++) {
			if (i%2!=0) {
				num3 = num3 + i;
			}
		}
		System.out.println(num3);


		//计算1-100以内所有的奇数的个数和
		int count = 0;
		for(int i = 1; i<=100; i++ ) {
			if (i%2!=0) {
				count++;
			}
		}
		System.out.println(count);

4 嵌套for循环

存在至少2层for循环,根据外层的条件，判断里层能否执行
如果能执行，就把里层代码都循环完毕后，再继续判断是否执行外层循环的下一次循环

4.1 嵌套for形式

for(开始条件;循环条件;更改条件){//外层循环
	
	for(开始条件;循环条件;更改条件){//内层循环
	
		循环体；
	
	}
	
}

4.2 本类用于练习嵌套for循环

package cn.tedu.basic;
/*本类用于测试嵌套for循环*/
public class TestForDemo {
	public static void main(String[] args) {
		//执行顺序
		//执行外层循环第一轮，i=1,打印1，遇到内层循环，打印12345,i自增成2
		//执行外层循环第二轮，i=2,打印2，遇到内层循环，打印12345,i自增成3
		//执行外层循环第三轮，i=3,打印3，遇到内层循环，打印12345,i自增成4
		//i为4，不满足循环条件，循环结束
		/**总结：外层循环执行一次(控制轮数)
		 * 内层循环执行多次(在每一轮中执行的次数)*/
		for(int i = 1; i<=3;i++) {//外层循环
			System.out.println("外层循环的第："+i+"轮");
			for(int j = 1; j <=5 ; j++) {//内层循环
				System.out.println("内层循环的第"+j+"次");
			}
		}
		System.out.println("**************打印矩形******************");
		//执行顺序分析：
		//外层第一轮i=1,遇到内层循环,打印*****,内层循环结束，换行，i自增成2
		//外层第二轮i=2,遇到内层循环,打印*****,内层循环结束，换行，i自增成3
		//外层第三轮i=3,遇到内层循环,打印*****,内层循环结束，换行，i自增成4
		//此时i的值为4，不符合循环条件，循环结束
		/**总结：外层循环控制的是行数
		 * 内层循环控制的是每行打印的列数*/
		for(int i = 1;i<=3;i++) {
			for(int j = 1;j<=5;j++) {
				System.out.print("*");
			}
			System.out.println();//用空白行来换行
		}
	}
}

4.3 打印矩形

		//打印矩形
		for (int i=1 ; i<=3 ; i++) {
			for (int j=1; j<= 5; j++){
				System.out.print("*");	
			}
			System.out.println("*");
		}

外层循环控制的是图形的行数，内层循环控制的是图形的列数

4.4 打印左直三角形

package cn.tedu.basic;
/**需求:利用for循环,打印左直角三角形*/
//行1星1 *
//行2星2 * *
//行3星3 * * *
//行4星4 * * * *
//行i星i * * * * *
public class TestForTriangle {
    public static void main(String[] args) {
        for(int i = 1;i<6;i++) {//外循环
            for (int j = 1; j <=i; j++) {//内循环
                //注意:需要修改内循环的循环条件,让j的最大值随着i改变,否则写死了
                System.out.print("*");//在同一轮/同一行打印不换行
            }
            System.out.println();//空白行用来换行
        }
    }
}

4.5 打印九九乘法表

package cn.tedu.basic;
/**本类用于测试完成99乘法表*/
//1*1=1	
//1*2=2	2*2=4	
//1*3=3	2*3=6	3*3=9	
//1*4=4	2*4=8	3*4=12	4*4=16	
//1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
//1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
//1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
//1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
//1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
public class TestFor99Excel {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {//控制行数,打印9行
            for (int j = 1; j <= i; j++) {//控制列数,i行打印i列
                //System.out.println("*");--打印左直角三角形
                //System.out.println("2*3=6");2--i 3--j 6--i*j
            	//拼接打印算式,后面拼接一个"\t"表示这是表格格式,\t也被称作制表符
                System.out.print(j+"*"+i+"="+(i*j)+"\t");
            }
            System.out.println();//空白行用来换行
        }
    }
}

5 break和continue的实际应用

5.1 概念

break: 直接结束当前循环,跳出循环体,简单粗暴

break以后的循环体中的语句不会继续执行,循环体外的会执行
注意如果是嵌套for循环,在内层循环遇到了break,只会跳出当前这一层内循环哦

continue: 跳出本轮循环,继续下一轮循环

continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

5.1 break的实际应用

制作一个猜数字游戏，给用户100次机会，如果猜到88就结束，没猜到，就一直猜，直到用完所有机会

		for (int i=1;i<=100;i++) {
			
			//提示并接受用户猜的数
			System.out.println("请输入您猜的数字：");
			int number=new Scanner(System.in).nextInt();
			
			//判断用户是否猜对
			if(number!=88) {
				System.out.println("不好意思您猜错了，请重新输入！");  //用户猜错后，提示用户错误，继续循环
				continue; 
				/*
				 * 是用来提高代码效率的，它可以结束本轮循环中后续的代码执行，直接开始新一轮的程序循环
				 * 注意，此处的continue不是决定能不能再次输入的，能输入几次取决于循环次数
				 * 当number不是88时，就没有必要判断后续语句了
				 */
			}
			
			if(number==88) {
				System.out.println("恭喜您，猜对了");break;  //用户才对后，要使用break语句结束循环，停止游戏
			}			
		}

break如果成立，直接跳出这个for循环，执行循环体外接下来的代码；
continue;是结束本轮循环后续的代码，重新执行下一轮循环，注意俩者的不同；

7 while循环

7.1 形式

while 语句是先判断，后执行

while（执行条件）{
     循环体
}

7.2 前序知识

生成随机数方法：需要调用Random方法；使用与Scanner，需要导包；
int r = new Random().nextInt(100);

其中，100，是为了限定int的取值，控制在【0-100）的范围内，包含1，不包含100；

7.3 案例

package day05;

import java.util.Random;
import java.util.Scanner;

/**
 * 本类用于练习while循环
 * @author Administrator
 *
 */
public class testfor5 {
	public static void main(String[] args) {
		//需求：产生一个随机数和用户一直输入的数做比较，直到猜对
		
		
		// 1.生成一个随机数
		int r = new Random().nextInt(100);  //生成一个整数的随机数，用法与Scanner一致
		//    System.out.println(r);
		
		// 2.调用一个自定义的猜数字方法
		guessNum(r);
		
		
		
	}

	private static void guessNum(int r) {//方法定义的时候有参数，方法调用的时候必须传参
		// 设置调用的方法
		/**
		 * while(判断是否能继续循环的条件）{如果条件的结果为true执行此处循环体的内容}
		 * 所以，我们用while写死循环，格式while（true）
		 * 一定注意，死循环设置程序的出口--循环什么时候结束
		 */
		while(true) {//设置了一个一直会执行的死循环
			//1.接收用户猜的数字
			System.out.println("请输入您要猜的数：");
			int input = new Scanner(System.in).nextInt();
			
			//2.判断用户猜对没有
			if(input>r) {
				System.out.println("猜大了");
			}else if(input<r) {
				System.out.println("猜小了");
			}else if(input==r) {
				System.out.println("猜对了");
				break;  //本处是死循环的出口
			}

		}
		
	}
}

7.4 do while 循环

7.5 形式

do{
    循环体
}while （执行条件）；

7.6 执行顺序

do while 循环不判断条件，先执行一次循环体输出，然后根据后续while中的执行条件进行判断，如果符合，那么继续执行，如果不符合，停止执行

7.7 案例

package day05;

import java.util.Random;

/**
 * 此类用于do while循环的练习
 * @author Administrator
 *
 */
public class testDowhile {

	public static void main(String[] args) {
		//
		int a;
		do {
			System.out.println("我是循环体");
			a = new Random().nextInt(100);
			System.out.println(a); 
			
		}while(a>50);
		
	}
}

如果第一次生成的随机数大于50，那么再次执行do中循环体，直至不满足while中执行条件时，停止执行；

蟑螂恶霸不是恶霸
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值