Java编程思想学习(三)----第三章：操作符
3.2使用Java操作符
操作符接受一个或多个参数，并生成一个新值。
操作符作用于操作数，生成一个新值。有些操作符可以改变操作数自身的值。几乎所以的操作符都只能操作“基本类型”。例外的操作符有“=”，“==”，“！=”，这些操作符能操作所有对象。String支持“+”和“+=”。
3.3优先级
@Test public void precedence() { int x=1,y=2,z=3; int a = x+y-2/2+z; int b = x + (y -2)/(2 - z); System.out.println("a = " + a + "b = " + b); //a = 5b = 1 }/* Output:a = 5 b = 1*///:~
System.out.println()语句中，当编译器观察到一个String后面紧跟一个“+”，而这个“+”的后面又紧跟一个非String类型的元素时，就会尝试将非String类型元素转换为String。
3.4赋值
对基本数据类型的赋值是很简单的。基本类型存储了实际的数值，而并非指向一个对象的引用，所以在为其赋值的时候，是直接将一个地方的内容复制到另一个地方。
但是对象”赋值“的时候，情况发生了变化。对一个对象进行操作时，我们真正操作的是对对象的引用。
class Tank { float level; } public class Assignment { public static void main(String[] args) { TankOld t1 = new TankOld(); TankOld t2 = new TankOld(); t1.level = 18; t2.level = 24; System.out.println("1:t1.level: "+t1.level + ", t2.level: "+t2.level); t1 = t2; System.out.println("1:t1.level: "+t1.level + ", t2.level: "+t2.level); t1.level = 33; System.out.println("1:t1.level: "+t1.level + ", t2.level: "+t2.level); test(); }/* Output: 1:t1.level: 18.0, t2.level: 24.0 1:t1.level: 24.0, t2.level: 24.0 1:t1.level: 33.0, t2.level: 33.0 test--------------- 1:t1.level: 18.0, t2.level: 24.0 1:t1.level: 24.0, t2.level: 24.0 1:t1.level: 33.0, t2.level: 24.0 *///:~ public static void test() { System.out.println("test---------------"); TankOld t1 = new TankOld(); TankOld t2 = new TankOld(); t1.level = 18; t2.level = 24; System.out.println("1:t1.level: "+t1.level + ", t2.level: "+t2.level); t1.level = t2.level; System.out.println("1:t1.level: "+t1.level + ", t2.level: "+t2.level); t1.level = 33; System.out.println("1:t1.level: "+t1.level + ", t2.level: "+t2.level); } }
原本t1包含的对对象的引用，是指向一个值为9的对象。在t1赋值时，这个引用被覆盖了，也就是丢失；而那个不再被引用的对象会由“垃圾回收器”自动清理。
避免错误可以写成：t1.level = t2.level;
直接操作对象内的域容易导致混乱，违背了良好的面向对象程序设计的原则。
3.4.1方法调用中的别名问题
class Letter{ char c; } public class PassObject{ static voic f(Letter y){ y.c = 'z'; } public static void main(String[] args){ Letter x = new Letter(); x.c = 'a'; print("1:x.c:"+x.c); f(x); print("2:x.c:"+x.c); } }/* Output: 1:x.c:a 2:x.c:z *///~
现在需要知道它的存在，并在使用中注意这个陷阱。
3.5算数操作符
Java的基本算术操作符与其他大多数程序设计语言是相同的。其中包括加号(+)、减号(-)、除号(／)、乘号(*)以及取模操作符(%，它从整数除法中产生余数)。整数除法会直接去掉结果的小数位，而不是四舍五入地圆整结果。
简化符号同时进行运算和赋值操作。如x = x + 4,可以写为 x += 4。
要生成数字，程序首先会创建一个Random类的对象。如果在创建过程中没有传递任何参数，那么Java就好将当前时间作为随机数生成器的种子，并由此在程序每一次执行都产生不一样的输出。通过在创建Random对象时提供种子（随机数生产器对于特定的种子总是产生相同的随机数序列），就可以在每一次执行过程序时都生成相同的随机数。
3.5.1一元加、减操作符
一元减号用于转变数据的符号，而一元加号只是为了和一元减号相对应，但是它唯一的作用仅仅是讲较小类型的操作数提升为int。
3.6自动递增和递减
对于前缀递增和递减（如++a或--a)，会先执行运算，在生成值。而对于后缀递增和后缀递减（如a++或a--），会先生成值在执行运算。它们是除了赋值操作符以外，唯一具有“副作用”的操作符。他们会改变操作数，而不仅仅是使用自己的值。
3.7关系操作符
关系操作符包括小于(<)、大于(>)、小于或等于(<=)、大于或等于(>=)、等于(==)以及不等于(!=)。
3.7.1测试对象的等价性
public class Equivalence { public static void main(String[]args){ Integer n1 = new Integer(47)； Integer n2 = new Integer(47); System.out.println(n1 == n2); System.out.println(n1 != n2); } }/*Output: false true *///：~
但是尽管对象的内容相同，然而对象的引用却是不同的，而==和!=比较的就是对象的引用。
如果想比较两个对象的实际内容是否相同，又该如何操作呢？此时，必须使用所有对象都适用的特殊方法equals()但这个方法不适用于“基本类型”，基本类型直接使用==和!=即可。
class Value{ int i; } public class EqualsMethod2{ public static void main(String[] args) { Value v1 = new Value(); Value v2 = new Value(); v1.i = v2.i = 100; System.out.println(v1.equals (v2)); } }/*Output: false *///：~
equals()的默认行为是比较引用。所以除非在自己的新类中覆盖equals()方法，否则不可能表现出我们希望的行为。
大多数Java类库都实现了equals()方法，以便用来比较对象的内容，而非比较对象的引用。
3.8逻辑操作符
逻辑操作符“与”(&&)、“或”(||)、“非”(! )能根据参数的逻辑关系，生成一个布尔值(true或false)。
与在C及C++中不同的是：不可将一个非布尔值当作布尔值在逻辑表达式中使用。如果在应该使用String值的地方使用了布尔值，布尔值会自动转换成适当的文本形式。
在上述程序中，可将整数类型替换成除布尔型以外的其他任何基本数据类型。但要注意，对浮点数的比较是非常严格的。即使一个数仅在小数部分与另一个数存在极微小的差异，仍然认为它们是“不相等”的。
3.8.1 短路
public class ShortCircult{ static boolean test1(int val){ System.out.println("test1(" + val + ")"); System.out.println("result: " + (val < 1)); return val < 1; } static boolean test2(int val){ System.out.println("test2(" + val + ")"); System.out.println("result: " + (val < 2)); return val < 2; } static boolean test3(int val){ System.out.println("test3(" + val + ")"); System.out.println("result: " + (val < 3)); return val < 3; } public static void main(String[] args) { boolean b=test1(0)&&test2(2)&&test3(2); System.out.println("expression is " + b); } }/*Output: test1 (0) result: true test2 (2) result: false expression is false *///：~
第二个测试产生了一个false结果。由于这意味着整个表达式肯定为false，所以没必要继续计算剩余的表达式，那样只是浪费。“短路”一词的由来正源于此。
3.9 直接常量
@Test public void literalsTest1() { int i1 = 0x2f; // 十六进制（小写标识） System.out.println("i1: " + Integer.toBinaryString(i1)); int i2 = 0x2F; // 十六进制（大写标识） System.out.println("i2: " + Integer.toBinaryString(i2)); int i3 = 0177; // 八进制（前导零） System.out.println("i3: " + Integer.toBinaryString(i3)); char c = 0xffff; // 超出char自身的范围 System.out.println("c: " + Integer.toBinaryString(c)); byte b = 0x7f; // 超出byte自身范围 System.out.println("b: " + Integer.toBinaryString(b)); short s = 0x7fff; // 超出short自身范围 System.out.println("s: " + Integer.toBinaryString(s)); long n1 = 200L; // long后缀 System.out.println("n1: " + Long.toBinaryString(n1)); long n2 = 200l; // long后缀（和1容易引起混淆） System.out.println("n2: " + Long.toBinaryString(n2)); long n3 = 200; System.out.println("n3: " + Long.toBinaryString(n3)); float f1 = 1; float f2 = 1f; // float后缀 float f3 = 1F; // float后缀 double d1 = 1d; // double后缀 double d2 = 1D; // double后缀 } /* Output: i1: 101111 i2: 101111 i3: 1111111 c: 1111111111111111 b: 1111111 s: 111111111111111 n1: 11001000 n2: 11001000 n3: 11001000 *///:~
如果在程序里使用了“直接常量”，编译器可以准确地知道要生成什么样的类型，但有时候却是模棱两可的。
直接常量后面的后缀字符标志了它的类型。若为大写（或小写）的L，代表long（但是，使用小写字母l容易造成混淆，因为它看起来很像数字1）。大写（或小写）字母F，代表float；大写（或小写）字母D，则代表double。
十六进制数适用于所有整数数据类型，以前缀0x（或0X），后面跟随0-9或小写（或大写）的a-f来表示。如果试图将一个变量初始化成超出自身表示范围的值（无论这个值的数值形式如何），编译器都会向我们报告一条错误信息。如果超出范围，编译器会将值自动转换成int型，并告诉我们需要对这次赋值进行“窄化转型”。如果将比较小的类型传递给Integer.toBinaryString()方法，则该类型将自动被转换为int。
3.9.1 指数记数法
@Test public void exponents() { //大写和小写一样 float expFloat = 1.39e-43f; expFloat = 1.39E-43f; System.out.println(expFloat); double expDouble = 47e47d; // 'd'可选 double expDouble2 = 47e47d; // 自动转为double System.out.println(expDouble); float f4 = 1e-43f; // 10的次方 float f5 = (float) Math.pow(10, -43f); System.out.println(f4); System.out.println(f5); System.out.println(f4 == f5); } /* Output: 1.39E-43 4.7E48 1.0E-43 1.0E-43 true *///:~
设计师们很自然地决定e代表“10的幂次”。
那么在Java中看到像1.39e-43f 这样的表达式时，请转换思维，它真正的含义是1.39×10-43。
编译器通常会将指数作为双精度数(double)处理，所以假如没有这个尾随的f，就会收到一条出错提示，告诉我们必须使用类型转换将double转换成float。
3.10 按位操作符
按位操作符会对两个参数中对应的位执行布尔代数运算，并最终生成一个结果。
①如果两个输入位都是1，则按位“与”操作符(&)生成一个输出位1；否则生成一个输出位0。
②如果两个输入位里只要有一个是1，则按位“或”操作符 (|) 生成一个输出位1；只有在两个输入位都是0的情况下，它才会生成一个输出位0。
③如果输入位的某一个是1，但不全都是1，那么按位“异或”操作 (^) 生成一个输出位1。
④按位“非”(~)，也称为取反操作符，它属于一元操作符，只对一个操作数进行操作（其他按位操作符是二元操作符）。按位“非”生成与输入位相反的值——若输入0，则输出1，若输入1，则输出0。
按位操作符和逻辑操作符都使用了同样的符号，因此我们能方便地记住它们的含义：由于位是非常“小”的，所以按位操作符仅使用了一个字符。
对于布尔值，按位操作符具有与逻辑操作符相同的效果，只是它们不会中途“短路”。
3.11 移位操作符
">>" "<<"
Java中增加了一种“无符号”右移位操作符(>>>)，它使用“零扩展”：无论正负，都在高位插入0。这一操作符是C或C++中所没有的。只有数值右端的低5位才有用。这样可防止我们移位超过int型值所具有的位数。若对一个long类型的数值进行处理，最后得到的结果也是long。此时只会用到数值右端的低6位，以防止移位超过long型数值具有的位数。
“移位”可与“等号”（<<=或>>=或>>>=）组合使用。如果对byte或short值进行这样的移位运算，得到的可能不是正确的结果。它们会先被转换成int类型，再进行右移操作，然后被截断，赋值给原来的类型，在这种情况下可能得到-1的结果。
@Test public void bitManipulation() { Random rand = new Random(47); int i = rand.nextInt(); int j = rand.nextInt(); printBinaryInt("-1", -1); printBinaryInt("+1", +1); int maxpos = 2147483647; printBinaryInt("maxpos", maxpos); int maxeng = -2147483648; printBinaryInt("maxeng", maxeng); printBinaryInt("i", i); printBinaryInt("j", j); printBinaryInt("~j", ~j); printBinaryInt("-i", -i); printBinaryInt("i & j", i & j); printBinaryInt("i | j", i | j); printBinaryInt("i ^ j", i ^ j); printBinaryInt("i << 5", i << 5); printBinaryInt("i >> 5", i >> 5); printBinaryInt("(~i) >> 5", (~i) >> 5); printBinaryInt("i >>> 5", i >>> 5); printBinaryInt("(~i) >>> 5", (~i) >>> 5); // 10111010001001000100001010010101 //11111101110100010010001000010100 //00000101110100010010001000010100 /* Output: -1, int: -1, binary: 11111111111111111111111111111111 +1, int: 1, binary: 1 maxpos, int: 2147483647, binary: 1111111111111111111111111111111 maxeng, int: -2147483648, binary: 10000000000000000000000000000000 i, int: -1172028779, binary: 10111010001001000100001010010101 j, int: 1717241110, binary: 1100110010110110000010100010110 ~j, int: -1717241111, binary: 10011001101001001111101011101001 -i, int: 1172028779, binary: 1000101110110111011110101101011 i & j, int: 570425364, binary: 100010000000000000000000010100 i | j, int: -25213033, binary: 11111110011111110100011110010111 i ^ j, int: -595638397, binary: 11011100011111110100011110000011 i << 5, int: 1149784736, binary: 1000100100010000101001010100000 i >> 5, int: -36625900, binary: 11111101110100010010001000010100 (~i) >> 5, int: 36625899, binary: 10001011101101110111101011 i >>> 5, int: 97591828, binary: 101110100010010001000010100 (~i) >>> 5, int: 36625899, binary: 10001011101101110111101011 */ long l = rand.nextLong(); long m = rand.nextLong(); printBinaryLong("-1L", -1L); printBinaryLong("+1L", +1L); long ll = 9223372036854775807L; printBinaryLong("maxpos", ll); long lln = -9223372036854775808L; printBinaryLong("maxeng", lln); printBinaryLong("l", l); printBinaryLong("m", m); printBinaryLong("~m", ~m); printBinaryLong("-l", -l); printBinaryLong("l & m", l & m); printBinaryLong("l | m", l | m); printBinaryLong("l ^ m", l ^ m); printBinaryLong("l << 5", l << 5); printBinaryLong("l >> 5", l >> 5); printBinaryLong("(~l) >> 5", (~l) >> 5); printBinaryLong("l >>> 5", l >>> 5); printBinaryLong("(~l) >>> 5", (~l) >>> 5); /* Output: -1L, Long: -1, binary: 1111111111111111111111111111111111111111111111111111111111111111 +1L, Long: 1, binary: 1 maxpos, Long: 9223372036854775807, binary: 111111111111111111111111111111111111111111111111111111111111111 maxeng, Long: -9223372036854775808, binary: 1000000000000000000000000000000000000000000000000000000000000000 l, Long: -8652529054300476342, binary: 1000011111101100000010101010101100001101101011000110110001001010 m, Long: 2955289354441303771, binary: 10100100000011010011000000001010010011111101111010011011011011 ~m, Long: -2955289354441303772, binary: 1101011011111100101100111111110101101100000010000101100100100100 -l, Long: 8652529054300476342, binary: 111100000010011111101010101010011110010010100111001001110110110 l & m, Long: 72066398748419146, binary: 100000000000010000000001000000001101001000010010001001010 l | m, Long: -5769306098607591717, binary: 1010111111101111010011101010101110011111111111111110111011011011 l ^ m, Long: -5841372497356010863, binary: 1010111011101111010001101010100110011110010110111100101010010001 l << 5, Long: -179768631971968704, binary: 1111110110000001010101010110000110110101100011011000100101000000 l >> 5, Long: -270391532946889886, binary: 1111110000111111011000000101010101011000011011010110001101100010 (~l) >> 5, Long: 270391532946889885, binary: 1111000000100111111010101010100111100100101001110010011101 l >>> 5, Long: 306069219356533602, binary: 10000111111011000000101010101011000011011010110001101100010 (~l) >>> 5, Long: 270391532946889885, binary: 1111000000100111111010101010100111100100101001110010011101 */ printBinaryLong("i ^ m", i ^ m); /* Output: * i ^ m, Long: -2955289355552037810, binary: * 1101011011111100101100111111110100101001110100111110010001001110 */ char cone = 'a'; int conei = 'a'; char ctwo = 2; char cthree = '0'; printBinaryInt("cthree", cthree); cthree = (char) (cone + ctwo); printBinaryInt("cone", cone); printBinaryInt("conei", conei); printBinaryInt("ctwo", ctwo); printBinaryInt("cthree", cthree); /* Output: * 扩展 cthree, int: 48, binary: 110000 cone, int: 97, binary: 1100001 conei, int: 97, binary: 1100001 ctwo, int: 2, binary: 10 cthree, int: 99, binary: 1100011 */ } public void printBinaryInt(String s, int i) { System.out.println(s + ", int: " + i + ", binary:\n " + Integer.toBinaryString(i)); } public void printBinaryLong(String s, Long l) { System.out.println(s + ", Long: " + l + ", binary:\n " + Long.toBinaryString(l)); }
3.12 三元操作符if-else
三元操作符: boolean-exp ? value0 : value1
也可以换用普通的if-else语句（在后面介绍），但三元操作符更加简洁。
3.13 字符串操作符+和+=
引入了操作符重载(operator overloading)机制。表达式以一个字符串起头，那么后续所有操作数都必须是字符串型。
3.14 使用操作符时常犯的错误
while(x=y){ //...... }
不会得到编译时错误的情况是x和y都为布尔值。在这种情况下，x=y属于合法表达式。
3.15 类型转换操作符
如果要执行一种名为窄化转换(narrowing conversion)的操作（也就是说，将能容纳更多信息的数据类型转换成无法容纳那么多信息的类型），就有可能面临信息丢失的危险。而对于扩展转换(widelung conversion)．则不必显式地进行类型转换，因为新类型肯定能容纳原来类型的信息，不会造成任何信息的丢失。
Java允许我们把任何基本数据类型转换成别的基本数据类型，但布尔型除外，后者根本不允许进行任何类型的转换处理。“类”数据类型不允许进行类型转换。
对象可以在其所属类型的类族之间可以进行类型转换，例如，“橡树”可转型为“树”，反之亦然。但不能把它转换成类族以外的类型，如“岩石”。
3.15.1 截尾和舍入
将float或double转型为整型值时，总是对该数字执行截尾。如果想要得到舍入的结果，就需要使用java.lang.Math中的round()方法。
3.15.2 提升
表达式中出现的最大的数据类型决定了表达式最终结果的数据类型。如果将二个float值与一个double值相乘，结果就是double，如果将一个int和一个long值相加，则结果为long。
3.16 Java没有sizeof
在C和C++中，sizeof()操作符可以告诉你为数据项分配的字节数。在C和C++中，需要使用sizeof()的最大原因是为了“移植”。不同的数据类型在不同的机器上可能有不同的大小，所以在进行一些与存储空间有关的运算时，程序员必须获悉那些类型具体有多大。Java不需要sizeof()操作符来满足这方面的需要，因为所有数据类型在所有机器中的大小都是相同的。
3.17 操作符小结
//:operators/AllOps.java //Tests all the operators on all the primitive data types to show which ones are //accepted by the Java compiler. public class AllOps{ //To accept the results of a boolean test: void f(boolean b){ } void boolTest(boolean x, boolean y){ //Arithmetic operators: //! x=x*y; //! x=x/y; //! x=x%y; //! x=x+y; //! x=x-y; //! x++; //! x--; //! x=+y; //! x=-y; //Relational and logical: //! f(x>y); //! f(x>=y); //! f(x<y); //! f(x<=y); f(x == y); f(x != y); f(!y); x = x && y; x = x || y; //Bitwise operators: //! x=~y; x = x & y; x = x | y; x = x ^ y; //! x=x<<1; //! x=x>>1; //! x=x>>>1; //Compound assignment: //! x+=y; //! x-=y; //! x*=y; //! x/=y; //! x%=y; //! x<<=1; //! x>>=1; //! x>>>=1; x &= y; x ^= y; x |= y; //Casting: //! char c=(char)x; //! byte b=(byte)x; //! short s=(short)x; //! int i=(int)x; //! long l=(long)x; //! double d=(double)x; } void charTest(char x, char y){ //Arithmetic operators: x = (char) (x * y); x = (char) (x / y); x = (char) (x % y); x = (char) (x + y); x = (char) (x - y); x++; x--; x = (char) +y; x = (char) -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: x = (char) ~y; x = (char) (x & y); x = (char) (x | y); x = (char) (x ^ y); x = (char) (x << 1); x = (char) (x >> 1); x = (char) (x >>> 1); //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; //Casting: //! boolean b1=(boolean)x; byte b = (byte) x; short s = (short) x; int i = (int) x; long l = (long) x; float f = (float) x; double d = (double) x; } void byteTest(byte x, byte y){ //Arithmetic operators: x = (byte) (x * y); x = (byte) (x / y); x = (byte) (x % y); x = (byte) (x + y); x = (byte) (x - y); x++; x--; x = (byte) +y; x = (byte) -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: x = (byte) ~y; x = (byte) (x & y); x = (byte) (x | y); x = (byte) (x ^ y); x = (byte) (x << 1); x = (byte) (x >> 1); x = (byte) (x >>> 1); //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; //Casting: //! boolean b1=(boolean)x; char c = (char) x; short s = (short) x; int i = (int) x; long l = (long) x; float f = (float) x; double d = (double) x; } void shortTest(short x, short y){ //Arithmetic operators: x = (short) (x * y); x = (short) (x / y); x = (short) (x % y); x = (short) (x + y); x = (short) (x - y); x++; x--; x = (short) +y; x = (short) -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: x = (short) ~y; x = (short) (x & y); x = (short) (x | y); x = (short) (x ^ y); x = (short) (x << 1); x = (short) (x >> 1); x = (short) (x >>> 1); //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; //Casting: //! boolean b1=(boolean)x; char c = (char) x; byte b = (byte) x; int i = (int) x; long l = (long) x; float f = (float) x; double d = (double) x; } void intTest(int x, int y){ //Arithmetic operators: x = x * y; x = x / y; x = x % y; x = x + y; x = x - y; x++; x--; x = +y; x = -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: x = ~y; x = x & y; x = x | y; x = x ^ y; x = x << 1; x = x >> 1; x = x >>> 1; //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; //Casting: //! boolean b1=(boolean)x; char c = (char) x; byte b = (byte) x; short s = (short) x; long l = (long) x; float f = (float) x; double d = (double) x; } void longTest(long x, long y){ //Arithmetic operators: x = x * y; x = x / y; x = x % y; x = x + y; x = x - y; x++; x--; x = +y; x = -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: x = ~y; x = x & y; x = x | y; x = x ^ y; x = x << 1; x = x >> 1; x = x >>> 1; //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; //Casting: //! boolean b1=(boolean)x; char c = (char) x; byte b = (byte) x; short s = (short) x; int i = (int) x; float f = (float) x; double d = (double) x; } void floatTest(float x, float y){ //Arithmetic operators: x = (x * y); x = (x / y); x = (x % y); x = (x + y); x = (x - y); x++; x--; x = +y; x = -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: //! x = (float) ~y; //! x = (float) (x & y); //! x = (float) (x | y); //! x = (float) (x ^ y); //! x = (float) (x << 1); //! x = (float) (x >> 1); //! x = (float) (x >>> 1); //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; //! x <<= 1; //! x >>= 1; //! x >>>= 1; //! x &= y; //! x ^= y; //! x |= y; //Casting: //! boolean b1=(boolean)x; char c = (char) x; byte b = (byte) x; short s = (short) x; int i = (int) x; long l = (long) x; double d = (double) x; } void doubleTest(double x, double y){ //Arithmetic operators: x = (x * y); x = (x / y); x = (x % y); x = (x + y); x = (x - y); x++; x--; x = +y; x = -y; //Relational and logical f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //! f(!x); //! f(x&&y); //! f(x||y); //Bitwise operators: //! x = (float) ~y; //! x = (float) (x & y); //! x = (float) (x | y); //! x = (float) (x ^ y); //! x = (float) (x << 1); //! x = (float) (x >> 1); //! x = (float) (x >>> 1); //Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; //! x <<= 1; //! x >>= 1; //! x >>>= 1; //! x &= y; //! x ^= y; //! x |= y; //Casting: //! boolean b1=(boolean)x; char c = (char) x; byte b = (byte) x; short s = (short) x; int i = (int) x; long l = (long) x; } }
在char、byte和short中，我们可看到使用算术操怍符中数据类型提升的效果。对这些类型的任何一个进行算术运算，都会获得一个int结果，必须将其显式地类型转换回原来的类型（窄化转换可能会造成信息的丢失），以将值赋给原本的类型。但对于int值，却不必进行类型转化，因为所有数据都已经属于int类型。但不要放松警惕，认为一切事情都是安全的，如果对两个足够大的int值执行乘法运算，结果就会溢出。下面这个例子向大家展示了这一点:
//:operators/Overflow.java //Surprise! Java lets you overflow. public class Overflow{ public static void main(String[] args) { int big = Integer.MAX_VALUE; System.out.println("big = " + big); int bigger = big * 4; System.out.println("bigger = " + bigger); } }/*Output: big = 2147483647 bigger = -4 *///:~
