Java中的运算符基础和高级
算术运算符:
基础
加:“+”, 减:“-”, 乘:“*”, 除:“/”, 取余,取模:“%”
注意:整数操作只能得到整数,要想得到小数,必须有浮点数参与运输
类型转换
类型转换分为:
1.隐式转换: 取值范围小的的数值转换为取值范围大的数值
2.强制转换: 取值范围大的的数值转换为取值范围小的数值
范围大小:double > float > long > int > short > byte
隐式转换
1.取值范围小的,和取值范围大的进行运算,小的会先提升为大的,再进行运算
2.byte short char三种类型的数据在运算的时候,都会直接先提升为int,然后再进行运算
例:
byte a = 10;
byte b = 20;
c = a + b;
a和b先转换成int类型再相加
强制转换
如果把一个取值范围大的的数值,赋值给取值范围小的变量,不允许直接赋值,必须强制转换
格式:目标数据类型 变量名 = (目标数据类型) 被强转的数据
double a = 12.3;
int b = (int) a;
注意:如果数据比较大,可能会发生错误
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
byte a = 10;
byte b = 20;
//强转将 int 转化为 byte 类型
byte result = (byte)(a + b);
System.out.println(result);
byte c = 100;
byte d = 100;
//数值过大强转会出现错误
byte result1 = (byte)(c + d);
System.out.println(result1);
}
}
输出为
30
-56 (显然不对)
“+” 操作的三种情况
数字相加
1 + 1 = 2;
字符串相加
当 “+” 操作中出现字符串时,这个 “+” 是字符串连接符,而不是算数运算符,会将前后的数据进行拼接,并产生一个新的字符串
“123” + 123 = “123123”
连续进行 “+” 操作的时候,从左到右依次执行
1 + 1313 + “我爱你” = “1314我爱你”
// 1+1313=1314先执行,再执行1314+“我爱你”
1 + 2 + “abc” + 2 + 1 = “3abc21”
“abc” + true = “abctrue”
字符相加
当出现下面两种情况时:
1.字符+字符 ‘a’ + ‘b’
2.字符+数字 ‘a’ + 1
会把字符通过ASCII码表查询到对应的数字再进行计算
public class ArithmeticoperatorDemo2 {
public static void main(String[] args) {
char c = 'a';
int result = c + 0;
System.out.println(result);
}
}
输出为:
97
正好对应ASCII码
自增自减运算符
1.自增运算符:
“++” : 变量的值加1
a++和++a
2.自减运算符:
“–” : 变量的值减1
a–和–a
两种用法
单独使用
单独写一行,++和–无论放在变量的前面还是后面结果都是一样的
参与计算:
a++, a–
先用后加
int a = 10;
int b = a++;
先令b=a=10, 然后再让a=a+1, a=11
a–同理
++a, --a
先加后用
int a = 10;
int b = ++a;
先让a=a+1, a=11, 再令b=a=11
–a同理
把下面这段代码搞清楚就能理解了
public class ArithmeticoperatorDemo4 {
public static void main(String[] args) {
int x = 10;
int y = x++;
int z = ++x;
System.out.println("x:" + x);
System.out.println("y:" + y);
System.out.println("z:" + z);
}
}
最终结果:
x:12
y:10
z:12
赋值运算符
| 符号 | 含义 |
|---|---|
| = | a=10，将10赋值给变量a |
| += | a+=b，将a+b的值给a |
| -= | a-=b，将a-b的值给a |
| *= | a*=b，将axb的值给a |
| /= | a/=b，将a÷b的商给a |
| %= | a%=b，将a÷b的余数给a |
注意: +=, -=, /=, *=, %= 底层都隐藏了一个强制类型转换,举例如下:
short s = 1;
s += 1;
//等同于s = (short) (s + 1); 因为s+1的时候s强制转换为了int类型,但s本身是short类型,所以等式左边要强制转换为short类型
System.out.println(s);
关系运算符
| 符号 | 含义 |
|---|---|
| == | a==b，判断a和b的值是否相等 |
| != | a!=b，判断a和b的值是否不相等 |
| > | a>b，判断a是否大于b |
| >= | a>=b，判断a是否大于等于b |
| < | a<b，判断a是否小于b |
| <= | a<=b，判断a是否小于等于b |
上述返回的结果都是boolean类型成立为true，不成立为false
逻辑运算符
| 符号 | 含义 |
|---|---|
| & | 逻辑与(且) 并且，两边都为真，结果才是真 |
| ^ | 逻辑异或 相同为false，不同为true |
| ! | 逻辑非 取反 |
| | | 或者，两边都为假，结果才是假 |
短路运算符
| 符号 | 含义 |
|---|---|
| && | 短路与 结果和&相同，但是有短路效果 |
| || | 短路或 结果和|相同，但是有短路效果 |
短路效果:当左边的表达式能确定最终结果,那么右边就不会参与运行了
& , | : 无论左边true还是false,右边都要执行
&& , || : 如果左边能确定整个表达式的结果,右边不执行
&& : 左边为false，右边不管是真是假，整个表达式的结果一定是false。
|| : 左边为true，右边不管是真是假，整个表达式的结果一定是true。
这两种情况下,右边不执行,提高了代码运行效率
public class LogicoperatorDemo2 {
public static void main(String[] args) {
int a = 10;
int b = 10;
boolean result = ++a < 5 && ++b < 5;
System.out.println(result);
System.out.println(a);
System.out.println(b);
//当++a < 5 为false之后,不会执行后面的 ++b < 5,所以b=10
int c = 10;
int d = 10;
boolean result1 = ++c < 5 & ++d < 5;
System.out.println(result1);
System.out.println(c);
System.out.println(d);
//当++c < 5 为false之后,会执行后面的 ++d < 5,所以b=11
}
}
输出结果
false
11
10
false
11
11
三元运算符
格式: 关系表达式 ? 表达式1 : 表达式2;
关系表达式为true执行表达式1, 为false执行表达式2
一定要接受运算符的值
例:求两个数的较大值
a > b ? a : b;
取最大值
代码实现:输入两个整数, 输出最大值
import java.util.Scanner;
public class TernaryoperatorDemo1 {
public static void main(String[] args) {
//使用三元运算符, 获取两个数的较大值
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数");
int a = sc.nextInt();
System.out.println("请输入第二个整数");
int b = sc.nextInt();
int max = a > b ? a : b;
System.out.println(max);
sc.close();
}
}