海老师的技术博客： OCA 考试 准备笔记（二）：Operators and Statements

这一章主要关于Java中的运算和逻辑语句。 首先，对于运算要明确运算的不一定是按照从左往右的顺序进行，例如：

int y = 4;
double x = 3 + 2 * --y; // 此运算顺序为从从右往左进行

以下为运算的优先等级：

1. Binary Arithmetic Operators：

1. Arithmetic Operators
   主要包括 +, -, *, /, %, ++, - - 这些基础的数学运算以及优先等级，在这就不做过多的讲解。
2. Numeric Promotion
   这是关于primitive 类型的一些原则，需要理解并记住
   1. 如果两个值的类型不同，Java会自动把其中类型占用空间小的一个提升为类型占用空间大的那个类型，从而使两个值都为类型占用空间大的那个类型。
   2. 如果一个是integer类型，另一个是floating-point类型， Java会自动提升integer 那个成为 floating-point 类型。
   3. 小类型，byte, short, char，在与binary arithmetic operator使用时会被提升为int类型。
   4. 当所有的提升完成后，所有值都有相同的数据类型，结果值的数据类型也将是相同的提升后的类型。

---------原则1的例子---------
	int x = 1;
	long y = 33;
	x * y  的类型?   
	根据原则1， 类型小的值的类型会被提升为类型大的值的数据类型，
	所以int会被提升为long， 结果的类型为 long
---------原则1的例子---------
	double x = 39.21;
	float y = 2.1;
	x + y 的类型？
	这题有个陷阱，x + y 不能通过编译, 需改成 float y = 2.1f 
	更改后，根据原则1， 结果的类型为double 
---------原则3的例子---------
	short x = 10;
	short y = 3;
	x / y 的类型？
	根据原则3， x 和 y会被提升为int， 所以结果的类型为 int
---------结果所有原则的例子---------
	short x = 14;
	float y = 13; 
	double z = 30;
	x * y / z 的类型？
	这题需要结果所有原则， 
	1. x被提升为int， 
	2. 2.x继续被提升为float，因为x * y， 
	3. 3. x * y的结果被提升为double， 因为 / z 。
	4. 最后结果的类型为double

先写到这，下次继续更新。。。。。

2. Unary Operators：

又称单元运算， 只有一个运算符号的运算，如下表：

以下给出一些例子，会附上备注给大家参考，在这就不做过多讲解

--------- negation operator -----------
boolean x = false; 
System.out.println(x); // false 
x = !x;
System.out.println(x); // true
int x = !5; // DOES NOT COMPILE, 逻辑反转不可用于数字
boolean y = -true; // DOES NOT COMPILE,  boolean值没有反转
boolean z = !0; // DOES NOT COMPILE, 数字不可逻辑反转，并且boolean 值不可被赋予数字
------------ “++“， “--“ ---------------
int counter = 0; 
System.out.println(counter); // Outputs 0 
System.out.println(++counter); // Outputs 1 
System.out.println(counter); // Outputs 1 
System.out.println(counter--); // Outputs 1 
System.out.println(counter); // Outputs 0

int x = 3;
int y = ++x * 5 / x-- + --x; 
System.out.println("x is " + x);  
System.out.println("y is " + y);
// 分解下： 
	int y = 4 * 5 / x-- + --x; // x assigned value of 4
	int y = 4 * 5 / 4 + --x; // x assigned value of 3
	int y = 4 * 5 / 4 + 2; // x assigned value of 2
	x 是 2
	y 是 7

3. Additional Binary Operators：

1. Assignmeng Operators " = "
   就是把右边的值赋给左边的变量，以下为一些例子，不做过多讲解：

	int x = 1.0; // DOES NOT COMPILE， double值不可以赋给int
	short y = 1921222; // DOES NOT COMPILE，1921222超出了short的范围
	int z = 9f; // DOES NOT COMPILE， floating-point 不可以赋给int
	long t = 192301398193810323; // DOES NOT COMPILE， 最后缺少L
	
	可以通过type cast 改变类型进行赋值：
	int x = (int)1.0;
	short y = (short)1921222; // Stored as 20678
	int z = (int)9L;
	long t = 192301398193810323L;

2. Compound Assignment Operators
   “ += “， “ -= “， “ *= “， “ /= “ 等等 都是的

	int x = 2, z = 3;
	x = x * z; // Simple assignment operator 
	x *= z; // Compound assignment operator
	
	好处：
  	1. 简化代码
  	2. 可以自动进行类型转换， 如下：
	  	long x = 10;
		int y = 5;
		y = y * x; // DOES NOT COMPILE， 因为x需要变成（int）
		如果使用 compound assignment， 则会自动cast，我们无需指明类型
		long x = 10; 
		int y = 5;
		y *= x;
	 4. 

3. Relational Operators
   参照下表，这里就不做解释
   

4. Logical Operators
   参照下表，相信大家都已经掌握了
   

5. Equality Operators
   这里需要记住几点使用情景

   1. 当比较两个数字 primitive 类型的值， 如果类型不等，小的数据类型会被提升为大的数据类型， 例如：
      5 == 5.00 returns true since the left side is promoted to a double.
   2. 可以用来比较两个 boolean 值
   3. 可以用来比较两个 object， 包括 null 和 String

   以下是一些例子帮助大家理解：

	boolean x = true == 3; // DOES NOT COMPILE， 不可以混合类型
	boolean y = false != "Giraffe"; // DOES NOT COMPILE，不可以混合类型
	boolean z = 3 == "Kangaroo"; // DOES NOT COMPILE，不可以混合类型
	boolean y = false;
	boolean x = (y = true); 
	System.out.println(x); // Outputs true
	File x = new File("myFile.txt");
	File y = new File("myFile.txt");
	File z = x;
	System.out.println(x == y); // Outputs false 
	System.out.println(x == z); // Outputs true

4. Java Statements：

主要关于一些逻辑语句的应用，这里就不一一讲解，我会列出知识点，大家根据自己的程度进行学习

1. if 语句
2. if - else 语句
3. switch 语句
   说一下switch 里的目标变量的类型，
   • Java1.5 以前仅支持int或者可以被提升为int的类型, byte, short, char或者int。
   • 1.5 加入enum后，enum类型可以被支持。
   • 1.7 switch支持 String 类型。
4. while 语句
5. do - while 语句
6. for 语句

5. Advanced Flow Control

1. 内嵌循环
2. 标签(label) 的应用

	int[][] myComplexArray = {{5,2,1,3},{3,9,8,9},{5,7,12,7}}; 
	OUTER_LOOP: for(int[] mySimpleArray : myComplexArray) {
		INNER_LOOP: for(int i=0; i<mySimpleArray.length; i++) { 		
			System.out.print(mySimpleArray[i]+"\t");
		}
	System.out.println(); 
	}
	通过标签可以直接跳到指定的位置，在内嵌环境中非常有用

3. break

	public class SearchSample {
		public static void main(String[] args) {
			int[][] list = {{1,13,5},{1,2,5},{2,7,2}}; int searchValue = 2;
			int positionX = -1;
			int positionY = -1;
			PARENT_LOOP: for(int i=0; i<list.length; i++) { 
				for(int j=0; j<list[i].length; j++) {
					if(list[i][j]==searchValue) { 
						positionX = i;
						positionY = j;
						break PARENT_LOOP; // 可以直接break 外面的loop
					} 
				}
			}
			if(positionX==-1 || positionY==-1) {
				System.out.println("Value "+searchValue+" not found"); 
			} else {
				System.out.println("Value "+searchValue+" found at: " + "
				("+positionX+","+positionY+")");
			} 
		}
	}

4. continue

public class SwitchSample {
	public static void main(String[] args) {
		FIRST_CHAR_LOOP: for (int a = 1; a <= 4; a++) { 
			for (char x = 'a'; x <= 'c'; x++) {
				if (a == 2 || x == 'b') 
					continue FIRST_CHAR_LOOP;  // 可以continue 外面的loop
				System.out.print(" " + a + x); 
			}
		} 
	}
}

最后附上总结表：