• 流程控制结构及equal和随机函数

    目录


    在Java中有3种流程控制结构：顺序结构、选择结构、循环结构。

    顺序结构

    顺序结构是指程序从上向下依次执行每条语句的结构，中间没有任何的判断和跳转。

    选择结构

    选择结构是根据条件判断的结果来选择执行不同的代码。选择结构可以细分为单分支结构、双分支结构和多分支结构。Java提供了if控制语句和switch语句来实现选择结构。

    • if ； if…else
    • seitch

    if

    在Java当中，if语句属于选择结构，if语句又被称为分支语句/条件控制语句。

    if语句的语法结构

    if 语句的语法结构有四种编写方式：

    • 第一种：
      if(布尔表达式){
      java语句;
      java语句;
      java语句;
      …
      }

    • 第二种：
      if(布尔表达式){
      java语句;
      java语句;
      …
      }else{
      java语句;
      java语句;
      …
      }

    • 第三种：
      if(布尔表达式){
      java语句;
      java语句;
      …
      }else if(布尔表达式){
      java语句;
      java语句;
      …
      }else if(布尔表达式){
      java语句;
      java语句;
      …
      }else if(布尔表达式){
      java语句;
      java语句;
      …
      }…

    • 第四种：
      if(布尔表达式){
      java语句;
      java语句;
      …
      }else if(布尔表达式){
      java语句;
      java语句;
      …
      }else if(布尔表达式){
      java语句;
      java语句;
      …
      }else {
      java语句;
      java语句;
      …
      }

    重点：对于Java中的if语句来说，只要有一个分支执行，整个if语句全部结束。

    注意： 1. 以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行。
    2. 所有控制语句都是可以嵌套使用

    例：要求输入一个三位数，判断该数是不是水仙花数。

    package cn.bdqn.demo01;

import java.util.Scanner;

public class Demo01 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个三位数：");
		int num = sc.nextInt();
		int baiWei = num/100;
		int shiWei = num/10%10;
		int geWei = num%10;
		//System.out.println(Math.pow(3,2));控制台输出的是3^2结果为9
		if(Math.pow(baiWei, 3)+Math.pow(shiWei, 3)+Math.pow(geWei, 3)==num){
			System.out.println("您输入的是水仙花数！");
		}else{
			System.out.println("您输入的不是是水仙花数！");
		}
			
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    多分支if选择结构（if-else-if选择结构）

    执行规律：

    1. 先判断条件1，如果条件1为true，则执行代码块1，执行完代码块1之后，结束这个if-else-if结构，继续往下执行if-else-if结构之后的代码
    2. 如果条件1为false，继续往下判断条件2，如果条件2为true，执行代码块2，执行完代码块2之后，结束这个if-else-if结构，继续往下执行if-else-if结构之后的代码
    3. 如果条件2为false，继续往下判断条件3，…
    4. 如果所有的条件都为false，就执行else里面的代码块n,执行完代码块n后，结束这个if-else-if结构，继续往下执行if-else-if结构后面代码
      注意事项：
      1）所有的条件不管多么简单还是多么复杂，都只能是布尔值，要么为true，要么为false
      2）else可以省略不写，如果所有的条件都不满足，也没有else，则整个if-else-if结构都不会执行
      3）if-else-if结构中的条件，如果下面的条件会引用上面条件的潜在值，条件是有顺序，严格的条件在上面

    例：需求：
    * 对学员的考试成绩评测
    * 成绩>=80 ：良好
    * 成绩>=60 ：中等
    * 成绩<60 ：差
    * 使用多重if选择结构实现

    public static void main(String[] args) {
		/*
		 * 需求：
		 * 	对学员的考试成绩评测
		 * 成绩>=80 ：良好 
		 * 成绩>=60 ：中等
		 * 成绩<60   ：差
		 * 
		 * 使用多重if选择结构实现
		 * 
		 */
		
		Scanner sc =new Scanner(System.in);
		
		System.out.println("请输入你的考试成绩：");
		double score = sc.nextDouble();
		
//		if(score>=80&&score<=100){
//			System.out.println("良好");
//		}
//		
//		if(score>=60&&score<80){
//			System.out.println("中等");
//		}
//		
//		if(score>=0&&score<60){
//			System.out.println("差");	
//		}
		
//		if(score>=80&&score<=100){
//			System.out.println("良好");
//		}else if(score>=60&&score<80){
//			System.out.println("中等");
//		}else{
//			System.out.println("差");	
//		}
		
		if(score>=80){
			System.out.println("良好");
		}else if(score>=60){
			System.out.println("中等");
		}else{
			System.out.println("差");	
		}
		
		System.out.println("继续努力.....");

	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    练习题：根据天气（晴天/下雨）来决定是室内活动还是室外活动，根据温度来决定具体的活动：晴天30°以上，室内游泳，30°一下，室外篮球，雨天25°以上，室内游泳，雨天25°一下，在家敲代码

    package cn.bdqn.demo01;

import java.util.Scanner;

public class LianXiTi {

	public static void main(String[] args) {
		/*
		 * 练习：根据天气（晴天/下雨）来决定是室内活动还是室外活动，
		 * 根据温度来决定具体的活动：晴天30°以上，室内游泳，30°一下，室外篮球，
		 * 雨天25°以上，室内游泳，雨天25°一下，在家敲代码
		 */
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入当天天气：");
		String weather = sc.next();
		System.out.println("请输入当天气温：");
		double airTemperature = sc.nextDouble();
		boolean weatherToday = weather.equals("晴天");
		if(weatherToday)
		//晴天
		{
			if(airTemperature>30){					//晴天30°以上
				System.out.println("室内游泳！");
			}else{									//晴天30°以下
				System.out.println("室外篮球！");
			}
		}
		//雨天
		else{
			if(airTemperature>25){					//雨天25°以上
				System.out.println("室内游泳！");
			}else{									//雨天25°以下
				System.out.println("在家敲代码！");
			}
		}
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    switch语句

    语法格式：

    switch(表达式){
    case 常量 1:
    语句;
    break;
    case 常量 2:
    语句;
    break;
    …
    default:
    语句;
    break;
    }

    • switch、case、break、default是Java关键字

       -->JDK1.7后，switch后的表达式可以是int、short、byte、char、枚举类型、String类型表达式。
 -->case用于与表达式进行匹配。
 -->break用于终止后续语句的执行。
 -->default是可选的，当其他条件都不匹配时执行default。

      • 1
      • 2
      • 3
      • 4

      执行规律：
      1）计算switch后表达式的值。
      2）将计算结果从上至下依次与case后的常量值比较。
      3）如果相等就执行该常量后的代码块，遇到break语句就结束。
      4）如果与任何一个case后的常量值都不匹配，就执行default中的语句。
      注意事项：
      1）如果case后没有break语句，程序将继续向下执行，直到遇到break语句或switch语句结束----“case穿透”。
      2）case常量值不能相同。
      3）default语句可以在任意位置书写，但一般写在switch结构的末尾。也可以省略不写。

    练习：使用switch选择结构判断一个月份属于一年中的那个季节。（春夏秋冬）

    package cn.bdqn.demo02;

import java.util.Scanner;

public class Subject17 {

	public static void main(String[] args) {
		/*
		 * 使用switch选择结构判断一个月份属于一年中的那个季节。（春夏秋冬）
		 */
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入月份（1-12）：");
		int month =sc.nextInt();
		
		switch(month){
		case 12:
//			System.out.println("冬季");
//			break;
		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;
		case 8:
			System.out.println("夏季");
			break;
		case 9:
//			System.out.println("秋季");
//			break;
		case 10:
//			System.out.println("秋季");
//			break;
		case 11:
			System.out.println("秋季");
			break;
		}

	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    switch与多重if异同点

    相同点：
    都是用来处理多分支条件的结构
    不同点：
    switch选择结构只能处理等值条件判断的情况
    多重if选择结构既能处理某个变量处于某个连续区间时的情况，也能处理等值条件判断的情况

    循环结构

    循环结构是根据判断条件来重复性地执行某段代码。Java提供了while语句、do-while语句、for语句来实现循环。JDK5.0新提供了增强for循环，可以更简单的方式来遍历数组和集合。

    • while
    • do…while
    • for

    while循环

    语法结构：
    初始值;
    while(循环条件){
    循环操作代码块;
    迭代部分;
    }
    例题：在控制台输出10遍好好学习，天天向上

    package cn.bdqn.demo01;

public class Demo01 {

	public static void main(String[] args) {
		//在控制台输出10遍好好学习，天天向上
		//不使用循环来实现
		System.out.println("第1遍：好好学习，天天向上");
		System.out.println("第2遍：好好学习，天天向上");
		System.out.println("第3遍：好好学习，天天向上");
		System.out.println("第4遍：好好学习，天天向上");
		System.out.println("第5遍：好好学习，天天向上");
		System.out.println("第6遍：好好学习，天天向上");
		System.out.println("第7遍：好好学习，天天向上");
		System.out.println("第8遍：好好学习，天天向上");
		System.out.println("第9遍：好好学习，天天向上");
		System.out.println("第10遍：好好学习，天天向上");
		
		System.out.println("--------------------------------");
		
		//使用循环来实现
		int i =1;
		while(i<=100){
			System.out.println("第"+i+"遍：好好学习，天天向上");
			i++;
		}

	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    执行规律：
    1）首先执行1次初始值代码
    2）判断循环条件，如果循环条件为true，则执行{}里的循环操作代码块，并执行迭代部分，之后再次进行循环条件的判断，根据循环条件的结果决定是否再执行{}里的代码
    如果循环条件为false，则结束整个while循环结构，继续往下执行while循环结构后面的代码
    注意事项：
    1）初始值只执行1次
    2）循环条件不管多么简单还是多么复杂，都只能是布尔值，要么为true，要么为false
    3）循环操作代码块可以是一行或者多行语句，
    4）在循环结构中一定要有迭代部分来改变初始值，从而让循环条件再某个时候不再满足，结束循环操作，否则循环会进入死循环
    5）如果循环条件在第一次判断的时候就不满足，那么循环操作一次都不会执行
    Java中的循环控制语句有while循环、do-while循环和for循环等，循环结构的特点是在给定条件成立时，反复执行某程序段，直到条件不成立为止。

    例题：使用while循环模拟打印50份试卷

    package cn.bdqn.demo01;

public class Demo03 {

	public static void main(String[] args) {
		//使用while循环模拟打印50份试卷
		
		//初始值
		int i =1;
		while(i<=50){//循环条件
			System.out.println("打印第"+i+"份试卷");//循环操作
			++i;//迭代部分
		}
		
		System.out.println("试卷打印完毕");

	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    do-while循环结构

    语法结构：
    初始值
    do{
    循环操作代码块;
    迭代部分;
    }while(循环条件);

    例题：使用do-while循环输出100遍好好学习，天天向上

    public static void main(String[] args) {
		//使用do-while循环输出100遍好好学习，天天向上
		
		//初始值
		int i =1;
		do{
			System.out.println("第"+i+"遍：好好学习，天天向上");//循环操作
			i++;//迭代部分
		}while(i<=100);//循环条件

		System.out.println("程序执行完毕");
	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    执行规律：
    1）首先执行1次初始值
    2）然后进入{}内执行循环操作和迭代部分
    3）执行完1次{}里的代码后判断循环条件，如果循环条件为true，继续执行{}里的循环操作代码块和迭代部分，

    如果循环条件为false，结束整个do-while循环结构，继续往下执行do-while循环结构后面的代码

    注意事项：

    • 初始值只执行1次
    • do-while循环是先执行1次循环操作，然后再去判断循环条件。因此如果第一次循环条件就不满足，循环操作也会执行一次
    • 循环条件不管多么的简单还是复杂，都只能是布尔值，要么为true，要么为false

    for循环

    语法结构：
    for(初始值;循环条件;迭代部分){
    循环操作代码块
    }

    例题：使用for循环输出100遍好好学习，天天向上

    public static void main(String[] args) {
		//使用for循环输出100遍好好学习，天天向上
		for(int i=1;i<=100;i++){
			System.out.println("第"+i+"遍：好好学习，天天向上");
		}

		System.out.println("程序执行完毕");
	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    执行规律：
    1）首先执行1次初始值代码
    2）判断循环条件，如果循环条件为true，则执行{}里的循环操作代码块，执行完循环操作代码后执行迭代部分，之后再次进行循环条件的判断，根据循环条件的结果决定是否再执行{}里的代码

    如果循环条件为false，则结束整个for循环结构，继续往下执行for循环结构后面的代码

    注意事项：

    • 初始值只执行1次
    • 循环条件不管多么简单还是多么复杂，都只能是布尔值，要么为true，要么为false
    • 循环操作代码块可以是一行或者多行语句
    • 在循环结构中一定要有迭代部分来改变初始值，从而让循环条件再某个时候不再满足，结束循环操作，否则循环会进入死循环
    • 如果循环条件在第一次判断的时候就不满足，那么循环操作一次都不会执行
      例题：输入一个值，然后根据这个值输出一下加法列表：
      在这里插入图片描述
      程序如下：
    package cn.bdqn.demo03;

import java.util.Scanner;

public class Demo03 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个值：");
		int num =sc.nextInt();
		System.out.println("根据这个值可以输出以下加法表：");
		for(int i =0;i<=num;i++){
			System.out.println(i+"+"+(num-i)+"="+num);
		}
	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    循环主要由4个部分组成

    • 初始部分：设置循环的初始状态。
    • 循环体：重复执行的代码
    • 循环条件：判断是否继续循环的条件。
    • 迭代部份：改变循环条件的值。如果没有迭代部分，会出现死循环。

    equals函数

    比较两个字符串的内容是否相同
    规则：字符串1.equals(字符串2)；
    这是用来比较字符串1和字符串2是否相同。

    String str1 = "hello";
String str2 = "hello";

boolean result1 = str1.equals(str2);
System.out.println("str1和str2内容相同："+result1);
boolean result2 = str1.equals("Hello");
System.out.println("str1和str2内容相同："+result2);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    运行结果：
    在这里插入图片描述

    随机函数

    产生随机数（0.0~1.0）的方法：
    模板：double num1 = Math.random();

    • Math.random()随机返回的是一个[0.0，1.0)的double类型的数据。

    产生随机数（0~1）的方法：

    package cn.bdqn.demo01;

public class randomHanShu {

	public static void main(String[] args) {
		int num1 = (int)(Math.random()*10);
		System.out.println(num1);

	}

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    随机结果如下：
    在这里插入图片描述
    每次随机的结果都是不一样的。
    那么随机获取一个[19,31)之间的 int 型数据怎么办呢？

    int num3=(int)(Math.random()*12+19);
System.out.println(num3);

    • 1
    • 2

    解释：
    012=0；112=12
    0+19=19；12+19=31

    - 随机获取[num1,num2)之间的int型数据：

    (int)(Math.random)*(num2-num1)+num1

  • 相关阅读:
    Posix信号量
    PyQt5 使用Pandas数据分析
    vcs仿真教程（查看断言）
    110道Java初级面试题及答案（最新Java初级面试题大汇总）
    平均回复在5s内的快捷短语
    【电商】电商后台设计—优惠券
    川宁生物业绩持续高涨
    OpenCV 02(色彩空间)
    vue路由 & nodeJS环境搭建
    Python升级之路( Lv15 ) 并发编程三剑客: 进程, 线程与协程
  • 原文地址：https://blog.csdn.net/qq_45734913/article/details/126617252