Java基础 控制选择语句-控制循环语句-改变控制语句顺序

鳄鱼君

发表文章数:643

热门标签

,

Vieu四代商业主题

高扩展、安全、稳定、响应式布局多功能模板。

¥69 现在购买
首页 » Java » Java基础 控制选择语句-控制循环语句-改变控制语句顺序

选择结构

if语句的语法结构,编写方式:

第一种方式
if(布尔表达式){
    java语句;
    ...
}

第二种方式
if(布尔表达式){
   java语句;
   ...
}else{
   java语句;
   ...
}

第三种方式
if(布尔表达式){
    java语句;
    ...
}else if(布尔表达式){
    java语句;
    ...
}else if(布尔表达式){
    java语句;
    ...
}...

第四种方式
if(布尔表达式){
    java语句;
    ...
}else if(布尔表达式){
    java语句;
    ...
}else if(布尔表达式){
    java语句;
    ...
}else{
    java语句;
    ...
}

对于Java种的if语句来说,只要有一个分支执行,整个if语句全部都结束!如果分支带有else,此时百分之百会有一个分支执行!所有的控制语句都可以嵌套使用。if语句的分支中只有一条java语句,大括号可以省略:

if(布尔表达式) java语句;

现在需要根据学生的成绩判断学生的成绩等级,【90~100】A级,【80~90】B级,【70~80】C级,【60~70】D级,【0~60】E级,成绩要求范围【0~100】,且可能带有小数:

public class IfTest
{
	public static void main(String[] args){
		int studentScore = 80;

		if (studentScore < 0 || studentScore > 100){
			System.out.println("学生成绩不合法");
		}
		else if(studentScore >= 90){
			System.out.println("你被评定为A级");
		}else if(studentScore >= 80){
			System.out.println("你被评定为B级");
		}else if(studentScore >= 70){
			System.out.println("你被评定为C级");
		}else if(studentScore >= 60){
			System.out.println("你被评定为D级");
		}else{
			System.out.println("你被评定为E级");
		}
	}
}

另一种方式

public class IfTest
{
	public static void main(String[] args){
		int studentScore = 80;
		String result = "你被评定为E级";

		if (studentScore < 0 || studentScore > 100){
			result = "学生成绩不合法";
		}
		else if(studentScore >= 90){
			result = "你被评定为A级";
		}else if(studentScore >= 80){
			result = "你被评定为B级";
			
		}else if(studentScore >= 70){
			result = "你被评定为C级";
		}else if(studentScore >= 60){
			result = "你被评定为D级";
		}
		System.out.println(result);
	}
}

现在想要动态的获取分数,接受用户键盘的输入:

public class IfTest
{
	public static void main(String[] args){
		// 创建键盘扫描对象
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入你的分数【0~100】:");
		// 调用Scanner对象的next()方法,开始接受用户键盘输入
		// 程序执行到这里会卡住,等待用户输入
		// 接受类型为 字符串类型
		// String userInputContent = s.next();
		
		// 接受类型为 整数型
		int studentScore = s.nextInt();

		System.out.println("studentScore:" + studentScore);
		String result = "你被评定为E级";

		if (studentScore < 0 || studentScore > 100){
			result = "学生成绩不合法";
		}
		else if(studentScore >= 90){
			result = "你被评定为A级";
		}else if(studentScore >= 80){
			result = "你被评定为B级";
			
		}else if(studentScore >= 70){
			result = "你被评定为C级";
		}else if(studentScore >= 60){
			result = "你被评定为D级";
		}
		System.out.println(result);
	}
}
判断今天天气:
    当外边下雨的时候:
        带雨伞:
              男:带黑伞
              女:带红伞
    当外边是晴天:
        判断天气温度:
            温度30°以上:
                 男:戴墨镜
                 女:擦防晒霜

按照简单的逻辑进行判断,代码可以按照下面的方式写:

public class IfTest
{
	public static void main(String[] args){
		// 天气,温度,性别,需要从键盘的接收
		java.util.Scanner s = new java.util.Scanner(System.in);

		System.out.print("今天天气怎么样?【rain / sunny】:");
		String weather = s.next();

		System.out.print("你的性别是:【male / female】:");
		String gender = s.next();
		// equals比较字符串是否相等,==是比较内存地址的
		if( weather.equals("rain") ){

			if( gender.equals("male") ){
				System.out.println("今天下雨了,你需要打一把黑色的伞");
			}else if( gender.equals("female") ){
				System.out.println("今天下雨了,你需要打一把红色的伞");
			}else{
				System.out.println("你到底什么性别?");
			}

		}else if( weather.equals("sunny") ){
			System.out.print("今天的温度大约是多少:");
			int temperature = s.nextInt();

			if(temperature > 30){
				if( gender.equals("male") ){
					System.out.println("今天下雨了,你需要打一把黑色的伞");
				}else if( gender.equals("female") ){
					System.out.println("戴墨镜");
				}else{
					System.out.println("擦防晒霜");
				}
			}else{
				System.out.println("今天天气不是很热!");
			}

		}else{
			System.out.println("输入信息有误");
		}
	}
}

if只有一条语句的时候,可以省掉大括号:

public class IfTest
{
	public static void main(String[] args){
		boolean sex = true;
		// 正确
		if (sex) System.out.println("男");else System.out.println("女");
		
		// 编译报错,12行,else缺少if
		//if (sex)
		//	System.out.println("男");
		//	System.out.println("报错");
		//else
		//	System.out.println("女");

		if (sex)
			System.out.println("男");
			System.out.println("输出");//这一行的输出跟if没有关系

	}
}

switch语句也属于选择结构,也是分支语句。语法格式:

switch(int/String类型的字面值/变量){
    case int/String类型的字面值/变量:
        java语句;
        ...
        break;
    case int/String类型的字面值/变量:
        java语句;
        ...
        break;
    default:
        java语句;
        ...
}

注意:

  1. switch语句后面小括号当中的“数据”和case后面的“数据”进行匹配,匹配成功的分支执行,按照自上而下的顺序执行。
  2. 匹配成功的分支执行,分支中存在“break”语句,整个switch语句会终止
  3. 匹配成功的分支执行,分支中没有“break”语句,直接进入下一个分支执行(不进行匹配),这种现象叫做case穿透现象
  4. 所有的分支都没有匹配成功,如果存在default语句,则会执行default语句的程序
  5. switch和case只能是int/String类型的数据,不能是其它类型。在JDK7以上版本,byte、short、char也可以直接写在switch和case后面,因为它们可以进行自动类型转换,自动转换为int类型
public class SwitchTest
{
	public static void main(String[] args){
			
		long x = 100L;
		//编译报错
		//switch(x){}

		//解决编译报错
		switch((int)x){}

		byte b = 20;
		switch(b){}
		
		short c = 20;
		switch(c){}
		
		char d = 'a';
		switch(d){}

		//编译报错
		//switch(false){}

		String name = "鳄鱼君";
		switch(name){}
		
	}
}

再来看一个完整的switch语句:

public class SwitchTest
{
	public static void main(String[] args){
			
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入数字:");
		int num = s.nextInt();

		switch(num){
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("输入的数字不合法");

		}
	}
}

case穿透,如果不加break语句,会从开始穿到结尾:

public class SwitchTest
{
	public static void main(String[] args){
			
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入数字:");
		int num = s.nextInt();

		switch(num){
			case 1:
				System.out.println("星期一");
			case 2:
				System.out.println("星期二");
			case 3:
				System.out.println("星期三");
			case 4:
				System.out.println("星期四");
			case 5:
				System.out.println("星期五");
			case 6:
				System.out.println("星期六");
			case 7:
				System.out.println("星期日");
			default:
				System.out.println("输入的数字不合法");

		}
	}
}

case合并:

public class SwitchTest
{
	public static void main(String[] args){
			
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入数字:");
		int num = s.nextInt();

		switch(num){
			case 1: case 0:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("输入的数字不合法");

		}
	}
}

需要注意的是switch和case后面的类型只能是int/String,我们可以使用switch语句实现一个简单的计算器:用户输入第一个数字,输入运算符,用户输入第二个数字,然后返回结果:

public class SwitchTest
{
	public static void main(String[] args){
			
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入第一个数字:");
		int numOne = s.nextInt();
		
		System.out.print("请输入运算符 [+,-,*,/,%]:");
		String operator = s.next();

		System.out.print("请输入第二个数字[不能为0]:");
		int numTwo = s.nextInt();
		
		int result = 0;
		switch(operator){
			case "+":
				result = numOne + numTwo;
				break;
			case "-":
				result = numOne - numTwo;
				break;
			case "*":
				result = numOne * numTwo;
				break;
			case "/":
				result = numOne / numTwo;
				break;
			case "%":
				result = numOne % numTwo;
				break;
		}
		System.out.println("计算结果:" + numOne + operator + numTwo + "=" + result);
		
	}
}

这里的程序很脆弱,重点是练习switch语句的使用,其它的问题这里先暂且不考虑!

循环结构

在程序当中有一些需要反复/重复执行的代码,这时候就可以把需要反复执行的代码放到“循环体”中,联合计数器控制这段需要反复执行的代码。

for循环

for循环的语法格式:

for( 初始化表达式 ; 布尔表达式 ; 更新表达式 ){
    循环体,java语句构成;
}

注意:

  1. 初始化表达式 、 布尔表达式 、 更新表达式都不是必须的,但是两个分号是必须的
  2. 初始化表达式最先执行,并且在整个for循环当中只执行一次
  3. 布尔表达式必须是true/false,不能是其它值
  4. for循环的执行过程:
  5. 先执行初始化表达式,并且该表达式只执行一次
    判断布尔类型表达式的结果是true/false
    --true,执行循环体,执行更新表达式,判断布尔表达式的结果是true/fasle
    ----...
    --fasle,循环结束
public class ForTest
{
	public static void main(String[] args){
		//打印1~10
		for(int i=1; i<=10; i++){
			System.out.println(i);
		}

		//打印1~10,变量i的作用域仅限于当前for循环内部使用
		for(int i=1; i<=10; i = i + 1){
			System.out.println(i);
		}

                // i变量无法在main方法的作用域当中访问,编译报错
                //System.out.println(i);

		//死循环
		for(; ;){
			System.out.println("死循环");
		}

	}
}

这里涉及到变量的作用域问题:

public class ForTest
{
	public static void main(String[] args){
		//main方法作用域当中的变量,只要main方法没有结束,i就能用
		int i = 0;
		for(; i<10; i++){
			System.out.println("i-->" + i);
		}
		//这里可以访问main方法作用域的变量i
		System.out.println(i);//10

	}
}

for循环也可以这样写:

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

		//输出10以内的奇数
		for(int i=1; i<=10; i+=2){
			System.out.println("i-->" + i);
		}

		for (int i=100; i>=50 ; ){
			System.out.println("i----->" + i);
			i-=10;
		}

		for (int i=100; i>=50 ; ){
			i-=10;
			System.out.println("i-------->" + i);
			
		}

	}
}

循环语句和条件判断语句嵌套使用:

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

		//1~100所有的奇数,推荐
		for (int i=1; i<=100 ; i+=2){
			System.out.println(i);
		}

		//循环语句和条件判断
		for (int i=1; i<=100 ; i++){
			
			if (i%2 != 0){
				System.out.println("奇数:" + i);
			}
			
		}


	}
}

计算1~100之内奇数的和:

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

		int sum = 0;
		//1~100所有的奇数,并求和
		for (int i=1; i<=100 ; i+=2){
			sum +=i;
		}
		System.out.println(sum);

	}
}

for循环嵌套for循环:

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

		for (int i=1; i<=10 ; i+=1){//循环10次

			// 这里是循环体,无论这个循环体当中编写什么程序,这个程序会执行10次
			for (int j=0; j<3 ;j++ ){
				System.out.println("j--->" + j);
			}
			//System.out.println(i);
			//内层循环中的变量名和外层循环的变量名不能重复
			/*for (int i=10; ; ){

			}*/
		}
		
	}
}
public class ForTest
{
	public static void main(String[] args){

		//0 1 2 会被打印9次
		//0 1 2 执行3次
		for (int i=0; i<3 ; i+=1){ //循环10次
			//0 1 2 执行3次
			for (int j=0; j<3 ; j++ ){
				//0 1 2
				for (int k=0; k<3; k++){
					System.out.println("k--->" + k);
				}
			}
		}
		
	}
}
public class ForTest
{
	public static void main(String[] args){

		for (int i=0; i<10 ; i+=1){ 
			System.out.println("Begin");
			for (int j=0; j<3 ; j++ ){
				System.out.println("j-->" + j);
			}
			System.out.println("Over");
		}
		
	}
}

打印99乘法表:

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

		for (int i=1; i<10 ; i+=1){ 
			// 循环一次换一行,i为行数
			System.out.println("\n");
			for (int j=1; j<=i ; j++ ){
				// 第一行1*1,即i*j,第二行2*1,即i*j,第二行有几个取决于i
				System.out.print( i + "*" + j + "=" + i * j );
				// 每行输出,使用制表符隔开
				System.out.print("\t");
			}

		}
		
	}
}

输出1~100中的素数(质数,能被1和自身整除,不能被其它数字整除的数字):

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

		int count = 0;
		for (int i=2; i<=100 ; i++ ){
			boolean isSu = true; //定义一个布尔值,根据它来判断谁是素数
			for (int j=2; j<i; j++){
				if (i%j == 0) {
					isSu = false;
					break;//非素数,跳出循环
				}
			}
			if (isSu){
				count ++;
				System.out.print(i + "\t");
				if (count % 8 == 0){  //一行只显示8个素数
					System.out.println("\n");
				}
			}
		}
		
			
	}
}

while循环

while循环的语法结构:

while (布尔表达式){
    循环体;
}

while循环执行原理:先判断布尔表达式的结果,true,执行循环体,并再次判断布尔表达式的结果;false,循环结束!
while循环执行次数:0~n次,while循环的循环体可能一次都不执行!
编译器如果检测到程序无法执行,编译报错:

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

		while (true){
			System.out.println("死循环");
		}
		//语法错误
		System.out.println("鳄鱼君");//这行代码永远都不会执行,所以编译报错
	}
}

但是也可以骗过编译器:

public class WhileTest
{
	public static void main(String[] args){
		int i = 10;
		int j = 1;
                // 编译不会报错
		while (i > j){
			System.out.println("死循环");
		}
     
                // 编译错误
		while (10 > 3){
			System.out.println("死循环");
		}
		
		System.out.println("鳄鱼君");
	}
}
public class WhileTest
{
	public static void main(String[] args){
		int i = 10;
		while(i>0){
			System.out.println(i--);//先赋值在运算
		}
		System.out.println("i--->" + i);//0
	}
}

do..while循环

do..while循环的语法结构:

do{
    循环体;
}while{布尔表达式};

do..while循环的执行原理:先执行循环体,再判断布尔表达式为true/false,true执行循环体…;false结束!
do..while循环的执行次数:循环体代码执行次数1~n次
do..while循环最后有一个分号

public class doWhileTest
{
	public static void main(String[] args){
		int i = 10;
		//循环执行一次
		do{
			System.out.println(i);
		}
		while (i>100);
		
		System.out.println("================");
		//循环一次也不会执行
		while (i>100){
			System.out.println("i--->" + i);
		}
	}
}

控制循环语句顺序

break语句

break是java语言中的关键字,被译为中断/折断,break;可以成为一个完整的java语句。break语句可以使用在switch语句、循环语句中,用来跳出循环,终止循环的执行!

public class WhileTest
{
	public static void main(String[] args){
		for (int i=0; i<10 ; i++){
			//i等于4终止当前循环
			if (i == 4){
				break;
			}
			System.out.println("i--->" + i);//0 1 2 3
		}
		//这条语句不会受到影响
		System.out.println("鳄鱼君");
	}
}

for循环嵌套使用break语句:

public class WhileTest
{
	public static void main(String[] args){
		for (int i=0; i<3 ; i++ ){

			for (int j=0; j<3 ; j++ ){
				if (j == 2){
					break; //终止内层循环,不会影响外层循环
				}
				System.out.println("j-->" + j);//0 1
			}

			System.out.println("i---->" + i);//0 1 2 
		}
	}
}

如果想要在for循环内部终止外部的for循环,可以这样写:

public class WhileTest
{
	public static void main(String[] args){
                //给外层循环起名A
		A:for (int i=0; i<3 ; i++ ){
                        //给外层循环起名B
			B:for (int j=0; j<3 ; j++ ){
				if (j == 2){
					break A; //终止A循环
				}
				System.out.println("j-->" + j);//0 1
			}

			System.out.println("i---->" + i);
		}
	}
}

continue语句

continue表示继续/go on/下一个,continue语句也是一个关键字,continue;构成一个java语句。break和continue语句的区别:

  1. break:终止循环,不再执行
  2. continue:终止本次循环,直接进入下一次循环
public class ContinueTest
{
	public static void main(String[] args){
		for (int i=0; i<10 ; i++ ){
			if (i == 5){//i等于5,跳过本次循环,直接进入下次循环,所以不会打印5
				continue;
			}
			System.out.println(i);
		}
		System.out.println("鳄鱼君");
	}
}
标签:

未经允许不得转载:作者:鳄鱼君, 转载或复制请以 超链接形式 并注明出处 鳄鱼君
原文地址:《Java基础 控制选择语句-控制循环语句-改变控制语句顺序》 发布于2020-08-02

分享到:
赞(0) 赏杯咖啡

评论 抢沙发

1 + 5 =


文章对你有帮助可赏作者一杯咖啡

支付宝扫一扫打赏

微信扫一扫打赏

Vieu4.6主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。
切换注册

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录
切换登录

注册