Java面向对象系列[v1.0.0][运算符]

算数运算符

加法运算符

double a = 5.2;
double b = 3.1;
double sum = a + b;
System.out.printlb(sum);

加法运算符除了用来计算加法，还可以用于字符串的连接运算符

减法运算符

double a = 5.2;
double b = 3.1;
double sub= a - b;
System.out.printlb(sub);

减法运算符除了用来计算减法，还可以用于求负运算符

乘法运算符

double a = 5.2;
double b = 3.1;
double multiply= a * b;
System.out.printlb(multiply);

除法运算符

如果两个操作数都是整型，计算结果也会是整型，如果出现小数位不会四舍五入，而是直接截取整数位

public class DivTest
{
    public static void main(String[] args)
    {
        var a = 5.2;
        var b = 3.1;
        var div = a / b;
        // div的值将是1.6774193548387097
        System.out.println(div);
        // 输出正无穷大：Infinity
        System.out.println("5除以0.0的结果是:" + 5 / 0.0);
        // 输出负无穷大：-Infinity
        System.out.println("-5除以0.0的结果是:" + - 5 / 0.0);
        // 下面代码将出现异常
        // java.lang.ArithmeticException: / by zero
        System.out.println("-5除以0的结果是::" + -5 / 0);
    }
}

求余运算符

public class ModTest
{
    public static void main(String[] args)
    {
        var a = 5.2;
        var b = 3.1;
        var mod = a % b;

        System.out.println(mod); // mod的值为2.1
        System.out.println("5对0.0求余的结果是:" + 5 % 0.0); // 输出非数:NaN
        System.out.println("-5.0对0求余的结果是:" + -5.0 % 0); // 输出非数:NaN
        System.out.println("0对5.0求余的结果是:" + 0 % 5.0); // 输出0.0
        System.out.println("0对0.0求余的结果是:" + 0 % 0.0); // 输出非数:NaN
        // 下面代码将出现异常：java.lang.ArithmeticException: / by zero
        System.out.println("-5对0求余的结果是:" + -5 % 0);
    }
}

自加运算符

int a = 5;
int b = a++ + 6;
System.out.println(a + "\n" + b);

int a = 5;
int b = ++a + 6;
System.out.printlb(a + "\n" + b);

自减运算符

自加和自减只能用于操作变量，不能用于操作数值直接量、常量或表达式，例如5++、6—等都是错的

Math工具类

public class MathTest
{
    public static void main(String[] args)
    {
        var a = 3.2; // 定义变量a为3.2
        // 求a的5次方，并将计算结果赋为b。
        double b = Math.pow(a, 5);
        System.out.println(b); // 输出b的值。
        // 求a的平方根，并将结果赋给c
        double c = Math.sqrt(a);
        System.out.println(c); // 输出c的值。
        // 计算随机数,返回一个0～1之间的伪随机数。
        double d = Math.random();
        System.out.println(d); // 输出随机数d的值
        // 求1.57的sin函数值：1.57被当成弧度数
        double e = Math.sin(1.57);
        System.out.println(e); // 输出接近1
    }
}

赋值运算符

Java使用=作为赋值运算符

public class AssignOperatorTest
{
    public static void main(String[] args)
    {
        var str = "Java"; // 为变量str赋值为Java
        var pi = 3.14; // 为变量pi赋值为3.14
        var visited = true; // 为变量visited赋值为true
        var str2 = str; // 将变量str的值赋给str2
        int a;
        int b;
        int c;
        // 通过为a, b, c赋值，三个变量的值都是7
        a = b = c = 7;
        // 输出三个变量的值。
        System.out.println(a + "\n" + b + "\n" + c);

        var d1 = 12.34;
        var d2 = d1 + 5; // 将表达式的值赋给d2
        System.out.println(d2); // 输出d2的值，将输出17.34

    }
}

比较运算符

比较运算符用于判断两个变量或常量的大小，比较运算的结果是一个布尔值true/false

>：大于，只支持左右两边操作数是数值类型
>=：大于或等于，只支持左右两边操作数是数值类型
<：小于，只支持左右两边操作数是数值类型
<=：小于或等于，只支持左右两边操作数是数值类型
==：如果比较两个操作数都是数值类型，即使他们的数据类型不同，只要他们的值相等，则返回true，例如97=‘a’, 5.0==5都将返回true；如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时，才可以比较，且这两个引用必须指向同一个对象才会返回true；Java支持两个boolean类型的值进行比较，例如true==false将返回false
!=：

public class ComparableOperatorTest
{
    public static void main(String[] args)
    {
        System.out.println("5是否大于 4.0：" + (5 > 4.0)); // 输出true
        System.out.println("5和5.0是否相等：" + (5 == 5.0)); // 输出true
        System.out.println("97和'a'是否相等：" + (97 == 'a')); // 输出true
        System.out.println("true和false是否相等：" + (true == false)); // 输出false
        // 创建2个ComparableOperatorTest对象，分别赋给t1和t2两个引用
        var t1 = new ComparableOperatorTest();
        var t2 = new ComparableOperatorTest();
        // t1和t2是同一个类的两个实例的引用，所以可以比较，
        // 但t1和t2引用不同的对象，所以返回false
        System.out.println("t1是否等于t2：" + (t1 == t2));
        // 直接将t1的值赋给t3，即让t3指向t1指向的对象
        var t3 = t1;
        // t1和t3指向同一个对象，所以返回true
        System.out.println("t1是否等于t3：" + (t1 == t3));
    }
}

逻辑运算符

&&：与字符，前后两个操作数同时为true才返回true，否则返回false
&：不短路与字符，作用与&&相同，但不会短路
||：或字符，前后两个操作数同时为false才会返回false，否则返回true
|：不断路或字符，作用与||相同，但不会短路
!：非，只需要一个操作数，如果操作数是true，则返回false，如果操作数为false，则返回true
^：异或，当两个操作数不同时才返回true，相同则返回false

public class LogicOperatorTest
{
    public static void main(String[] args)
    {
        // 直接对false求非运算，将返回true
        System.out.println(!false);
        // 5>3返回true，'6'转换为整数54，'6'>10返回true，求与后返回true
        System.out.println(5 > 3 && '6' > 10);
        // 4>=5返回false，'c'>'a'返回true。求或后返回true
        System.out.println(4 >= 5 || 'c' > 'a');
        // 4>=5返回false，'c'>'a'返回true。两个不同的操作数求异或返回true
        System.out.println(4 >= 5 ^ 'c' > 'a');

        // 定义变量a,b，并为两个变量赋值
        var a = 5;
        var b = 10;
        // 对a > 4和b++ > 10求或运算
        if (a > 4 | b++ > 10)
        {
            // 输出a的值是5，b的值是11。
            System.out.println("a的值是:" + a + "，b的值是:" + b);
        }

        // 定义变量c,d，并为两个变量赋值
        var c = 5;
        var d = 10;
        // c > 4 || d++ > 10求或运算
        if (c > 4 || d++ > 10)
        {
            // 输出c的值是5，d的值是10。
            System.out.println("c的值是:" + c + "，d的值是:" + d);
        }

    }
}

位运算符

Java支持的位运算符共7个

&：按位与，同时为1时才返回1
|：按位或，同时为0时才返回0
~：换位非，单目运算符，将操作数的每个位（包括符号位）全部取反
^：按位异或，当两位相同时返回0，不同时返回1
<<：左移运算符
>>：右移运算符
>>>：无符号右移运算符

一般来说位运算符只能操作整数类型的变量或者值，运算法则如下

public class BitOperatorTest
{
    public static void main(String[] args)
    {
//        System.out.println(2.5 & 3.0);
        System.out.println(5 & 9); // 将输出1
        System.out.println(5 | 9); // 将输出13
        System.out.println(~-5); // 将输出4
        System.out.println(5 ^ 9); // 将输出12
        System.out.println(5 << 2); // 输出20
        System.out.println(-5 << 2); // 输出-20
        System.out.println(-5 >> 2); // 输出-2
        System.out.println(-5 >>> 2); // 输出1073741822
    }
}

~-5的运算过程

5^9的运算过程

左移运算符是将操作数的二进制码整体左移指定位数，左移后右边空出来的位以0填充

右移操作符是将操作数的二进制码右移指定位数后，左边空出来的位以原来的符号位填充，如果操作数原来是正数，则左边补0，如果操作数原来是负数，则左边补1，而>>>比较特殊，无符号右移d的意思就是无论整数还是负数，左边都补0
-5>>2的运算结果

-5>>>2的运算结果

进行移位运算时，还应该遵循如下规则：

• 对于低于int类型的（byte、short和char）的操作数总是先自动类型转换位int类型后再移位
• 对于int类型的整数移位a>>b，当b大于32时，系统先用b对32求余(因为int类型只有32位),得到的结果才是真正移位的位数，那么a>>33和a>>1的结果完全一样，a>>32和a完全相同
• 对于long类型的整数移位a>>b，当b>64时总是先用b对64求余，得到的结果才是真正的移位位数
• 当进行移位运算时，只要被移位的二进制码没有发生有效位的数字丢失（对于正数而言，通常被移出的位全部都是0），不难发现左移n位就是相当于乘以2的n次方，右移n位则是除以2的n次方
• 进行移位运算不会改变操作数本身，只是得到了一个新的运算结果，而原来的操作数本身是不会改变的

赋值运算符扩展

+=：x+=y，即对应于x=x+y
-= ：x-=y，即对应于x=x-y
*=：x*=y， 即对应于x=x*y
/=：x/=y，即对应于x=x/y
%=：x%=y，即对应于x=x%y
&=：x&=y，即对应于x=x&y
|=：x|=y，即对应于x=x|y
^=：x^=y，即对应于x=x^y
<<=：x<<=y，即对应于x=x<<y
>>=：x>>=y，即对应于x=x>>y
>>>=：x>>>=y，即对应于x=x>>>y

public class EnhanceAssignTest
{
    public static void main(String[] args)
    {
        // 定义一个byte类型的变量
        byte a = 5;
        // 下面语句出错，因为5默认是int类型，a + 5就是int类型。
        // 把int类型赋给byte类型的变量，所以出错
        // a = a + 5;
        // 定义一个byte类型的变量
        byte b = 5;
        // 下面语句不会出现错误
        b += 5;
    }
}

使用扩展运算符，不仅具有更好的性能而且程序健壮性也更好

三目运算符

三目运算符:[?:],语法格式如下
(expression) ? if-true-statement : if-false-statement;
其规则是先对逻辑表达式expression求值，如果逻辑表达式返回true,则返回第二个操作数的值，如果逻辑表达式返回false，则返回第三个操作数的值

public class ThreeTest
{
    public static void main(String[] args)
    {
        String str = 5 > 3 ? "5大于3" : "5不大于3";
        System.out.println(str); // 输出"5大于3"
        String str2 = null;
        if (5 > 3)
        {
            str2 = "5大于3";
        }
        else
        {
            str2 = "5不大于3";
        }
        var a = 11;
        var b = 12;
        // 三目运算符支持嵌套
        System.out.println(a > b ? "a大于b" : (a < b ? "a小于b" : "a等于b"));
    }
}

三目运算符和if else写法的区别在于，if后的代码块可以有多个语句，但三目运算符是不支持三个语句的，但三目运算符支持嵌套

运算符的结合及优

Java语言大部分运算符是从左向右结合的，只有单目运算符、赋值运算符和三目运算符例外，他们是从右向左结合的，也就是从右向左运算

int a = 5; int b = 4; int c = a++ - —b * ++a/b— >>2%a--;