Think in Java - Chatpter 3 控制程序流程

程序员经常都会忘记其他优先级规则，所以应该用括号明确规定计算顺序。

// Assignment with objects is a bit tricky
class Number{
	int i;
}

public class Assignment {

	public static void main(String[] args) {
		Number n1 = new Number();
		Number n2 = new Number();
		n1.i = 9;
		n2.i = 47;
		System.out.println("[1] n1.i: " + n1.i + " , n2.i: " + n2.i);
		
		n1=n2;
		System.out.println("[2] n1.i: " + n1.i + " , n2.i: " + n2.i);
		
		n1.i = 27;
		System.out.println("[3] n1.i: " + n1.i + " , n2.i: " + n2.i);
	}
}
/*
[1] n1.i: 9 , n2.i: 47
[2] n1.i: 47 , n2.i: 47
[3] n1.i: 27 , n2.i: 27
*/

// Passing objects to methods can be a bit tricky
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
*/

// Demonstrates the ++ and -- operators
public class AutoInc {
	static void prt(String s) {
		System.out.println(s);
	}

	public static void main(String[] args) {
		int i = 1;
		prt("i: " + i);
		prt("++i: " + ++i);
		prt("i++: " + i++);
		
		prt("i: " + i);
		prt("--i: " +--i);
		prt("i--: " + i--);
		
		prt("i: " + i);
	}
}
/*
i: 1
++i: 2
i++: 2
i: 3
--i: 2
i--: 2
i: 1
*/

//由于 equals()的默认行为是比较句柄。所以除非在自己的新类中改变了equals()，否则不可能表现出我们希望的行为
//大多数Java 类库都实现了equals()，所以它实际比较的是对象的内容，而非它们的句柄。
class Value{
	int i;
}

public class Test {

	public static void main(String[] args) {
		Value v1 = new Value();
		Value v2 = new Value();
		v1.i = v2.i = 100;
		System.out.print(v1.equals(v2));
		
		Integer i1 = new Integer(1);
		Integer i2 = new Integer(1);
		System.out.print(i1.equals(i2));
	}

}
/*
false
true
*/

// Surprise! Java lets you overflow.
// 如果对两个足够大的 int 值执行乘法运算，结果值就会溢出。
public class Oveflow {

	public static void main(String[] args) {
		int big = 0x7fffffff; // max int value
		prt("big = " + big);
		int bigger = big * 4;
		prt("bigger = " + bigger);
	}
	
	static void prt(String s){
		System.out.println(s);
	}
}

 

return：

• 指定一个方法返回什么值（假设它没有void返回值）
• 并立即返回那个值。

break & continue：

• break 强行退出循环，不再执行循环中剩下的语句
• 停止执行当前的循环，然后退回循环起始处，开始新的循环

//Demonstrates break and continue keywords
public class BreakAndContinue {

	public static void main(String[] args) {
		for(int i=0; i<100; i++){
			if(i==74)
				break; //out of for loop
			if(i%9 != 0)
				continue; //next iteration
			System.out.println(i);
		}
		int i=0;
		//an "infinite loop"
		while(true){
			i++;
			int j = i*27;
			if(j==1269)
				break; //out of loop
			if(i%10 != 0)
				continue; // top of loop
			System.out.println(i);
		}
	}
}
/*
0
9
18
27
36
45
54
63
72
10
20
30
40
*/

 标签：

label：

1. 简单的一个 continue 会退回最内层循环的开头（顶部），并继续执行。
2. 带有标签的 continue 会到达标签的位置，并重新进入紧接在那个标签后面的循环。
3. break 会中断当前循环，并移离当前标签的末尾。
4. 带标签的break 会中断当前循环，并移离由那个标签指示的循环的末尾。

 Switch：

根据一个整数表达式的值，switch语句可从一系列代码选出一段执行。

要求使用一个选择因子，并且必须是int 或char 那样的整数值。

假若将一个字串或者浮点数作为选择因子使用，那么它们在switch语句里是不会工作的。

对于非整数类型，则必须使用一系列if语句。

//What happen when you cast a float or double to an integral value?
//将一个 float或double 值造型成整数值后，总是将小数部分“砍掉”，不作任何进位处理。
public class CastingNumbers {

	public static void main(String[] args) {
		double above = 0.7,
				below = 0.4;
		System.out.println("above : " + above);
		System.out.println("below : " + below);
		System.out.println("(int)above : " + (int)above);
		System.out.println("(int)below : " + (int)below);
		
		System.out.println("(char)('a' + above): " + (char)('a' + above));
		System.out.println("(char)('a' + below): " + (char)('a' + below));
	}
}
/*
above : 0.7
below : 0.4
(int)above : 0
(int)below : 0
(char)('a' + above): a
(char)('a' + below): a
*/