Java基础运算符详解：算术、赋值、比较及逻辑操作-优快云博客

本文链接：https://blog.youkuaiyun.com/HolyJohn/article/details/134313631

1.算术运算符

1）运算符定义

运算符：对常量或者变量进行操作的符号。

表达式：用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。

不同运算符连接的表达式体现的是不同类型的表达式。

举例：

int a = 10;
int b = 20;
int c = a + b;

+：是运算符，并且是算术运算符

a + b : 是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

符号	作用	说明
+	加	参考小学一年级
-	减	参考小学一年级
*	乘	参考小学二年级，与“×”相同
/	除	参考小学二年级，与“÷”相同
%	取余	获取的是两个数据做除法的余数

注意事项：

/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。

整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

/*
	算术运算符
*/
public class OperatorDemo01{
	public static void main(String[] args){
		//定义两个变量
		int a = 6;
		int b = 4;
		
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b);
		System.out.println(a / b);
		System.out.println(a % b);
		//除法得到的是商，取余得到是余数
		
		//整数相除只能得到整数，要想得到小数，必须有浮点数的参与
		System.out.println(6.0/4);
		
	}
}

2）字符的“+”操作

拿字符在计算机底层对应的数值来进行计算的

'A' --------> 65 A-Z是连续的

'a' --------> 97 a-z是连续的

'0' --------> 48 0-9是连续的

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：

byte类型,short类型和char类型将被提升到int类型
整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

等级顺序：byte,short,char-->int-->long-->float-->double

/*
	字符的“+”操作
*/
public class OperatorDemo01{
	public static void main(String[] args){
		//定义两个变量
		int i = 10;
		char c = 'A';//'A'的值是65
		c = 'a';//'a'的值是97
		c = '0';//'0'的值是48
		System.out.println(i + c);
		
		//char ch = i + c;
		//char类型会被自动提升为int类型
		/*
		OperatorDemo01.java:13: 错误: 不兼容的类型: 从int转换到char可能会有损失
                char ch = i + c;
                            ^
1 个错误
错误: 编译失败
		*/
		int j = i + c;
		System.out.println(j);
		
		//int k = 10 + 13.14;
		/*
			OperatorDemo01.java:25: 错误: 不兼容的类型: 从double转换到int可能会有损失
                int k = 10 + 13.14;
                           ^
1 个错误
错误: 编译失败
		*/
		double k = 10 + 13.14;
		System.out.println(k);
	}
}

3)字符串的"+"操作

当"+"操作中出现字符串时，这个"+"是字符串连接符，而不是算术运算。
当"+"操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行"+"操作时，从左到右逐个执行。

/*
	字符串的“+”操作
*/
public class OperatorDemo01{
	public static void main(String[] args){
		System.out.println("IT" + "麦仓分享");
		System.out.println("麦仓分享" + "IT");
		System.out.println("麦仓分享" + 521);
		System.out.println(521 + "麦仓分享" );
		
		System.out.println("麦仓分享" + 5 + 21);
		System.out.println(1 + 99 +"分，麦仓分享" );
		
	}
}

2.赋值运算符

符号	作用	说明
=	赋值	a = 10,将10赋值给变量a
+=	加后赋值	a += b，将a + b 的值给a
-=	减后赋值	a -= b，将a - b 的值给a
*=	乘后赋值	a *= b，将a × b 的值给a
/=	除后赋值	a /= b，将a ÷ b 的商给a
%=	取余后赋值	a %= b，将a ÷ b 的余数给a

注意事项：

扩展的赋值运算符隐含了强制类型转换

/*
	赋值运算符
*/
public class OperatorDemo{
	public static void main(String[] args){
		//把10赋值给int类型的变量i
		int i = 10;
		System.out.println("i:" + i);
		
		//+= 把左边和右边的数据做加法操作，结果赋值给左边
		i += 20; 
		//等价于 i =(int)(i + 20);
		System.out.println("i:" + i);
		
		//注意：扩展的赋值运算符底层隐含了强制类型转换
		short s = 10;
		s += 20;
		//等价于s = (short)(s + 20);
		System.out.println("s:" + s);
	}
}

3.自增自减运算符

符号	作用	说明
++	自增	变量的值加1
--	自减	变量的值减1

注意事项：

++ 和 -- 既可以放在变量的后边，也可以放在变量的前边。
单独使用的时候，++ 和 -- 无论时放在变量的前边还是后边，结果是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。
参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。

最常见的用法：单独使用。

/*
	自增自减运算符
*/
public class OperatorDemo{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		System.out.println("i:" + i);
		
		//单独使用
		//i++;
		//++i;
		System.out.println("i:" + i);
		
		//参与操作使用
		//int j = i++;
		int j = ++i;
		System.out.println("i:" + i);
		System.out.println("j:" + j);
	}
}

4.关系运算符

符号	说明
==	a==b,判断a和b的值是否相等，成立为true,不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true,不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：

关系运算符的结果都是boolean类型，要么是true,要么是false。
千万不要把"=="误写成"="。

/*
	关系运算符
*/
public class OperatorDemo{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 10;
		
		//==
		System.out.println("i == j:" + (i == j));
		System.out.println("i == k:" + (i == k));
		System.out.println("-----------------");
		
		//!=
		System.out.println("i != j:" + (i != j));
		System.out.println("i != k:" + (i != k));
		System.out.println("-----------------");
		
		//>
		System.out.println("i > j:" + (i > j));
		System.out.println("i > k:" + (i > k));
		System.out.println("-----------------");
		
		//>=
		System.out.println("i >= j:" + (i >= j));
		System.out.println("i >= k:" + (i >= k));
		System.out.println("-----------------");
		
		//<
		System.out.println("i < j:" + (i < j));
		System.out.println("i < k:" + (i < k));
		System.out.println("-----------------");
		
		//<=
		System.out.println("i <= j:" + (i <= j));
		System.out.println("i <= k:" + (i <= k));
		System.out.println("-----------------");
		
		//不小心把==写成了=
		//把j的值赋值给了i，然后输出i的值
		System.out.println("i = j:" + (i = j));
	}
}

5.逻辑运算符

1）定义

在数学中，一个数据x，大于3，小于6，我们可以这样来进行表示：3<x<6

在Java中，需要把上面的式子先进行拆解，再进行表达。

拆解为：x>3和x<6

合并后：x>3&&x<6

&&其实就是一个逻辑运算符。

我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符。

当然，逻辑运算符也课可以直接连接布尔类型的常量或者变量。

2）逻辑运算符

符号	作用	说明
&	逻辑与	a&b,a和b都是true,结果为true,否则为false
\|	逻辑或	a\|b,a和b都是false,结果为false,否则为true
^	逻辑异与	a^b,a和b结果不同为true,相同为false
！	逻辑非	!a,结果和a的结果正好相反

/*
	逻辑运算符
*/
public class OperatorDemo{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//& 有false,则false
		System.out.println((i > j) & (i > k));//false & false
		System.out.println((i > j) & (i < k));//false & true
		System.out.println((i < j) & (i > k));//true & false
		System.out.println((i < j) & (i < k));//true & true
		System.out.println("-----------------");
		
		//| 有true,则true
		System.out.println((i > j) | (i > k));//false | false
		System.out.println((i > j) | (i < k));//false | true
		System.out.println((i < j) | (i > k));//true | false
		System.out.println((i < j) | (i < k));//true | true
		System.out.println("-----------------");
		
		//^ 相同为false,不同为true
		System.out.println((i > j) ^ (i > k));//false ^ false
		System.out.println((i > j) ^ (i < k));//false ^ true
		System.out.println((i < j) ^ (i > k));//true ^ false
		System.out.println((i < j) ^ (i < k));//true ^ true
		System.out.println("-----------------");
		
		//! 
		System.out.println((i > j));//false
		System.out.println(!(i > j));//!false
		System.out.println(!!(i > j));//!!false
		System.out.println(!!!(i > j));//!!!false
		
	}
}

3）短路逻辑运算符

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果
\|\|	短路或	作用和\|相同，但是有短路效果

注意事项：

逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或|，无论左边真假，右边都要执行。
短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

最常用的逻辑运算符：&&，||，！

/*
	短路逻辑运算符
*/
public class OperatorDemo{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//&& 有false,则false
		System.out.println((i > j) && (i > k));//false && false
		System.out.println((i > j) && (i < k));//false && true
		System.out.println((i < j) && (i > k));//true && false
		System.out.println((i < j) && (i < k));//true && true
		System.out.println("-----------------");
		
		//|| 有true,则true
		System.out.println((i > j) || (i > k));//false || false
		System.out.println((i > j) || (i < k));//false || true
		System.out.println((i < j) || (i > k));//true || false
		System.out.println((i < j) || (i < k));//true || true
		System.out.println("-----------------");
		
		//&&和&
		//System.out.println((i++ > 100) & (j++ > 100));//false & false
		//System.out.println((i++ > 100) && (j++ > 100));//false && false
		//System.out.println("i:" + i);
		//System.out.println("j:" + j);
		
		//||和|
		//System.out.println((i++ > 9) | (j++ > 100));//true | false
		System.out.println((i++ > 9) || (j++ > 100));//true || false
		System.out.println("i:" + i);
		System.out.println("j:" + j);
		
	}
}

6.三元运算符

1）格式

格式：关系表达式?表达式1:表达式2;

例如：a>b?a:b;

计算规则：

首先计算关系表达式的值
如果值为true,表达式1的值就是运算结果
如果值为false,表达式2的值就是运算结果

/*
	三元运算符
	
	格式：关系表达式?表达式1:表达式2;

	例如：a>b?a:b;
	
	计算规则：
		首先计算关系表达式的值
		如果值为true,表达式1的值就是运算结果
		如果值为false,表达式2的值就是运算结果
*/
public class OperatorDemo{
	public static void main(String[] args){
		//定义变量
		int a = 10;
		int b = 20;
		
		//获取两个数据中的较大值
		int max = a > b ? a : b;
		
		//输出结果
		System.out.println("max:" + max);
		
	}
}