Java 操作符陷阱

1、优先级

public class Precedence {

	public static void main(String[] args) {
		int x = 1, y = 2, z = 3;
		int a = x + y - 2 / 2 + z;		// (1)
		int b = x + (y - 2) / (2 + z);	// (2)
		System.out.println("a = " + a + " b = " + b);
	}
} /* 输出结果:
a = 5 b = 1
*///:~

    写了注释的两条语句看起来大体相同，但是从输出就可以看出它们具有迥然不同的含义，而这正是使用括号的结果。

    请注意，System.out.println()语句中包含“+”操作符。在这种上下文环境中，“+”意味着“字符串连接”，并且如果必要，它还要执行“字符串转换”。当编译器观察到一个String后面紧跟一个“+”，而这个“+”的后面又紧跟一个非String类型的元素时，就会尝试着将这个非String类型的元素转换成String。正如输出中所看到的，它成功地将a和b从int转换成String了。

2、赋值

class Tank {
	int level;
}

public class Assignment {

	public static void main(String[] args) {
		Tank t1 = new Tank();
		Tank t2 = new Tank();
		t1.level = 10;
		t2.level = 47;
		System.out.println("1: t1.level: " + t1.level +
				", t2.level: " + t2.level);
		t1 = t2;
		System.out.println("2: t1.level: " + t1.level +
				", t2.level: " + t2.level);
		t1.level = 27;
		System.out.println("3: t1.level: " + t1.level +
				", t2.level: " + t2.level);
	}
} /* 输出结果:
1: t1.level: 10, t2.level: 47
2: t1.level: 47, t2.level: 47
3: t1.level: 27, t2.level: 27
*///:~

    Tank类的两个实例（t1和t2）是在main()里创建的。对每个Tank类对象的level域都赋予了一个不同的值，然后，将t2赋给t1，接着又修改了t1。由于赋值操作的是一个对象的引用，所以修改t1的同时也改变了t2！这是因为t1和t2包含的是相同的引用，它们指向相同的对象。（原本t1包含的对对象的引用，是指向一个值为10的对象。在对t1赋值的时候，这个引用被覆盖，也就是丢失了；而那个不再被引用的对象会由“垃圾回收器”自动清理。）
2.1、方法调用中的别名问题

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';
		System.out.println("1: x.c: " + x.c);
		f(x);
		System.out.println("2: x.c: " + x.c);
	}
} /* 输出结果:
1: x.c: a
2: x.c: z
*///:~

    方法f()似乎要在它的作用域内复制其参数Letter y的一个副本；但实际上只是传递了一个引用。所以，y.c = 'z';这行代码实际改变了f()之外的对象。

3、关系操作符

3.1、测试对象的等价性

<pre name="code" class="java">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));
	}
} /* 输出结果:
false
true
*///:~

    System.out.println(n1 == n2)输出的结果对于第一次接触关系操作符的人感到惊讶。因为两个Integer对象都是相同的，但是对象的引用却是不同，而==和!=比较的就是对象的引用。所以输出结果实现上先是false再是true。如果想比较两个对象的实际内容是否相同，可以使用equals()，示例中注释的那行。但这个方法不适用于“基本类型”，基本类型直接使用==和!=即可。

class Value {
	int i;
}
public class EqualsMethod {

	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));
	}
} /* 输出结果:
false
*///:~

    这种情况equals()输出的也是false！这是由于equals()的默认行为是比较引用。所以除非自己在Value类中覆盖equals()方法，否则不可能表现出我们期望的结果。大多数java类库都实现了equals()方法，以便用来比较对象的内容，而非比较对象的引用。

4、逻辑操作符

4.1、短路

public class ShortCircuit {
	
	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 < 1));
		return val < 2;
	}
	
	static boolean test3(int val) {
		System.out.println("test3(" + val + ")");
		System.out.println("result: " + (val < 1));
		return val < 3;
	}
	
	public static void main(String[] args) {
		boolean b = test1(0) && test2(2) && test3(2);
		System.out.println("expression is " + b);
	}
} /* 输出结果:
test1(0)
result: true
test2(2)
result: false
expression is false
*///:~

    对于test1(0) && test2(2) && test3(2)表达式，你很有可能会认为这三个测试都会被执行。但输出显示却并非如此。第一个测试生成结果为true，所以表达式会继续下去。然而，第二个测试产生了一个false结果。这意味着整个表达式肯定为false，所以没必要继续计算剩余的表达式，那样只是浪费。“短路”一词的由来正源于此。事实上，如果所有的逻辑表达式都有一部分不必计算，那将获得潜在的性能提升。

    关于操作符陷阱，就写到这。