- 在最底层,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 查看本文章
![](/qrcode.jpg)
按位操作符
- 按位操作符用来操作证书基本数据类型中的单个 比特 ,即二进制位。按位操作符会对俩个参数中对应的位执行布尔代数运算,并生成一个最终结果。
- 按位操作符来源于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()方法