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
<=	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();
    }
}