java编程思想——第3章 操作符

3.2使用java操作符

操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的值，这被称为“副作用”。

3.4赋值

赋值使用操作符“=”，意思是“取右边的值，把它复制给左边”。

(1)基本数据类型的赋值：基本类型存储了实际的数值，而并非指向一个对象的引用，所以在为其赋值的时候，是直接将一个地方的内容赋值到另外一个地方。

(2)对象的赋值：对一个对象进行操作时，我们真正操作的是对象的引用，所以倘若“将一个对象复制给另一个对象”，实际是将“引用”从一个地方复制到另外一个地方。

例如以下别名现象：

class Tank{
    int level;
}
public class Assignment{
    public static void main(String[] args){
        Tank t1 = new Tank();
        Tank t2 = new Tank();
        t1.level = 9;
        t2.level = 47;
        print(“1:t1.level:” + t1.level + “2:t2.level:” + t2.level);                //t1 = 9 t2 = 47
        t1 = t2;    
        print(“2:t1.level:” + t1.level + “2:t2.level:” + t2.level);                //t1 = 47 t2 = 47
        t1 = 27;
        print(“3:t1.level:” + t1.level + “2:t2.level:” + t2.level);                //t1 = 27 t2 = 27
    } 
}

方法中调用的别名问题

class Letter{
    char c;
}
public class PassObject{
    static void 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);            //1:x.c: a
        f(x);
        print("2:x.c: "+ x.c);            //2:x.c: z
    } 
}

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

3.6自动递增和递减

++，--唯一具有“副作用”的操作运算符

3.7关系操作符

(1)测试对象的等价性

== 和 != 比较的是对象的引用

特殊方法equals() 的默认行为也是比较引用

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);
        System.out.println(n1.equals(n2));

        Value v1 = new Value();
        Value v2 = new Value();
        v1.i = v2.i = 47;
        System.out.println(v1.equals(v2));
    }

}
class Value{
    int i;
}
/* Output:
* false
* true
* true
* false
*/

以上， 

a. n1 和 n2 是两个不同的引用（明显是两个不同的存储区域），所以二者 !=。 

b. equals() 方法是所有对象的特殊方法（继承自Object类），Integer重定义了equals()方法以比较其内容是否相等，所以这里n1.equals(n2) 为 true。equals()不适用于“基本类型”，基本类型直接使用==和!=即可。

c. v1.equals(v2)为 false 验证了 equals()方法默认行为是比较引用，除非在自定义类Value中重定义 equals()方法。

3.9直接常量

有时直接常量的类型是模棱两可的，这就需要与直接常量相关的某些字符来额外增加一些信息以“指导”编译器，使其能够准确地知道要生成什么样的类型。如果编译器能够正确地识别类型，就不必在数值后增加字符。

在C、C++或者Java中，二进制数没有直接常量表示方法。但是，在使用十六进制和进制的记数法时，以二进制形式显示结果将非常有用。通过使用Integer和Long类的静态方法toBinaryString()可以很容易地实现这一点。注意，如果将比较小的类型传递给Integer.toBinaryString()方法，则该类型将自动转换为int。

// Literals.java
public class Literals{
    public static void main(String[] args){
        int i1 = 0x2f;  // Hexadecimal (lowercase)
        System.out.println("i1: " + Integer.toBinaryString(i1));
        int i2 = 0X2F;  // Hexadecimal (uppercase)
        System.out.println("i2: " + Integer.toBinaryString(i2));
        int i3 = 0177;  // Octal (leading zero)
        System.out.println("i3: " + Integer.toBinaryString(i3));
        char c = 0xffff;    // max char hex value
        System.out.println("c: " + Integer.toBinaryString(c));
        byte b = 0x7f;  // max short hex value
        System.out.println("b: " + Integer.toBinaryString(b));
        short s = 0x7fff;   // max short hex value
        System.out.println("s: " + Integer.toBinaryString(s));
        long n1 = 200L; // long suffix
        long n2 = 200l; // long suffix (but can be confusing)
        long n3 = 200;
        float f1 = 1;
        float f2 = 1F;  // float suffix
        float f3 = 1f;  // float suffix
        double d1 = 1d; // double suffix
        double d2 = 1D; // dobule suffix
        // (Hex and Octal also work with long)
    }
    /* OUtput:
    * i1: 101111
    * i2: 101111
    * i3: 1111111
    * c: 1111111111111111
    * b: 1111111
    * s: 111111111111111
    * */
}

十六进制前缀0X(或0x)，八进制前缀0。

指数计数法中e代表为“10的幂次”。

3.10按位操作符

按位操作符用来操作整数基本类型中的单个“比特（bit）”，即二进制位。

按位操作符来源于C语言面向底层的操作，在这种操作中经常需要直接操纵硬件，设置硬件，寄存器内的二进制位。java的设计初衷是嵌入电视机机顶盒内，所以这种面向底层的操作仍被保留了下来。

3.11移位操作符

左移(<<)（乘2）,右移(>>)（除2）

3.15类型转换

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

(2)溢出。如果对两个足够大的int值执行乘法运算，结果就会溢出。编译器不会发出错误或警告信息，运行时也不会出现异常。这说明Java虽然是好东西，但也没有那么好！

// 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 big1 = big + 1;
        System.out.println("big1 = " + big1);
        int bigger = big * 4;
        System.out.println("bigger = " + bigger);       
    }
}
/* Output:
big = 2147483647
big1 = -2147483648
bigger = -4
*/

3.16java没有sizeof  

在C和C++中，sizeof()操作符可以告诉你为数据项分配的字节数。使用这个操作符的最大原因是为了进行一些与存储空间有关的运算，使程序可以在不同平台上“移植”。而Java不需要sizeof()操作符来满足这方面的需要，因为所有数据类型在所有机器中的大小是相同的。我们不必考虑移植问题——它已经被设计在语言中了。