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()操作符来满足这方面的需要，因为所有数据类型在所有机器中的大小是相同的。我们不必考虑移植问题——它已经被设计在语言中了。
