java—算数运算符、赋值运算符、比较运算符、逻辑运算符、三元运算符

运算符

进行特定操作的符号。例如：“+”
表达式：用运算符连起来的式子叫做表达式。例如：20+5。又例如：a+b

四则运算： +     -     *     /

取模（取余数）：%

首先计算得到表达式的结果，然后打印输出这个结果

除法公式： 被除数 / 除数 = 商 ... 余数
对于一个整数的表达式来说，除法用的事整除，整数除整数，结果仍然是整数，不看余数
只有对于整数的除法来说，取模运算符才有余数的意义。

public class Demo{
	public static void main(String[] args) {
		// 两个常量之间可以进行数学运算
		System.out.println(20 + 30);  // 50

		// 两个变量之间也可以进行数学运算
		int a = 20;
		int b = 30;
		System.out.println(a -b); // -10

		// 变量和常量之间可以混合使用
		System.out.println(a * 10); // 200
		
		int x = 10;
		int y = 3;
		int result1 = x / y;
		System.out.println(result1); // 3

		int result2 = x % y;
		System.out.println(result2); // 余数，模，1 
		
		// int + double --> double + double = double
		double result3 = x + 2.5;
		System.out.println(result3); // 12.5
	}
}

四则运算

1. 加法

   /*
   1. 对于数值来说，那就是加法
   2. 对于字符char类型来说，在计算之前，char会被提升为int，然后再计算
   	char类型字符，和int类型数字，之间的对照关系表，ASCII/Unicode
   3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作.
   	任何数据类型和字符串进行连接的时候，结果都会变成字符串
   */ 
   
   public class Demo {
   	public static void main(String[] args) {
   		// 字符串类型的变量基本使用
   		// 数据类型 变量名称 = 数据值；
   		String str1 = "Hello";
   		System.out.println(str1); // Hello
   		// String + int => String
   		System.out.println(str1 + 20); // Hello20
   	}
   }
   

2. 自增预算符 ++
   自减运算符 –

   基本含义： 让一个变量长一个数字1或者让一个变量降一个数字1
   使用格式： 写在变量名称之前，或者写在变量名称之后。
   例如： ++num      num++
   
   使用方式：
   	1. 单独使用： 不和其他任何操作混合，独立称为一个步骤
   	2. 混合使用： 和其他操作混合，例如与赋值混合，或者打印操作混合等
   使用区别：
   	1. 在单独使用的时候，前++和后++没有任何区别
   	2. 在混合使用的时候，有【重大区别】
   		a. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用（先加后用）
   		b. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】（先用后加）
   		
   注意事项：
   	只有变量才能使用自增、自减运算符。常量不可发生改变，不能用。
   

   public class Demo {
   	public static void main(String[] args) {
   		int num1 = 10;
   		System.out.println(num1); // 10
   		++num1; // 单独使用 前++
   		System.out.println(num1); // 11
   		num1++; // 单独使用 后++
   		System.out.println(num1); // 12
   		
   		// 与打印操作混合的时候
   		int num2 = 20;
   		// 混合使用，先++，变量立刻马上变成21，然后打印结果21
   		System.out.println(++num2); // 21
   		System.out.println(num2); // 21
   		
   		int num3 = 30;
   		// 混合使用，后++，首先使用变量原来的30，然后再让变量+1得到31
   		System.out.println(num3++); // 30
   		System.out.println(num3); // 31
   		
   		int num4 = 40;
   		// 和赋值操作混合
   		int result1 = --num4; // 混合使用，前--，变量立马-1为39，再将39交给result1变量
   		System.out.println(result1); // 39
   		System.out.println(num4); // 39
   
   		int num5 = 50;
   		// 混合使用，后--，首先吧本来的数字50交给result2，然后自己再-1为49
   		int result2 = num5--;
   		System.out.println(result2); // 50
   		System.out.println(num5); // 49
   
   		int x = 10;
   		int y = 20;
   		int result3 = ++x + y--;
   		System.out.println(result3 ); // 31
   		System.out.println(x); // 11
   		System.out.println(y); // 19
   		
   		// 30++; // 报错，常量不可以使用自增、自减运算符
   	}
   }
   

赋值运算符

赋值运算符分为：
	基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
		int a = 30;
	
	复合赋值运算符：
		+=			a += 1   相当于   a = a + 1
		-=			a -= 2   相当于   a = a - 2 
		*=			a *= 3   相当于   a = a * 3
		/=			a /= 4   相当于   a = a / 4
		%=			a %= 5   相当于   a = a % 5

注意事项： 
	1. 只有变量才能使用赋值运算符，常量不能进行赋值
	2. 复合赋值运算符其中隐含了一个强制类型转换

public class Demo {
	public static void main(String[] args) {
		int a = 10;
		a += 5; // a = 15

		int x = 10;
		x %= 3; // x = 1
		
		// 50 = 30; // 报错 常量不能赋值，不能写在赋值运算符左边
	
		byte num = 30;
		// num = num + 5;
		// num = byte +int
		// num = int + int
		// num = int
		// num = (byte) int
		num += 5;  // num = 35
		
	}
}

比较运算符

大于：		>
小于：		<
大于等于：	>=
小于等于：	<=
相等：		== 		【两个等号连写才是相等，一个等号代表赋值】
不相等：		!=

注意事项：
	1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
	2. 如果进行多次判断，不能连着写,程序中【不允许以下这么写】
		数学中的写法，例如： 1 < x < 3

public class Demo {
	public static void main(String[] args) {
		System.out.println(10 > 5); // true
		int num1 = 10;
		int num2 = 12;
		System.out.println(num1 < num2); // true
		System.out.println(num2 >= 100); // false
		System.out.println(num2 <= 100); // true
		System.out.println(num2 <= 12); // true
		
		int x = 2；
		// System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。
	}
}

逻辑运算符

与（并且）		&&			全真为真，一假为假
或（或者）		||			全假为假，一真为真
非（取反）		！			本来为true，变成false；本来为false，变成true

注意事项：
	1. 逻辑运算符只能用于boolean值
	2. 与、或需要左右各自有一个boolean值，但是取反只要有唯一的boolean值即可
	3. 与、或两种运算符，如果有多个条件，可以连续写。
		两个条件： 条件A && 条件B
		多个条件： 条件A && 条件B && 条件C && ...

		Tips： 
			对于1 < x < 3,应该拆成两个部分，然后使用运算符连接起来：
			int x =2；
			1 < x && x < 3

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

		System.out.println(true || false); // true
		System.out.println(true || true); // true
		System.out.println(false|| false); // false
		
		System.out.println(true); // true
		System.out.println(!true); // false
		
		int b = 20;
		// true || ...
		System.out.println(3 < 4 || ++b < 100); // true
		System.out.println(b); // 20
	}
}

三元运算符

一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反！，自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如加法+、赋值=
三元运算符：需要三个数据才能进行操作的运算符

格式： 
	数据类型 变量名称 = 条件判断 ？表达式A ： 表达式B

流程：
	首先判断条件是否成立：（二者选其一）
		如果成立为true，那么将该表达式A的值赋值给左侧的变量；
		如果不成立为false，那么将表达式B的值赋值给左侧的变量；
	
注意事项：
	1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求
	2. 三元运算符的结果必须被使用

public class Demo {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		// 数据类型 变量名称 = 条件判断 ？表达式A ： 表达式B
		int max = a > b ? a : b; // 最大值变量
		System.out.println(max); // 20
		
		// int result = 3 > 4 ? 2.5 : 10; // 报错。错误写法

		System.out.println(a > b ? a : b); // 20 正确写法

		// a > b ? a : b; // 错误写法  结果必须被使用
	}
}