
public class Code {
    public static void main(String[] args) {
        int a = 2;
        double b = 3.0;
        int c = 5;
        double d = 5.0;
        System.out.println(a+b);   //整数 + 浮点数
        System.out.println(a+c);   //整数 + 整数
        System.out.println(b+d);   //浮点数 + 浮点数
    }
}

运行结果：

1.2 * 、/、%

在使用乘、除和取模的时候要稍微注意：

如果 * 号两边的操作数有浮点数时，那么结果也为浮点数。

如果 / 号两边的操作数都是整数时，结果就会进行取整，舍弃小数部分。

如果 % 号两边的操作数有浮点数时，取模的结果也就为浮点数。

注意：Java 中是可以对浮点数进行 % 操作的，还有当 * 和 % 符号的左操作数是整数时，它们的右操作数不能为 0 。

实例：


public class Code {
    public static void main(String[] args) {
 
        System.out.println(5 * 10.0); //结果为浮点数
        System.out.println(10.0 / 5); //结果为浮点数
        System.out.println(10 / 6);   //结果为整数,舍弃小数部分
        System.out.println(10.5 % 5); //结果为浮点数
 
        //System.out.println(10 % 0);   //编译失败，报错
        //System.out.println(10 / 0);   //编译失败，报错
    }
}

运行结果：

1.3 += 、-= 、*=、/=、%=

在赋值运算操作符中有一个好处，它可以帮我们进行强制类型转换，其他的用法基本就很简单。

实例：


//这样写就会报错
public class Code {
    public static void main(String[] args) {
        byte a = 2;
        byte b = 3;
        byte c = a + b;  
        // a 与 b 在进行 + 操作时，会发生隐式类型转换，结果为一个int类型的数。
        // 这时再赋值给 c 时，就会报错。
        System.out.println(c);
    }
}

运行结果：

从这上面可以看到编译器给我们报的错是：Incompatible types(类型不兼容)

正确的写法：


//正确的写法
public class Code {
    public static void main(String[] args) {
        byte a = 2;
        byte b = 3;
        byte c = (byte)(a + b);  
 
        System.out.println(c);
    }
}

运行结果：

这里如果使用赋值运算操作符的话：


//使用赋值运算操作符
public class Code {
    public static void main(String[] args) {
        byte a = 2;
        byte b = 3;
        b += a;     //等价于 b = (byte)(b + a);
 
        System.out.println(b);
    }
}

运行结果：

编译器输出了正确结果。

所以有时候使用赋值运算操作符可以减少许多的小错误。

1.4 ++、--

自增、自减运算符在使用时，只要记得以下规律：

前置（++/--）时：先自增/自减，再参与运算。

例如：


public class Code {
    public static void main(String[] args) {
        int i = 1;
        int b = 0;
        b = ++i;    //等价于 b = (i+=1);
        System.out.println(b);
    }
}

运行结果：

后置（++/--）时：先参与运算，再自增/自减。

例如：


public class Code {
    public static void main(String[] args) {
        int i = 1;
        int b = 0;
        b = i++;    //等价于 b = i; i += 1;
        System.out.println(b);
    }
}

运算结果：

注意：上面的规则都是在一条语句内的。以下情况完全等价：


public class Code {
    public static void main(String[] args) {
        int i = 1;
        int j = 1;
        i++; 
        ++j;
        //这时完全等价。
 
        System.out.println(i);
        System.out.println(j);
    }
}

运行结果：

2. 关系运算符

关系运算符的使用就比较简单。

同时，关系运算符的结果都是 Boolean 类型的值（true/false）

实例：


public class Test {
    //关系运算符
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        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(a <= b);
    }
}

运行结果：

3. 逻辑运算符

注意：在 Java 中没有所谓的 0 为假，非 0 为真这种规则，真只有一个值：true ，假：false，并且它们的类型都是 Boolean 。

所以在 Java 中逻辑运算符的操作数和返回值都是 Boolean 类型。

3.1 && 、||、！

逻辑运算符主要包括：逻辑与、逻辑或和逻辑非。

运算规则：

&&：有 false ，结果为 false；全 true ，结果为 true。

||：有 true，结果为 true；全 false ，结果为 false。

！：操作数为 true ，结果为 false ；操作数为 false ，结果为 true。

实例：


public class Test {
    //逻辑运算符
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println(a && b);
        System.out.println(a && a);
        System.out.println(a || b);
        System.out.println(b || b);
        System.out.println(!a);
    }
}

运行结果：

3.2逻辑运算符中的短路情况

有时在使用 && 和 || 时会出现一种短路情况。

短路规则：

&&：当左操作数为 false 时，右操作数不执行，表达式的值为 false。

||：当左操作数为 true 时，右操作数不执行，表达式的值为：true。

实例：


public class Test {
    //逻辑运算符中的短路情况
    public static void main(String[] args) {
 
        System.out.println( (10 > 20) && ((10 / 0) == 0));  //除数不能为0
        System.out.println( (10 < 20) || ((10 / 0) == 0));
    }

运行结果：

小结：本来根据上面的代码判断，除数不能为 0 。编译器应该报错，但这里运行结果正常。

说明 && 和 || 的右操作数没有执行——短路。

小知识点：当 &(按位与) 和 | (按位或)的操作数类型为 Boolean 时，也可以进行逻辑操作，但它们没有短路情况。

4.位运算符

位运算符在使用的时候，操作的时该整数的二进制位。

位运算符包括：&（按位与）、I（按位或）、~（按位取反）、^（按位异或）

位运算符规则：

&：有 0 出 0，全 1 出 1 。

|：有 1 出 1，全 0 出 0。

~: 有 0 出 1，有 1 出 0。

^: 同出 0 ，异出 1。

实例：


public class Test {
    //位运算符
    public static void main(String[] args) {
        int a = 10; // 0000 0000 0000 0000 0000 0000 0000 1010
        int b = 20; // 0000 0000 0000 0000 0000 0000 0001 0100
        System.out.println(a & b);     //按位与
        System.out.println(a | b);     //按位或
        System.out.println(~a);        //按位取反
        System.out.println(a ^ b);     //按位异或
    }
}

运行结果：

5.移位运算符

Java 的移位运算符有 3 个：<< (左移) 、>> (右移) 、>>> (无符号右移)

规则：

<<: 高位舍去，低位补 0 。

>>: 低位舍去，高位补符号位（正数0/负数1）。

>>>: 低位舍去，高位补 0 。

实例：


public class Test {
    //移位运算符
    public static void main(String[] args) {
        int a = 1;  //0000 0000 0000 0000 0000 0000 0000 0001
        int b = -1; //1111 1111 1111 1111 1111 1111 1111 1111
        System.out.println(a << 1);
        System.out.println(b >> 1);
        System.out.println(b >>> 1);
    }
}

运行结果：

6.条件运算符

Java 中的条件运算符只有一个，同时也是唯一一个三目运算符。

写法：

表达式1 ? 表达式2 : 表达式3

规则：

表达式1为true，则表达式2为整个表达式的结果；若表达式1为false，表达式3为整个表达式的结果。

实例：


public class Test {
    //三目运算符
    public static void main(String[] args) {
        System.out.println(3 > 5 ? 4 : 20);
        System.out.println(3 < 5 ? 4 : 20);
    }
}

运行结果：

7.运算符的优先级

有关优先级，在我们使用的时候，只需要填上合适的括号就可以了，并不需要去死记硬背！！！

当然，如果是为了应付考试，那就可以去适当的记一下。

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/290866