关系运算符与结构化编程

关系运算符与结构化编程

今天主要学习了关系运算符的使用与三种结构（顺序结构、选择结构、循环结构）。

关系运算符

>、<、>=、<=、==、!=用于判断两个数据之间的大小关系，计算结果为boolean,如果成立返回为true，否则为false

double d1=10;
System.out.println(d1>3);  //返回true

==和=的区别:

• k=100;这是赋值运算符，意思是将=右边的计算结果储存在=左边的变量中
• k==100这是比较计算，意思是判断k是否值为100；如果是则返回true，否则false

!=意思是判断是否不等于，表示如果相等时返回false，否则返回true

• 由于浮点数无法精确存放，所以判断k==1.0这个写法是错误的，正确写法： a-b的绝对值小于1e-6

Java提供了一个工具类Math，其中包含一个abs()的方法实现求绝对值

• 内部实现是通过StrictMath实现的，其中通过对等类提供计算实现
• Math.sqrt() : 计算平方根
• Math.abs() : 取绝对值
• Math.ceil(): 逢余进一
• Math.floor() :逢余舍一
• Math.round(): 四舍五入，float时返回int值，double时返回long值

Math.abs(d1-1)<1e-6 判断浮点类型的变量d1的值是否为1

举个例题：

用户输入身高和提供，计算对应的BMI指数值。BMI指数（英文为Body Mass Index，简称BMI），是用体重千克数除以身高米数的平方得出的数字，是国际上常用的衡量人体胖瘦程度以及是否健康的一个标准

偏瘦：18.5以下、正常：18.5-23.9、超重：≥24、偏胖：24～27.9、肥胖：≥28。

Scanner s = new Scanner(System.in);  //创建一个Scanner对象，通过这个对象中的方法才能实现接受用户键盘录入数据
//提供的方法有nextXxx()用于接受对应数据类型的用户键盘录入，自动进行数据类型换换，如果转换失败则报异常InputMismatchException
Scanner sc = new Scanner(System.in);
int kk=sc.nextInt();
double dd=sc.nextDouble();

编码实现：

public class Test2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入身高，单位为米");
		double height = sc.nextDouble();//代码执行到这里时，会阻塞等待用户输入数据，如果用户输入合法则自动赋值给变量height。直接回车则继续等待用户输入，如果输入数据不合法则报错
		System.out.println("请输入体重，单位为千克");
		double weight = sc.nextDouble();
		double bmi = weight / Math.pow(height, 2);
		if (bmi < 18.5)
			System.out.println("偏瘦");
		else if (bmi < 23.9) //等价于  bmi>=18.5 并且  bmi<23.9
			System.out.println("正常");
		else {
			System.out.println("超重");
			if (bmi < 27.9)
				System.out.println("偏胖");
			else
				System.out.println("肥胖");
		}
	}
}

实现接受用户的键盘录入数据

//建立一个变量指向键盘录入
Scanner sc = new Scanner(System.in);
//通过这个变量读取用户键盘录入的数据，如果用户不输入则一直等待,如果输入的数据不是浮点数，则报错
double height=sc.nextDouble();

//变量sc中是Java提供的具体实现方法nextDouble实现从键盘读取一个浮点数，如果要求用户输入int，则方法为nextInt

实现屏幕输出

System.out.println("具体需要输出的内容");输出内容后会自动换行，如果不需要换行，则使用方法System.out.print("")

System.out.println("num:"+num);意思是输出【num：123】
System.out.println("num:num")意思是输出【num:num】

逻辑运算符

学习了逻辑运算符的简单用法：

并且&&、或者 ||、不是 !。逻辑计算支持短路操作

表达多个条件之间的关系。例如年龄大于等于18并且年龄小于65【age>=18 && age<65】

&&:与运算，含义是两个条件必须同时成立，可以翻译为并且

//年龄大于等于18并且年龄小于65
age>=18 && age<65
//算法规则：同真则真，其余为假

||：或运算，含义是两个条件中成立一个即可，可以翻译为或者

//年龄小于18岁或者年龄不小于65
age<18 || age>=65
//算法规则：同假则假，否则为真

!：非运算，含义是不是，用于对某个条件进行否定

//年龄不小于18
//写法1：
age >=18
//写法2： 
!（age<18）

//算法规则：非真则假，非假则真

短路运算

例如A && B:如果条件A为false,则不会执行B，因为根据运算规则结果一定是false，和B的值没有关系

A||B：如果条件A为true，则不会执行B，因为格局运算规则结果一定是true，和B的值没有关系

如果条件1的结果确定后则整个式子计算结果已经确定，则没有必要计算后续的式子，这就是所谓的短路计算

考核中主要配置++/–进行测试

int age=100;
char cc='A';  //字符之间的大小比较是通过unicode编码值进行比较
if(cc>='B' || age++<200){
	System.out.println("ZZZZZ");
}
System.out.println(age);//?输出101

int age=100;
char cc='A';
if(cc>='B' && age++<200){
	System.out.println("ZZZZZ");
}
System.out.println(age);//?输出100,因为短路的原因，导致age++并没有得到执行

int age=200;
char cc='A';
if(cc>='B' || age++<=200){
	System.out.println("ZZZZZ");
	System.out.println(age);//?输出201
}

赋值运算符

=，+=，-=，*=，/=，%=

int k=100; 含义是将100赋值存储在k对应的存储单元中

k=k+3可以简写为k+=3 -= */ /=类似，自动类型转换

short k=3;
k=k+3;  //出现了一个语法错误，因为k+3这里的3系统识别为int类型，所以计算时所有数据自动转换为int类型，必然计算结果也是int类型，将int类型的数据赋值给short类型变量----错误
System.out.println(k);

short k=3;
k+=3;  //没有语法错误，因为+=这种符号中包含了自动类型转换

结构化编程

结构化程式设计(英语:Structured programming)是1960年代开始发展起来的一种编程典范。它采用子程序、程式码区块、for循环以及while循环等结构来取代传统的goto。

应用代码一般是由三种结构组成：顺序结构、选择结构、循环结构

它的指导思想

自顶向下、逐步求精、模块化

编程过程

流程图是流经一个系统的信息流、观点流或部件流的图形代表。在企业中，流程图主要用来说明某一过程。这种过程既可以是生产线上的工艺流程，也可以是完成一项任务必需的管理过程。常见的绘制工具有Visio、PowerDesigner等。

1、圆角矩形表示“开始”与“结束”。

2、矩形表示行动方案、普通工作环节用

3、菱形表示问题判断或判定（审核/审批/评审）环节

4、用平行四边形表示输入输出

5、箭头代表工作流方向

结构化编程的推论

任何复杂的问题都可以三种基本算法结构来描述：顺序、选择、循环。因此用计算机语句描述的程序也包含三种基本结构

临时变量的生命周期

public class Test{
    public static void main(String[] args){
        long mm=0;
        {   
            System.out.println(mm);//语法正确，因为mm的范围包括了这个小范围
            System.out.println(kk);//语法错误，java要求变量必须是先定义后使用，先赋初值后使用
            //语法正确
            int kk=100;
            System.out.println(kk);//可以输出
        }
        System.out.println(mm);//语法正确，mm就是在这个范围内有效
        System.out.println(kk);//语法错误，因为kk只在上一个{}范围中有效
    }
}

条件分支语句

Java语言提供了两种判断语句：if语句和switch语句。这两种语句用于实现判断，当符合某些条件时执行某段代码，否则将不执行

语法： if(条件判断语句){代码A;}当条件成立时执行代码A，如果条件不成立则不执行代码A，而是直接执行if的下一句

​ if(条件){代码块1;}else{代码块2;}当条件成立时执行代码块1，如果条件不成立则执行代码块2。没有一种情况是同时执行代码块1和2

​ if(条件1){代码块1;}else if(条件2){代码块2;}...else{代码块n;}当条件1成立时执行代码块1，如果条件1不成立继续判断条件2，如果条件2成立则执行代码块2,依次类推。没有一种情况是同时执行代码块1和2

​ 说明：允许多个if之间进行相互嵌套

需求：要求输入学生性别，如果false则显示女的啊!

boolean sex=true;
Scanner sc=new Scanner(System.in);
sex=sc.nextBoolean();
if(sex){  //这里是一个简化写法，实际上就是true==sex
    System.out.println("男");
}else   //如果代码块中只有一条语句时，{}可写可不写
    System.out.println("女");

要求输入学生成绩（假设成绩都是整数），如果>85显示优秀，如果>70显示良好，如果>60显示及格，否则显示不及格

int score=0;//要求临时变量必须先定义后使用，必须先赋初值后使用
Scanner sc=new Scanner(System.in);
score=sc.nextInt();
if(score>85)
    System.out.println("优秀");
else{  //如果代码块多于一行，则{}不能省略，否则语法报错
    if(score>60){
        if(score>70)
            System.out.println("良好");
        else
        	System.out.println("及格");
    }else{
        System.out.println("不及格");
    }
}

int score=0;//要求临时变量必须先定义后使用，必须先赋初值后使用
Scanner sc=new Scanner(System.in);
score=sc.nextInt();
if(score>85)
    System.out.println("优秀");
else if(score>70)
    System.out.println("良好");
else if(score>60)
    System.out.println("及格");
else
    System.out.println("不及格");

开关分支语言switch

语法：

switch(表达式){

​ case 值1： 判断表达式的值是否在值1，如果相等则执行代码块1

​ 代码块1； break; 执行完成后，如果没有break，则自动执行后续语句，但是不进行判定。如果有break则立即中断switch的执行，跳到switch块的下一局继续执行

​ 多个case语句:

​ … …

​ default:

​ 如果所有的case都不能成立，则执行代码块n

​ 代码块n; break;

}

语法点：

• 表达式的计算结果可以是整型【不允许long类型】,可以是char，同时允许是字串类型[String]
• default的位置没有特殊要求，但是一定是所有的case值不相等时才会执行。但是为了增强可读性，所以一般建议写在所有的case之后

例题：输入月份，显示对应的本月的天数

public class Test1 {
	public static void main(String[] args) {
		int res = 0;
		System.out.println("请输入月份：");
		Scanner sc = new Scanner(System.in);
		int month = sc.nextInt();
		System.out.println("请输入年份：");
		int year = sc.nextInt();
		switch (month) {
		case 2:
			if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
				res = 29;
			else
				res = 28;
			break;
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
			res = 31;
			break;
		case 4:  //注意，这里的比对只执行成功一次，比对成功则不会再次进行比对，即使遇到case语句。一旦开始执行语句块，则一定要有break语句，否则会一直执行下去，直到switch结束或者遇到第一个break
		case 6:
		case 9:
		case 11:
			res = 30; 
			break;
		default:
			res = -1;
			break;
		}
		if (res > 0)
			System.out.println(year + "年" + month + "月有" + res + "天!");
		else
			System.out.println("输入的年月不合法!");
	}
}

public class Test2 {
	public static void main(String[] args) {
		F1 ff = F1.AA;
		switch (ff) {//允许使用枚举类型,进行比对时实际上是比较枚举的序号
		case BB:
			break;
		default:
			break;
		}
        char cc = 'a';//允许是字符类型，不是字符串类型；比较是字符值的unicode编码值
		switch (cc) {
		case 'b':
			break;
		default:
			break;
		}
		String key = "abc";
		switch (key) {// 从JDK1.8开始，在switch中可以使用字符串类型，比对时实际上是比较字符串类型的hash值[考点]
		case "abc":
			break;
		default:
			break;
		}
		long key1 = 100;
		switch (key1) {// switch中的表达式可以使用整型，但是不能是long类型
		case 100:
			break;
		default:
			break;
		}
	}
}

enum F1 {
	AA, BB;
}

要求输入学生成绩（假设成绩都是整数），如果>=80显示优秀，如果>=70显示良好，如果>=60显示及格，否则显示不及格

public class Test3 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int score=sc.nextInt();
		int key = score / 10;
		String res=null;
		switch (key) {
		case 10:
		case 9:
		case 8:	
			res="优秀";
			break;
		case 7:
			res="良好";
			break;
		case 6:
			res="及格";
			break;
		default:
			res="不及格";
			break;
		}
		System.out.println("学生成绩为:"+score+"评级为："+res);
	}
}

循环结构

循环就是重复做某一件事情。在Java程序中，循环控制即在某一情况下，控制程序重复执行某一条或多条语句，直到遇到终止条件为止

循环语句也称迭代语句，在Java语言中存在的while、for和do-while循环语句

需求：计算1+2+3+…+100=5050

while循环

while是Java中最基本的循环语句，满足条件才执行循环体，如果不满足条件则不执行。所以有可能循环体一次都不执行。

语法：while(条件){循环体;}当条件成立时反复执行循环体，每执行一次判断一次条件。

int res = 1;// 累加器
int k = 1;// 循环控制变量
while (k < 100) { //k++<100，当条件成立时执行循环体
	res += ++k; 
}
System.out.println("1+2+3+...+100="+res);

int res = 0;// 累加器
int k = 1;// 循环控制变量
while (k < 100) { //k++<100
	res += k++; 
}
System.out.println("1+2+3+...+100="+res);//输出4950，为什么

简化写法：

int res = 0;
int k = 1;
while (k <= 100) res += k++;
System.out.println("1+2+3+...+100=" + res);

需求：计算所有100以内奇数的和

public class Test{
	public static void main(String[] args){
		int res=0;
        int k=1;
        while(k<100){
            res+=k;
            k=k+2;
        }
        System.out.println(res);
	}
}

public class Test{
    public static void main(String[] args){
         int res=0;
         int k=0;
         while(k++<100){
             if(k%2==0); //语法正确，表示当k为偶数时不执行任何操作，这里的;表示这里是一个空语句，什么操作都不做
             else res+=k;
         }
     	System.out.println(res);
    }
}

do/while循环

语法：do{循环体;}while(条件); 先执行循环体，然后进行条件判断，如果条件为true，则执行下次循环；如果条件为false则终止循环。

• 不同于while循环的点：do/while循环至少执行循环体一次，而while循环有可能一次都不执行

public class Test6 {
	public static void main(String[] args) {
		int res = 0;
		int k = 1;
		do {
			res+=k;
			k++;
		} while (k <= 100);
		System.out.println(res);
	}
}

for循环

语法：for(表达式1；表达式2：表达式3){循环体;}

• 执行表达式1
• 执行表达式2，一般表达式2是一个条件，如果条件为true则执行循环体；如果条件为false则终止循环
• 执行循环体
• 执行表达式3
• 执行第2步骤

public class Test7 {
	public static void main(String[] args) {
		int res=0;
		for(int k=1;k<101;k++){
			res+=k;
		}
//		System.out.println(k);语法报错，因为k只在for循环内部有效
		System.out.println(res);
	}
}

for循环中的3个表达式不是必须的，可以不写

int k=1;
for(;k<=100;k++){
	res+=k;
}
System.out.println(k);

for(int k=1;;k++){  //循环条件为永真,是一个死循环    
}
//等价于while(true){}

//甚至for(;;){}语法正确

计算偶数和

int res=0;
for(int k=0;k<=100;k=k+2){
	res+=k;
}
System.out.println(res);

int res=0;
for(int k=0;k<=100;k++){
	res+=k++;
}

累加1+2+…+100=?的其它写法

int res=0;
for(int k=100;k>0;k--)
    res+=k;

三种循环写法的选择

• for循环一般用于可以明确循环次数的场景中
• while循环一般用于不能预先确定循环执行次数的场景中
• do/while循环一般用于不能预先确定循环执行次数，同时要求循环体至少执行一次的场景中

在具体开发中一般使用for循环居多，因为for可以实现另外两种写法【实际上都可以相互替代】

本次学习内容的其他练习题：

键盘录入升数，输出对应的加仑数

• 通过baidu查询对应的转换： 1 升=0.264172052358 美制加仑(加仑)

System.out.println("输入升数：");
Scanner sc = new Scanner(System.in);
double shen=sc.nextDouble();
System.out.println(shen+"升等于"+0.264172052358*shen+"加仑");
sc.close();//关闭键盘录入

//常量的定义  public final static double JIN_ZHI=0.264172052358;
public class Test9 {
	public static void main(String[] args) {
		final double JIN_ZHI = 0.264172052358;//final表示这个变量的值不能修改,也就是常量的意思，也有生命周期的概念和对应的范围限制
//		JIN_ZHI=100;因为变量JIN_ZHI前面有final修饰符，所以一旦赋值则不能修改
		System.out.println("输入升数：");
		Scanner sc = new Scanner(System.in);
		double shen = sc.nextDouble();
		System.out.println(shen + "升等于" + JIN_ZHI * shen + "加仑");
		sc.close();
	}
}

2、计算输入数据的阶乘值

Scanner sc = new Scanner(System.in);
int kk=sc.nextInt();
long res=1L;//累乘器
if(kk<0)
    System.out.println(kk+"小于0，没有定义!");
else {
	for(int k=1;k<=kk;k++)
        res*=k;
	System.out.println(kk+"!="+res);
}

3、互换两个数的值（不允许使用中间变量）

梳理解题思路，并进行验证

int k1=2,k2=3;//语法正确，将两行的声明可以缩减到一行上，int k1=2;int k2=3;
k1=k1+k2;
k2=k1-k2;
k1=k1-k2;

添加输入和对应的输出，接受键盘录入数据

public class Test11 {
	public static void main(String[] args) {
		System.out.println("第一个数字:");
		Scanner sc = new Scanner(System.in);
		int k1 = sc.nextInt();
		System.out.println("第二个数字:");
		int k2 = sc.nextInt();
		System.out.println("原始数据为:" + k1 + "," + k2);
		k1 = k1 + k2;
		k2 = k1 - k2;
		k1 = k1 - k2;
		System.out.println("互换后的数据为:" + k1 + "," + k2);
	}
}

在java中允许自定义方法用于封装一个具体的处理逻辑

public class Test12 {
	public static void main(String[] args) {
		int k1=2,k2=3;
		changePosition(k1, k2);//调用自定义方法，其中的参数按照位置对应进行传递，注意类型匹配
		System.out.println(k1+","+k2);//在Java中调用方法的简单类型参数传递是依靠值传递完成的[单向值传递]
	}
	
	//自定义方法,其中public static因为没有学习OOP,所以暂时认为是固定写法
	//void表示没有返回值，方法名称changePosition，小括号中是传入参数,注意这里时形参
	public static void changePosition(int k1,int k2) {
		k1=k1+k2;
		k2=k1-k2;
		k1=k1-k2;//这里修改k1和k2是无效的,因为调用方法时传入的数据不会自动传递回去，这就是java中的单向值传递的含义
	}
}

4、输出三个数中的最大值和最小值，不允许使用Math数据库

public class Test12 {
	public static void main(String[] args) {
		int k1=4,k2=7,k3=2;
		int mm=max(k2,k1,k3);//按照位置对应传递数据，和变量名称无关
		int mi=min(k1, k2, k3);
		String ss=String.format("k1:%d,k2:%d,k3:%d,max:%d,min:%d",k1,k2,k3,mm,mi);
		System.out.println(ss);
		
		String s2="k1:"+k1+",k2:"+k2+",k3:"+k3;
		System.out.println(s2);
	}
	//用于获取三个参数中最大的值
	public static int max(int k1, int k2, int k3) {
		int res = k1;
		if (res < k2)res = k2;
		if (res < k3)res = k3;
		return res;// 表示向调用该方法处传递返回值
	}
	//用于获取三个参数中最小的值
	public static int min(int k1, int k2, int k3) {
		int res = k1;
		if (res > k2)res = k2;
		if (res > k3)res = k3;
		return res;
	}
}