day02_运算符

运算符

一、类型转换

目的：因为Java中基本数据类型，本质上的区别是数据取值范围大小不一样。那么在操作过程中，会出现赋值、互相转换的过程

1.1、隐式转换

隐式转换：也称为自动转换，是将取值范围小的数据，赋值给取值范围大的数据，可以直接赋值（计算机自动完成）

数据范围从小到大：byte -> short (char) -> int -> long -> float -> double

隐式转换注意细节：

• 小的数据类型，和大的数据类型运算，小的会提升为大的之后，再进行运算
• byte、short、char在运算时，不管是否有更高的类型存在，都会自动提升为int类型，然后再参与运算

double d = 10;
long a = 10;

范例：
int a = 10; 
double b = 12.3; 
double c = a + b; //这里的a会提升为double再参与运算

byte a = 10; 
byte b = 10; 
int c = a + b; //这里的a和b会提升为int再相加，所以需要用int来接收

1.2、强制转换

强制转换：将取值范围大的数据，赋值给范围小的数据

int a = 5.5; //编译报错
int b = 10000000L; //编译报错

强制转换的格式：

目标数据类型 变量名 = (目标数据类型) 变量值;

int a = (int)5.5; //手动书写强转格式
int b = (int)10000000L; //手动书写强转格式

强转会造成数据精度的丢失，不建议使用

/*
编译报错，由于a和b是int类型，相加的结果也是int类型，要将一个int类型的结果赋值给byte，需要强转：byte c = (byte)a + b;
*/
int a = 10,b = 20; 
byte c = a + b;

/*
由于10和20是两个常量，在Java中存在[常量优化机制]，编译是会判断10+20的结果，在不在byte的范围内，如果在编译通过直接赋值；如果不在则报错
*/
byte b = 10 + 20; 

/*
	类型转换案例
*/
public class Demo01{
	public static void main(String[] args){
		/*
			强转案例演示：a和b的结果是int类型，大(int)->小(byte)赋值，需要手动强转
		*/
		int a = 10;
		int b = 20;
		byte c = (byte)(a + b); 
		
		/*
			常量优化机制：常量参与运算，在编译的时候计算机会自动计算结果，判断在不在左边的范围内
				情况1：不在，报错
				情况2：在，则通过编译
		*/
		byte bb = 10 + 20; // 运算结果30，byte类型可以装的下(这个判断计算机自动完成)，所以编译通过
	}
}

二、运算符

运算符：对常量或变量进行操作的[符号]
表达式：用运算符将常量或变量连接起来，并且符合Java语法的式子

2.1、算数运算符

• 加 +
• 减 -
• 乘 *
• 除 /：整数相除只能得到整数，如果想带有小数的结果，必须有小数(浮点数)参与运算
• 取余 %：两数相除，只取余数

/*
	算数运算符
	
	+、-、*:跟小学的运算方式一样
	
	/: 整数相除，结果只能得到整数，如果想要得到小数，必须加入小数运算
	
	%(取余): 取余数
*/
public class Demo01Operator {
	public static void main(String[] args) {
		System.out.println(10 + 20); //30
		System.out.println(10 - 20); //-10
		System.out.println(10 * 20); //200
		
		System.out.println(10 / 2); //5
		System.out.println(10 / 3); //3
		System.out.println(10.0 / 3); //3.3333333333333335
		System.out.println(10 / 3.0); //3.3333333333333335
		
		System.out.println(10 % 3); //1
	}
}

2.2、字符和字符串的+操作

2.2.1、字符的+操作

char字符在参与运算时，是怎么提升为int的?

• 对应ASCII码表中10进制的int值
• ASCII：美国信息交换标准代码，计算机中[字节]到[字符]的一套对应关系（不要去背! 会查即可）

2.2.2、字符串的+操作

当+号遇到字符串，这时的+号是?

• 是字符串连接符。字符串可以使用+号和任意类型进行[拼接]

/*
	字符的+操作：
		当byte、short、char参与运算，无论有没有更大范围的数据参与，都先自动提升为int类型
		自动提升为int类型的过程：匹配该字符在ASCII码表中，对应的十进制值
		
	字符串的+操作：
		当+号遇到字符串，这个+号就不是算数运算符了，而是字符串连接符
		将所有的字符都拼接为一个字符串整体
*/
public class Demo02Operator {
	public static void main(String[] args) {
		//字符的+操作
		int a = 1;
		char b = 'a';
		System.out.println(a + b); //98
		System.out.println('A' + 'B'); //131
		
		
		//字符串的+操作
		System.out.println("itcast"+666); //itcast666
		System.out.println(1 + 99 + "黑马"); //100黑马
		System.out.println("5+5=" + (5 + 5)); //5+5=10
		System.out.println("5+5=" + 5 + 5); //5+5=55
	
		int score = 99;
		System.out.println("成绩：" + score);//成绩：99
	}
}

2.2、自增自减运算符

自增自减 运算符：
++：变量自身+1，可用于变量前、后
–：变量自身-1，可用于变量前、后

变量单独使用和参与操作时的区别?

• 单独使用：在前在后效果一样（常用）
• 参与操作：1）符号在前：先拿变量自增或自减，再拿结果参与操作；2）符号在后：先拿变量参与操作，然后将结果自增或自减

/*
	自增自减运算符：
		++
		--
		
	使用：可以写在变量的前面，也可以写在后面
	
	如果变量自己玩(a++、++a)在前在后效果一样
	如果变量参与操作
		在前，先+1或者-1，然后将结果参与操作
		在后，先参与操作，然后在+1或者-1

	自增自减运算符的[应用场景]
*/
public class Demo04{
	public static void main(String[] args){	
		// 【1】计数器count
		int count = 0;
		
		// 【2】for循环的控制语句
		for(int i = 1; i <= 10; i++){
			System.out.println(i);
			// 打印一次计一次数
			count++;
		}
		// 打印count的结果
		System.out.println(count);
	}
}

2.3、赋值运算符

赋值运算符的分类：

• 基本赋值运算符：= (将等号右边的值，赋给左边的变量)
• 扩展赋值运算符：+=、-=、*=、/=、%= (将等号两边的值参与运算，再将结果，赋给左边的变量)

例如：a += 1;  指的就是  a = a + 1;

扩展赋值运算符的特点?

• 隐含了强值类型转换

2.4、关系运算符

关系运算符也称为比较运算符

关系运算符的分类：

• 等于 ==
• 不等于 !=
• 大于>
• 大于等于 >=
• 小于 <
• 小于等于 <=

含有关系运算符的表达式，称为关系表达式

关系表达式的结果，都是什么类型?

• 结果只能是true和false，都是boolean类型

2.5、逻辑运算符

作用：整合多个关系表达式的条件，结果也都是boolean类型

逻辑运算符分类：

• 与 &：遇false则false
• 或 |：遇true则true
• 非 !：取反
• 异或 ^：相同为false，不同为true

2.6、短路逻辑运算符

推荐使用短路逻辑运算符，可以提升代码的效率

短路逻辑运算符的特点：

• 短路与 &&：遇fasle则短路（作用上和逻辑运算符结果一样）
• 短路或 ||：遇true则短路（作用上和逻辑运算符结果一样）

public class Demo{
	public static void main(String[] args){
		System.out.println(4 < 5 && 5 > 3); //true
		System.out.println(4 > 5 && 5 > 3); //false
	}
}

2.6、三元运算符

三元运算符的格式：对应数据类型 变量名 = 关系表达式 ? 表达式1 : 表达式2;

执行流程：判断关系表达式的结果，为true返回表达式1，为false返回表达式2

/*
	三元运算符
	
	格式：
		(对应的)数据类型 变量名 = 关系表达式 ? 表达式1 : 表达式2;
	
	执行流程：
		判断关系表达式的结果 -> 一定是一个布尔类型
			如果结果是true，返回表达式1上的数据
			如果结果是false，返回表达式2上的数据
	
	示例：	
		boolean result = 10 > 5 ? true : false;
		System.out.println(result); //true
		
	案例需求：
		键盘录入三个同学的身高
		使用三元运算符，获取最高身高
*/

// 1.导包
import java.util.Scanner;
public class Demo05{
	public static void main(String[] args){	
		// 2.创建对象
		Scanner sc = new Scanner(System.in);
		// 3.提示用户录入三个身高
		System.out.println("请输入三个不同的身高");
		// 4.接收数据
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		
		// 5.比较第一步
		//int temp = a > b ? a : b;
		// 6.比较第二步
		//int max = temp > c ? temp : c;
		
		// *使用一行代码完成
		int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
	
		// 7.打印结果
		System.out.println("最高身高是:" + max);
	}
}

三、分支语句

3.1、流程控制语句 - 顺序结构

顺序结构：是Java程序的默认执行流程，从上到下，从左到右依次执行
作用：通过一些语句，来控制程序(代码)的执行流程

流程控制语句分类：

• 顺序结构：默认
• 分支结构：if、switch
• 循环结构：for、while、do…while

3.2、if语句格式

注意事项：

• 如果if语句所控制的语句体，只有一条语句，可以省略大括号（不建议!）
• if语句的小括号后面，不要写分号，Java中分号代表语句的结束

//第一种格式
if(关系表达式){
	//true走这里
}

//第二种格式
if(关系表达式){
	//true走这里
}else{
	//fasle走这里
}

//第三种格式
if(关系表达式1){
	语句体1;
}else if(关系表达式2){
	语句体2;
}else if(关系表达式3){
	语句体3;
}else{
	//如果上述条件都不满足，会走这里
	//一般else语句用来给出错误提示
}

/*
	案例：
		键盘录入张三的成绩，成绩应该在[0-100]分
		根据分数段，打印对应的奖励
			[100-80] 优秀
			[79-60] 良好
			[59-0] 继续努力			
			其他数据，错误提示
*/
// 导包
import java.util.Scanner;
public class Demo07{
	public static void main(String[] args){	
		// 提示用户录入，并接收成绩
		System.out.println("请输入你的成绩:");
		int score = new Scanner(System.in).nextInt();
		// if语句判断
		if(score <= 100 && score >= 80){
			System.out.println("优秀");
		}else if(score <= 79 && score >= 60){
			System.out.println("良好");
		}else if(score <= 59 && score >= 0){
			System.out.println("继续努力");
		}else{
			// 错误提示
			System.out.println("您输入的成绩非法!");
		}
	}
}