概述
运算符：对常量或者变量进行操作的符号。表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。 不同运算符连接的表达式体现的是不同类型的表达式。
算数运算符
注意事项：
- Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。
- /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
代码示例
/*
算数运算符
(1)+: 加法运算
(2)-: 减法运算
(3)*: 乘法运算
(4)/: 除法运算
被除数 ÷ 除数 = 商 ...... 余数
*/
public class Demo {
public static void main(String[] args) {
int a = 3;
int b = 2;
System.out.println(a + b);// 5
System.out.println(a - b);// 1
System.out.println(a * b);// 6
// int/int 结果必然是int类型
System.out.println(a / b);// 1
//整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
//int * double / int ==> double / int ==> double / double ==> double
System.out.println((a * 1.0) / b);// 1.5
//判断是否为偶数
System.out.println(10 % 2);//0
}
}算术运算符+的特殊用法
/*
+符号的作用
1.数学中的加法运算(数字相加,字符相加)
2.字符串的拼接(把两个字符串连在一起)
*/
public class Demo {
public static void main(String[] args){
System.out.println(5+5);//10
/*
int + char ==> int + int ==> int
需要:
char ==> int 查看ASCII码表 'A'对应65
*/
System.out.println(5+'A');// 70
/*
自动类型转换中:
byte/short/char类型,只要参加运算,会自动转换为int类型
char + char ==> int + int ==> int
需要:
char ==> int 查看ASCII码表 'A'对应65
char ==> int 查看ASCII码表 'B'对应66
*/
System.out.println('A'+'B');//131
System.out.println("===========================");
//"5+5="+5+5: 从左向右计算
//先计算"5+5="+5: 此处+号代表字符串的连接 结果是"5+5=5"
//然后"5+5=5"+5: 此处+号代表字符串的连接 结果是"5+5=55"
System.out.println("5+5="+5+5);//5+5=55
//()的优先级是比较高的,所以先计算5+5 结果10
//然后"5+5="+10: 此处+号代表字符串的连接 结果是"5+5=10"
System.out.println("5+5="+(5+5));//5+5=10
}
}赋值运算符
赋值运算符，就是将符号右边的值，赋给左边的变量。
代码示例
/*
基本赋值运算符: =
复合赋值运算符:
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
*/
public class Demo {
public static void main(String[] args){
int a = 10,b = 20;
a += b;//a = a + b
System.out.println(a);//30
System.out.println(b);//20
int c = 30,d = 20;
c %= d;//c = c % d = 30%20 = 10
System.out.println(c);//10
System.out.println(d);//20
}
}赋值运算符的特点
- +=,-=,/=,*=,%= 运算结果的数据类型和左侧变量的数据类型不一致,隐藏强制类型转换
- 整数常量只要不超出所赋值的整数变量的取值范围,可以直接赋值,内部隐藏强制类型转换
代码示例
public class Demo {
public static void main(String[] args) {
/*
s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型，
再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。
但是， s=s+1进行两次运算 ， += 是一个运算符，只运算一次，并带有强制转换的特点，
也就是说 s += 1 就是 s = (short)(s + 1) ，因此程序没有问题编译通过，运行结果是2.
*/
short s = 1;
s += 1;
System.out.println(s);//2
/*
右侧10是int类型(4个字节),左侧变量byte类型(1个字节)
按照道理来讲: 不能直接赋值
现在为什么可以呢?
原因是数字10是一个常量,值并没有超出byte的取值范围
所以可以直接赋值,内部会帮助我们进行强制类型转换
等价于:
byte b = (byte)10;
*/
byte b = /*(byte)*/10;
System.out.println(b);//10
}
}自增自减运算符
++ 运算，变量自己增长1。反之， -- 运算，变量自己减少1，用法与 ++ 一致
代码示例
/*
自增(++)自减(--)运算符(代码演示只演示++)
1.作用: 让变量的值增加1(++)或者减少1(--)
2.使用格式:
(1)可以写在变量的前面: ++a,--a
(2)可以写在变量的后面: a++,a--
3.使用特点:
(1)单独使用: ++/--自己独占一行,没有其它运算一起参与
前++和后++,没有任何区别,都是让变量的值增加1
前--和后--,没有任何区别,都是让变量的值减少1
(2)混合使用: 和其它运算(赋值,打印等)一起
前++/--: 先++/--,后再使用 先给变量的值增加(++)或者减少(--)1,然后再使用++/--后的结果
后++/--: 先使用,然后++/-- 先使用变量的值,再把变量的值 增加(++)或者减少(--)1
重点: ----最常用的东西
a++: 变量a的值增加1
a--: 变量a的值减少1
*/
public class Demo {
public static void main(String[] args) {
int a = 2;
//++自己独占一行,没有其它运算一起参与
a++;//a = a + 1 = 2 + 1
System.out.println(a);//3
int b = 2;
//++自己独占一行,没有其它运算一起参与
++b;//b = b + 1 = 2 + 1
System.out.println(b);//3
System.out.println("-----------------");
int c = 2;
/*
目前是++和赋值一起操作,属于混合运算
而且++写在了c的前面,先把c的值增加1,
c的值变为3,然后再把结果3赋值给变量d,d的值3
*/
int d = ++c;
System.out.println(c);//3
System.out.println(d);//3
System.out.println("-----------------");
int e = 2;
/*
目前是++和赋值一起操作,属于混合运算
而且++写在了e的后面,所以先使用e的值(2)赋值给变量f,所以f的值是2,
然后e的值再增加1,变成3
*/
int f = e++;
System.out.println(e);//3
System.out.println(f);//2
System.out.println("-----------------");
int x = 4; //5 6
/*
表达式(x++)+(++x)+(x*10)是从左到右计算的
先计算(x++): 因为++在后面,先使用x的值4,然后x的值增加,变成5
4 + (++x)+(x*10)
接着计算(++x): 因为++在前面,先把x的值增加1,x变成6,然后再使用6
4 + 6+(x*10)
接着计算x*10 --> 6*10 结果: 60
4 + 6 + 10 结果: 70
*/
int y = (x++) + (++x) + (x * 10);
// 4 + 6 +
System.out.println(x);//6
System.out.println(y);//70
}
}关系运算符
关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于
注意事项：
- 关系运算符的结果都是boolean类型，要么是true，要么是false。
- 千万不要把“==”误写成“=”，"=="是判断是否相等的关系，"="是赋值。
示例代码
public class Demo {
public static void main(String[] args) {
int a = 10, b = 20;
boolean result = (a == b);
System.out.println(result);//false
System.out.println(a != b);//10 != 20: true
System.out.println(a > b);//10 > 20: false
System.out.println(a >= b);//10 >= 20: false
System.out.println(a < b);//10 < 20: true
System.out.println(a <= b);//10 <= 20: true
System.out.println(a == b);//10 == 20: false
System.out.println(a = b);//20 把变量b的值赋值给变量a,最后打印变量a的值
}
}逻辑运算符
逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true
或
false
代码示例
public class Demo {
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,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true
}
}短路逻辑运算符
在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值 都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
总结：
- 逻辑与&，无论左边真假，右边都要执行。
- 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
- 逻辑或|，无论左边真假，右边都要执行。
- 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
代码示例
public class Demo {
public static void main(String[] args) {
int x = 3;
int y = 4;
// 两个表达都会运算
System.out.println((x++ > 4) & (y++ > 5));//false
System.out.println(x); // 4
System.out.println(y); // 5
//左边已经可以确定结果为false，右边不参与运算
System.out.println((x++ > 4) && (y++ > 5)); // false
System.out.println(x); // 4
System.out.println(y); // 4
}
}三元运算符
语法格式：
执行流程:
- 计算布尔表达式1的结果,看是true还是false
- 如果布尔表达式1的结果为true,就把表达式2的结果赋值给左侧的变量
- 如果布尔表达式1的结果为false,就把表达式3的结果赋值给左侧的变量
执行流程图解:
代码示例
public class Demo {
public static void main(String[] args) {
//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
int h1 = 150;
int h2 = 210;
int h3 = 165;
//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
int temp = h1 > h2 ? h1 : h2;
// 3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
int max = temp > h3 ? temp : h3;
//4：输出结果
System.out.println("这三个和尚中身高最高的是：" + max + "cm");
}
}