Java编程思想-操作符

在最底层,Java中的数据是通过使用操作符来操作的。

使用Java操作符

操作符接受一个或多个参数,并生成一个新值。参数的形式与普通的方法调用不同,但效果是相同的。加号和一元的正号(+), 减号和一元的符号(-), 乘号(*) ,除号(/) 以及赋值号(=)的用法与其他编程语言类似。
操作符作用于操作数,生成了一个新值。另外,有些操作符可能会改变操作数自身的值, 这被称为副作用。那些能改变其操作数的操作符,最普遍的用途就是产生副作用,但要记住,使用此类操作符生成的值,与使用没有副作用的操作符生成的值,没有什么区别。
几乎所有的操作符都只能操作基本数据类型。例外的操作符是 = ,== , != 这些操作符能操作所有的对象。除此以外,String 类支持 + 和 +=。

优先级

当一个表达式中存在多个操作符时,操作符的优先级就决定了各部分的计算顺序。Java对计算顺序做了特别的规定,其中,最简单的规则就是先乘除后加减。程序员会经常忘记其他优先规则,所以应该用括号明确规定计算顺序。

    public static void main(String[] args) {
     int x=1;int y=2;int z=3;
     int a=x+y-2/2+z;
     int b=x+(y-2)/(2+z);
        System.out.println(a); //result 5
        System.out.println(b);//result 1
    }

注意 : 这俩个语句看起来大体相同,但是从输出就可以看出它们具有迥然不同的含义,而这正是使用括号的结果。

赋值

=赋值使用操作符 = 。它的意思是取右边的值(即右值),把它复制给左边(即左值)。右值可以是任何常数,变量或者表达式(只要它能生成一个值就行)。但左值必须是一个明确的,已命名的变量。也就是说,必须有一个屋里空间可以存储等号右边的值。举例来说,可将一个常数赋给一个变量:

a=4;

但是不能把任何东西赋给一个常数,常数不能作为左值例如(4=a)
对基本数据类型的赋值是很简单的。基本类型存储了实际的数据,而并非指向了一个对象的引用,所以在为其赋值的时候,是直接将一个地方的内容复制到了另一个地方。例如,对基本数据类型使用 a=b,那么b的内容就复制给a ,若接着又修改了a,而b根本不会受这种修改的影响。

public class AllTheColorsOfTheRainbow {
    int anIntegerRepresentingColors;

    public static void main(String[] args) {
        AllTheColorsOfTheRainbow allTheColorsOfTheRainbow1 = new AllTheColorsOfTheRainbow();
        AllTheColorsOfTheRainbow allTheColorsOfTheRainbow2 = new AllTheColorsOfTheRainbow();
        allTheColorsOfTheRainbow1.anIntegerRepresentingColors=20;
        allTheColorsOfTheRainbow2.anIntegerRepresentingColors=30;
        System.out.println("1==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow1.anIntegerRepresentingColors);
        System.out.println("1==>1allTheColorsOfTheRainbow2.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow2.anIntegerRepresentingColors);

        allTheColorsOfTheRainbow1=allTheColorsOfTheRainbow2;
        System.out.println("2==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow1.anIntegerRepresentingColors);
        System.out.println("2==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow2.anIntegerRepresentingColors);

        allTheColorsOfTheRainbow1.anIntegerRepresentingColors=25;
        System.out.println("3==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow1.anIntegerRepresentingColors);
        System.out.println("3==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow2.anIntegerRepresentingColors);
    }
}


//运行结果为
1==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:20
1==>1allTheColorsOfTheRainbow2.anIntegerRepresentingColors:30
2==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:30
2==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:30
3==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:25
3==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:25

AllTheColorsOfTheRainbow 类非常简单,它的俩个实例 (allTheColorsOfTheRainbow1和allTheColorsOfTheRainbow2)都是在main()创建的。对于每个 AllTheColorsOfTheRainbow 类对象的 anIntegerRepresentingColors 域都赋予了一个不同的值,然后 allTheColorsOfTheRainbow2 赋给 allTheColorsOfTheRainbow1 ,接着又修改了 allTheColorsOfTheRainbow1。
在许多编程语言中,我们可能会期望 allTheColorsOfTheRainbow2 和 allTheColorsOfTheRainbow1总是相互独立的。但由于赋值操作是一个对象的引用,所以修改 allTheColorsOfTheRainbow1的同时也改变了 allTheColorsOfTheRainbow2! 这是由于allTheColorsOfTheRainbow1 和 allTheColorsOfTheRainbow2包含相同的引用,它们指向相同的对象。(原本 allTheColorsOfTheRainbow1 包含的对对象的引用,是指向一个值为20的对象。在堆allTheColorsOfTheRainbow1 赋值的时候,这个引用被覆盖,也就是数据丢失了,而那个不在被引用的对象会由垃圾回收器自动清理。)
这种特殊的现象通常称作别名现象,是Java操作对象的一种基本方式。在这个例子中,如果想避免别名问题,应该怎么办呢?可以这样写

allTheColorsOfTheRainbow1.anIntegerRepresentingColors=allTheColorsOfTheRainbow2.anIntegerRepresentingColors;

这样便可以保持俩个对象彼此独立。而不是 allTheColorsOfTheRainbow1 和 allTheColorsOfTheRainbow2绑定到相同的对象。但你很快就会意识到,直接操作对象内的作用域容易导致混乱,并且,违背了良好的面向对象程序设计的原则。这可不是一个小问题,所以从现在开始大家就应该留意,为对象赋值可能会产生意想不到的结果。

方法调用中的别名问题

当一个对象传递给方法时,也会产生别名问题:

public class PassObject {
    static void letterMethod(Letter letter){
        letter.field='h';
    }
    public class Letter{
        char field;
    }
    public static void main(String[] args) {
        PassObject passObject = new PassObject();
        //创建内部类对象
        PassObject.Letter letter = passObject.new Letter();
        letter.field='a';
        System.out.println("1==>letter.field:"+letter.field);

        letterMethod(letter);
        System.out.println("2==>letter.field:"+letter.field);
    }
}
//运行结果为
1==>letter.field:a
2==>letter.field:h

在许多编程语言中,方法letterMethod()似乎要在它的作用域内复制其参数 Letter letter的一个副本,但实际上只是传递了一个引用。所以代码行

letter.field='h';

实际改变的是 letterMethod()之外的对象。

算术操作符

Java 的基本算术操作符与其他大多数程序设计语言是相同的。其中包括加号(+),减号(-),除号(/),乘号(*)以及取模操作符(%,它从整数除法中产生余数)。整数除法会直接去结果的小数位,而不是四舍五入地圆整结果。
Java 也使用一种来自C和C++的简化符号同时进行运算与赋值操作。这用操作符后紧跟一个等号来表示,它对于Java 中的所有操作符都适用,值要其有实际意义就行。例如, 要将 x加4,并将结果赋回给x,可以这么写:x+=4。
Random类的对象,程序可生成许多不同类型的随机数字。Random类有方法 nextInt()和 nextFloat()即可

一元加,减,操作符

一元减号(-)和一元加号(+)与二元减号和加号都是用相同的符号。根据表达式的书写形式,编译器会自动判断出使用的是哪一种。例如语句

x = -a;
//的含义是显然的,编译器能正确识别下述语句。

x = a * -b;

//但是读者会被搞糊涂,所以有时更明确地写成:
x = a * (-b);

一元减号用于转变数据的符号,而一元加号只是为了与一元减号相对应,但是它唯一的作用仅仅是将较小类型的操作数提升为int。

自动递增和递减

和C类似,Java提供了大量的快捷运算。这些快捷运算使编码更方便,同时也使代码更容易阅读,但是有时可能使代码阅读起来更困难。
递增和递减运算是俩种相当不错的快捷运算(常被称为自动递增和自动递减运算)。其中,递减操作符 -- 意为减少一个单位. 递增操作符是 ++ 意为增加一个单位。举个例子来说,假设a是一个int值,则表达式 ++a 就等同于 a=a+1 。递增和递减操作符不进改变了变量,并且以变量的值作为生成的结果。
这俩个操作符各有俩种使用方式,通常称为前缀式和后缀式

前缀递增表示 ++ 操作符位于变量或者表达式前面。类似于前缀递减意为着 -- 操作符位于变量或者表达式前面。
后缀递增表示 ++ 操作符位于变量或表达式的后面。类似于后缀递减意为着-- 操作符位于变量或者表达式后面。

对于前缀递增和前缀递减(如 ++a / --a) 会先执行运算,在生成值。
对于后缀递增和后缀递减(a++ / a--)会先生成值,在执行运算。

        int a=1;
        int b=a++;
        System.out.println("a:"+a);  //a=2
        System.out.println("b:"+b); //b=1
        int c=1;
        int d=++c;
        System.out.println("c:"+c); //c=2
        System.out.println("d:"+d); //d=2
        
        int e=1;
        e=e++;
        System.out.println("e:"+e); //e=1
        
        int f=1;
        f=++f;
        System.out.println("f:"+f); //2

e并没有给我们想一样进行自增!
原因: ++(--) 操作是具有返回值的,当 ++(--) 在变量前面的时候返回值为自增(自减)后面的值,当++(--)在变量后面的时候返回值为自增(自减)前面的值,在 e=e+1时,e++返回值为1,所以e没有变化。
在实际开发过程中++(--)在变量后的情况尽量不要把结果赋值给其他变量。

关系操作符

关系操作符生成的是一个boolean(布尔)结果,它们计算的是操作数的值之间的关系。如果关系是真实的,关系表达式会生成true(真),如果关系是不真实,则会生成false(假)。关系操作符包括小于(<) , 大于(>) , 小于或等于(<=) ,大于或等于(>=) , 等于(==) 一级不等于(!=)。

    public static void main(String[] args) {
    Integer integer1=new Integer(47);
    Integer integer2=new Integer(47);
        System.out.println(integer1 == integer2);  //false
        System.out.println(integer1 != integer2);  //true
    }

你可能觉得输出的结果肯定先是 true 再是false ,因为俩个Integer 对象都是相同的,但是尽管对象的内容相同,然而对象的引用却是不同,而 == 和 != 比较的就是对象的引用。所以输出实际结果先是 false 后是 true 。
如果你想比较俩个对象的实际内容是否相同,又该如何操作呢?如下

    public static void main(String[] args) {
    Integer integer1=new Integer(47);
    Integer integer2=new Integer(47);
        System.out.println(integer1.equals(integer2));   //true
    }

结果正如我们所料想那样为true,但是事情并没有那么简单,加入自己创建一个类,然后equals判断是否相同如下

public class Calculation {
    int number;
    public static void main(String[] args) {
        Calculation calculation1=new Calculation();
        Calculation calculation2=new Calculation();
        calculation1.number=20;
        calculation2.number=20;
        System.out.println(calculation1.equals(calculation2)); //false
    }
}

事情再次变得令人费解? 结果又是false ,这是由于equals的默认行为是比较引用所以除非在自己的新类中覆盖equals方法,否则不可能表现出我们希望的行为。
如上 Integer 类中重写了 Object 的equals方法如下

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

所以如果你想在自己创建的新类判断是否相同,也需要重写equals方法

逻辑操作符

逻辑操作符与(&&) , 或 (||) , 非(!) 能根据参数的逻辑关系,生成一个布尔值 (true 或者 false)
与 , 或 ,非只能用于布尔值。与C及C++中不同的是:不可将一个非布尔值当作布尔值在逻辑表达式中使用。

短路

当使用逻辑操作符时,我们会遇到一种短路现象。即一旦能够明确无误地确定整个表达式的值,就不再计算表达式余下部分了。因此,整个逻辑表达式靠后的部分有可能不会被运算。

直接常量

一般来说,如果程序里使用了直接常量 ,编译器可以准确地知道要生成什么样的类型,但有时候却是模棱两可的,如果发生这种情况,必须对编译器加以适当的指导们用与直接量相关的某些字段来额外增加一些信息。
直接常量后面的后缀字符标志了它的类型。若为大写(或小写)的L 则表示long(但是,使用小写字母I 容易造成混淆,因为它看起来很像数字1)。大写(或小写)字母F则表示float, 大写(或小写)字母D,则表示 double。
十六进制数适用于所有证书数据类型,以前缀0x(或0X),后面跟随0-9或小写(或大写)的a-f来表示。如果试图将一个变量初始化成超出自身表示范围的值(无论这个值得数值形式如何),编译器都会向我们报告一条错误信息。
八进制数由前缀0以及后续的0-7的数字来表示。
在C,C++或者Java中,二进制数没有直接常量表示方法。但是,在使用十六进制和八进制记数法时,以二进制形式显示结果将非常有用。通过Integer 和 Long类的静态方法 toBinaryString()可以很容易实现这一点。

扫描二维码关注公众号，回复： 10564864 查看本文章

按位操作符

按位操作符用来操作证书基本数据类型中的单个比特 ,即二进制位。按位操作符会对俩个参数中对应的位执行布尔代数运算,并生成一个最终结果。
按位操作符来源于C语言面向底层的操作,在这种操作中经常需要直接操纵硬件,设置硬件寄存器内的二进制。Java的设置初衷是嵌入电视机机顶盒内,所以这种面向底层的操作人呗保留了下来。但是,人们可能不会过多地用到位操作符。
如果俩个输入位都是1 ,则按位与(&) 生成一个输出位1,否则生成一个输出位0。如果俩个输入位只要有一个1,则按位或(|)生成一个输出位1。只要两个输入位都是0的情况下,他才会生成一个输出位0。如果输入位的某一个是1,但不全都是1,那么按位异或(^)会生成一个输出位1。按位非(~) 也被称为取反操作符,它属于一元操作符,只对一个操作数进行操作(其他按位操作符是二元操作符)。按位非生成与输入位相反的值 __若输入0,则输出1 ,若输出1 则返回0。

        //按位 &
        System.out.println(1&1); //result 1
        System.out.println(1&0); //result 0
        System.out.println(0&0); //result 0

        //按位 |
        System.out.println(0|1);//result 1
        System.out.println(0|0);//result 0
        System.out.println(1|1);//result 1

        //按位 异或 ^
        System.out.println(1^0); //1
        System.out.println(1^1); //0
        System.out.println(0^0); //0

按位操作符和逻辑操作符都使用了同样的符号,因此我们能方便地记住它们的含义:由于位是非常小的,所以按位操作符仅使用了一个字符。
按位操作符可与等号(=)联合使用,以便合并运算和赋值: &=,!=和^=都是合法的(由于~ 是一元操作符,所以不可与 = 联合使用)

移位操作符

官方文档说明
移位操作符操作的运算对象也是二进制的位。移位操作符只可用来处理整数类型(基本类型的一种)。左移位操作符(<<)能按照操作符右侧指定的位数将操作符左边的操作数向左移动(在低位补0)。有符号右移操作符(>>) 则按照操作符右侧指定的位数将操作符左边的操作数向右移动。
有符号右移操作符使用符号扩展,若符号为正,则在高位插入0,若符号为负,则高位2插入1,Java中增加了一种无符号右移操作符(>>>)它使用零扩展,无论正负,都在高位插入0。这一操作符是C和C++中所没有的。
如果对char , byte 或者 short 类型的数值进行移位处理, 那么再移位之前,它们会被转换成int类型,并且得到的结果也是一个int类型的值。
移位可以与等号 (<<= 或 >>= 或 >>>=) 组合使用。此时,操作符左边的值会移动由右边的值指定位数,再将的到的结果赋给左边的变量,再将得到的结果赋给左边的变量。
简单理解就是
移位运算符是位操作符的一种。移位运算符可以在二进制的基础上对数字进行平移。按照平移的方法和填充数字的规则分为三种

<< : 左移运算符 ,例如 a<< 1 相当于 a*2
>> : 右移运算符,例如 a>>1 相当于 a/2
>>> : 无符号右移,忽略符号位,空位都以0补齐。(计算机中数字以补码存储,首位为符号位)
例如

    public static void main(String[] args) {
        //Integer.toBinaryString()是将数字用二进制格式显示
        
        //右移运算符
        System.out.println(Integer.toBinaryString(-10>>2));
        //左移位移符
        System.out.println(Integer.toBinaryString(-10<<2));
        //无符号右移
        System.out.println(Integer.toBinaryString(-10>>>2));


        //运行结果为
        11111111111111111111111111111101
        11111111111111111111111111011000
        111111111111111111111111111101(省略了首位俩个0)
    }

字符串操作符+和+=

这个操作符在Java中有一项特殊用途: 连接不同的字符串。
字符串操作有一些很有趣的行为。如果表达式以一个字符串起头,那么后续所有操作数都必须是字符串型(请记住,编译器会把双引号内的字符序列自动转成字符串)如下

    public static void main(String[] args) {
        int x=0;
        int y=1;
        int z=2;
        String str="x,y,z";
        //result x,y,z012
        System.out.println(str+x+y+z);
        //result 0 x,y,z
        System.out.println(x+" "+str);
        str +="(summed)= ";
        //result x,y,z(summed)= 3
        System.out.println(str+(x+y+z));
        //result  0
        System.out.println(" "+x);
    }

三元此操作符if-else

三元操作符也被称为条件操作符,它显得比较特别,因为它有三个操作数,但它确实属于操作符的一种因为它最终也会生成一个值,其表达式如下

boolean-exp? value0 : value1

如果 boolean-exp(布尔表达式)的结果为true,就计算 value0 ,而且这个计算结果也就是操作符最终产生的值,如果boolean-exp的结果为false,就计算value1,同样,它的结果也就成为了操作符最终产生的值。
当然,也可以换用普通的if-else,但三元操作符更加简洁。尽管C(C中发现了该操作符)引以为傲的就是它是一种简练的语言,而且三元操作符的引入多半就是为了体现这种高效率的编程,但假如你打算频繁使用它,还是要多作思量,因为它很容易产生永恒可读性极差的代码。
条件操作符与if-else完全不同,因为它会产生一个值。如下进行比较

public class Calculation {
    static int sumResult(int i){
        return i<10 ? i*10 :i*100;
    }

    static int staticSumResult(int i){
        if (i<10){
            return i*10;
        }else {
            return i*100;
        }
    }

    public static void main(String[] args) {
        System.out.println(sumResult(9));//90
        System.out.println(sumResult(10));// 1000
        System.out.println(staticSumResult(9));//90
        System.out.println(staticSumResult(10));//1000
    }
}

我们可以看出 sumResult() 中代码与 staticSumResult()中不用三元操作符的代码相比,显得更加紧凑,但staticSumResult()更易理解,而且不需要太多的录入,所有在使用三元草自作符时,请务必仔细考虑。

使用操作符时常犯的错误

使用操作符时一个常犯的错误就是,即使对表达式如何计算有点不确定,也不愿意使用括号。这个问题在Java中仍然存在。
在C和C++中,一个特别常见的错误如下:

while(x = y){
//...
}

程序员很明显是想测试是否相等(==),而不是进行赋值操作。在C和C++中,如果y是一个非零值,那么这种赋值的结果肯定是true,而这样便会得到一个无穷循环。在Java中,这个表达式的结果并不是布尔值,而编译器期望的是一个布尔值。由于Java不会自动地将int数值转换成布尔值,所以在编译时会抛出一个编译时错误,从而阻止我们进一步去运行程序。所以这种情况在Java中永远不会出现(唯一不会得到编译时错误的情况是x和y都为布尔值。在这种情况下,x=y属于合法表达式。而在前面表达式例子中,则可能是一个错误)。
Java中有一个与C和C++类似的问题,即使用按位与和按位或代替逻辑与和逻辑或。按位与和按位或使用单字符(&或|) ,而逻辑与和逻辑或使用双字符 (&& 或||) 就像 = 和 == 一样,键入一个字符当然要比键入俩个简单。Java编译器可防止这个错误发生,因为它不允许我们随便把一种类型当做另一种类型来用。

类型转换操作符

类型转换(cast)的原意是模型铸造。在适当的时候,Java会将一种数据类型自动转换成另一种,例如,假设我们为某浮点变量赋以一个整数值,编译器会将int 自动转换成float。类型转换运算允许我们显式地进行这种数据的转换,或者在不能自动进行转换的时候强制进行类型转换。
要想执行类型转换,需要将希望得到的数据类型置于圆括号内,放在要进行类型转换的值左边如int a=1; Long b=(Long)a;
在Java中,类型转换则是一种比较安全的操作。然而,如果,要执行一种名为窄化转换的操作(也就是说,将能容纳更多的数据类型转换成无法容纳那么多信息的类型,可能面临信息丢失的危险。此时,编译器会强制我们进行类型转换,这实际上是说这可能是一件危险的事情,如果无论如何要这么做,必须显式地进行类型转换,而对于扩展转换,则不必显式地进行类型转换,因为新类型肯定能容纳原来类型的信息,不会造成任何信息的丢失。
Java中允许我们把任何基本数据类型转换成别的基本数据类型,但布尔类型除外,后者根本不允许进行任何类型的转换处理。类数据类型不允许进行类型转换。为了将一种类转换成另一种必须采用特殊的方法。

截尾和舍入

在执行窄化转换时,必须注意截尾和舍入问题。例如,如果将一个浮点值转换为整数值,Java会如何处理呢?如下

       double dou1=0.4d;
       double dou2=0.7d;
       float flo1=0.4f;
       float flo2=0.7f;
        System.out.println((int)dou1);//0
        System.out.println((int)dou2);//0
        System.out.println((int)flo1);//0
        System.out.println((int)flo2);//0

因此答案是在 float 或 double 转型为整型值时,总是对该数字执行截尾。如果想要得到舍入的结果,就需要使用java.lang.Math中的rund()方法:

    public static void main(String[] args) {
       double dou1=0.4d;
       double dou2=0.7d;
       float flo1=0.4f;
       float flo2=0.7f;

        System.out.println(Math.round(dou1));// 0
        System.out.println(Math.round(dou2));// 1
        System.out.println(Math.round(flo1));// 0
        System.out.println(Math.round(flo2));// 1

    }

提升

如果对基本数据类型执行算术运算或按位运算,大家会发现,只要类型比int小(即char,byte或者short),那么再运算之前,这些值会自动转换成int 。这样一来,最终生成的结果就是int类型。如果想把结果赋值给较小的类型,就必须使用类型转化(即然把结果赋给了较小的类型,就可能出现信息丢失)。通常,表达式中出现的最大的数据类型决定了表达式最终结果的数据类型。如果将一个float值与一个double值相乘,结果就是 double ,如果将一个int 和一个long值相加 ,则结果为long。

Java没有sizeof

在C和C++中,sizeof()操作符可以告诉你为数据项分配的字节数。在C和C++中,需要使用 sizeof()的最大原因是为了移植 ,不同的数据类型在不同的机器上可能有不同的大小,所以在进行一些与存储空间相关的运算时,程序员必须获悉那些类型具体有多大。例如,一台计算机可用32位来保存整数,而另外一台只用16位保存。显然,在第一台机器中,程序可保存更大的值。可以想象,移植是令C和C++程序员颇为头疼的一个问题。
Java不需要使用sizeof()操作符来满足这方面的需求,因为所有数据类型在所有机器中的大小都是相同的。我们不必考虑移植问题__它已经被设计在语言中了。

总结

如果你拥有编程语言的经验,那么只要它的语法类似于C,你就会发现Java中的操作符与它们是多么的相似,以至于对你来说没有任何学习困难。
本章学了 Java操作符 +,-,*,/ 操作符的优先级,可以使用括号来明确计算顺序,使用 = 进行赋值, 算术操作符有学习了 %(取模),一元加减操作符 , 自动递增和递减 ++a --a 与 a++ ,a-- (前缀递增/递减-->先运算后赋值反之后缀递增/递减先赋值后运算),
又学了关系操作符 < , > , <= , >= ,== 以及 != 还学了逻辑操作符 &&(逻辑与) , ||(逻辑或) 和 ! (逻辑非
又学了按位操作符 &(按位与) , |(按位或) ,^(按位异或) 和 ~(按位非) ,接下来移位操作 << (左移操作符),>> (右移操作符) ,>>>(无符号操作符) ,其中又学了三元操作符if-else,请谨慎使用三元操作符。
类型转换操作符 (cast), Java中没有sizeof()方法

北岛荒丶南城NULL

发布了256 篇原创文章 · 获赞 188 · 访问量 65万+

他的留言板关注

Java编程思想-操作符

使用Java操作符

优先级

赋值

方法调用中的别名问题

算术操作符

一元加,减,操作符

自动递增和递减

关系操作符

逻辑操作符

短路

直接常量

按位操作符

移位操作符

字符串操作符+和+=

三元此操作符if-else

使用操作符时常犯的错误

类型转换操作符

截尾和舍入

提升

Java没有sizeof

总结

猜你喜欢