java 解惑 1

_1.java

package itepub.net._20100805;

/**
 *  奇偶性
 * @author yuahan
 *
 */
public class _1 {
	public static boolean isOdd1(int n){// wrong
		return n % 2 == 1;
	}
	
	public static boolean isOdd2(int n){// right
		return n % 2 != 0;
	}
	
	public static void main(String[] args) {
		System.out.println(isOdd1(-1));
		System.out.println(isOdd2(-1));
	}
}

_11.java

package itepub.net._20100805;

/**
 * 最后的笑声
 * @author yuahan
 *
 */
public class _11 {

	public static void main(String[] args) {
		System.out.println("H" + "A");//HA
		System.out.println('H' + 'A');//137
		/*
		 * 当且仅当有字符串类型时，+是字符串连接，其他的任何操作都会被认为是加法操作
		 * */
	}
}

_12.java

package itepub.net._20100805;

/**
 * char array
 * @author yuahan
 *
 */
public class _12 {
	public static void main(String[] args) {
		char[] array = {'1','2','3'};
		int[] array2 = {1,2,3};
		System.out.println("letters: " + array);

		System.out.println("letters: " + array.toString());

		System.out.println("letters: " + String.valueOf(array));// just for the char array, not for other arrays. 
		
		System.out.println("letters: " + array2);

		System.out.print("letters: ");
		System.out.println(array);//Prints an array of characters and then terminate the line. This method behaves as though it invokes print(char[]) and then println().
		
		System.out.print("letters: ");
		System.out.println(array2);
		
		
		/*
		  	letters: [C@c17164
			letters: [C@c17164
			letters: 123
			letters: [I@1fb8ee3
			letters: 123
			letters: [I@1fb8ee3
		*/
	}
}

_13.java

package itepub.net._20100805;

/**
 * String
 * 	equals()	比较的是内容
 * 	==			比较的是引用
 * 需要注意的是java的String池。
 * 而且当一个String是由"常量的String"形成的，(如String s4 = "Mon" + "day"; s4会引用内存池中的"Monday"(如果存在的话))
 * 该String会引用内存中的String(如果存在的话).
 * @author yuahan
 * 
 */
public class _13 {
	public static void main(String[] args) {
		String s1 = "Monday";
		String s2 = "Monday";
		
		System.out.println(s1 == s2);
		
		
		String s3 = new String("Monday");
		System.out.println(s1 == s3);
		
		
		s3 = s3.intern();//当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。 
		System.out.println(s1 == s3);
		
		
		String s4 = "Mon" + "day";//对于String的常量表达式，java 会判断在内存中生成了Mon 和 day 两个常量之后，合成s4时会检查是否已经存在
		System.out.println(s1 == s4);
		
		String s5 = "Monday6";
		String s6 = s1 + 6;
		System.out.println(s1 == "Monday");
		System.out.println(s5 == ("Monday" + 6));//两个都是常量，故在编译时便能确定，导致引用相同
		
		System.out.println(s5 == s6);//false
		System.out.println(s5 == (s1 + 6));//false
		System.out.println(s5 == ("Monday" + s1.length()));//后者是变量，只有在执行时才能确定,引用不同
		System.out.println(s6 == ("Monday" + s1.length()));
		
		
		
		String animal1 = "animal1";
		String animal2 = "animal" + "1".length();
		System.out.println("equals? " + animal1 == animal2);// result is "false", not "equals? false".
		System.out.println("equals? " + (animal1 == animal2));// result is "equals? false".
		
	}
}

_14.java

package itepub.net._20100805;

/**
 * 转义符
 * @author yuahan
 *
 */
public class _14 {
	public static void main(String[] args) {
		String str = "a\u0022.length()+\u0022b";//\u0022 是引号的Unicode转义符 
		System.out.println(str.length());//2
		System.out.println(("a".length()+"b").length());
	}
}

_2.java

package itepub.net._20100805;

/**
 * 找零时刻
 * @author yuahan
 *
 */
public class _2 {
	public static void main(String[] args) {
		System.out.println(2.00 - 1.10);// 1.10不能被精确的表示成浮点型数值
		System.out.println((200 - 110) / 100D);
	}
}

_22.java

package itepub.net._20100805;

/**
 * URL
 * @author yuahan
 *
 */
public class _22 {
	public static void main(String[] args) {
		System.out.println("");
		http://www.google.com;// goto. it looks like: "http:		//www.google.com"
		System.out.println("");
	}
}

_24.java

package itepub.net._20100805;

/**
 * byte -128 -- 127
 * 对于混合类型来说 要特别的小心
 * @author yuahan
 *
 */
public class _24 {
	public static void main(String[] args) {
		for(byte i = Byte.MIN_VALUE;i<Byte.MAX_VALUE;i++){
			if(i == 0x90){//默认为int类型，故为144。 没有符合条件的时候
				System.out.println(i);
			}
		}
		//没有任何输出
		
		for(byte i = Byte.MIN_VALUE;i<Byte.MAX_VALUE;i++){
			if(i == (byte)0x90){//默认为int类型，故为144。 没有符合条件的时候
				System.out.println(i);
			}
		}
		//-112
	}
}

_25.java

package itepub.net._20100805;

/**
 * 增量操作
 * @author yuahan
 *
 */
public class _25 {
	public static void main(String[] args) {
		int j = 0;
		for (int i = 0; i < 100; i++) {
			j = j++;//0
		}
		System.out.println(j);//0
		
		/*
		 * 相当于
		 * int temp = j;
		 * j= j + 1;
		 * j = temp;
		 */
		
		
		int k = 0;
		for (int i = 0; i < 100; i++) {
			k = ++k;//100
		}
		System.out.println(k);//100
	}
}

_26.java

package itepub.net._20100805;

public class _26 {
	public static void main(String[] args) {
		int i = Integer.MAX_VALUE;
		int j = Integer.MAX_VALUE - 100;
		int count = 0;
		for(;j<i;j++){
			count++;
		}
		System.out.println(count);
	}
}

_3.java

package itepub.net._20100805;

/**
 * 长整除
 * @author yuahan
 *
 */
public class _3 {
	public static void main(String[] args) {
		final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;
		final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;
		System.out.println(MICROS_PER_DAY / MILLIS_PER_DAY);// result=5. 因为是溢出之后然后再转换成的long类型。实际上已经溢出.
		
		
		final long MICROS_PER_DAY_2 = 24L * 60 * 60 * 1000 * 1000;
		final long MILLIS_PER_DAY_2 = 24L * 60 * 60 * 1000;
		System.out.println(MICROS_PER_DAY_2 / MILLIS_PER_DAY_2);// result=1000.
	}
}

_36.java

package itepub.net._20100805;

public class _36 {
	public static boolean decision(){
		try{
			return true;
		} catch(Exception e){
			
		} finally{
			return false;
		}
	}
	
	public static void main(String[] args) {
		System.out.println(decision());
	}
}

_5.java

package itepub.net._20100805;

/**
 * 16进制问题
 * @author yuahan
 *
 */
public class _5 {
	public static void main(String[] args) {
		System.out.println(Long.toHexString(0x100000000L + 0xcafebabe));	//cafebabe
		/*
			 0xffffffffcafebabe
			+0x0000000100000000  
			-------------------  
			 0x00000000cafebabe 
		 */
		
		System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL));	//1cafebabe
		
		/*
			 0x00000000cafebabe
			+0x0000000100000000  
			-------------------  
			 0x00000001cafebabe 
		 */
	}
}

_6.java

package itepub.net._20100805;

public class _6 {
	public static void main(String[] args) {
		System.out.println((int)(char)(byte)-1);//65535
		//	-1						ffffffff
		//	(byte)-1				ff
		//	(char)(byte)-1			ffff
		//	(int)(char)(byte)-1		000000ff	//65535
		System.out.println(Math.pow(2, 16) - 1);//65535.0
		
		/*
		 * 如果最初的数值类型是有符号的，那么久执行符号扩展。
		 * 如果最初的数值类型是char类型，则都执行零扩展，无论转换成何种类型。
		 */
	}
}

_7.java

package itepub.net._20100805;

/**
 * 异或操作
 * @author yuahan
 *
 */
public class _7 {

	public static void main(String[] args) {
		int x = 1984;			//0x7c0
		int y = 2001;			//0x7d1
		x ^= y ^= x ^= y;
		System.out.println(x);	//0
		System.out.println(y);	//1984
		
		// x = x^y^x^y = x^x^y^y = (x^x)^(y^y) = 0^0 = 0
		// y = y^x^y^ = x^(y^y) = x^0 = x
	}
}

_8.java

package itepub.net._20100805;

/**
 * 条件表达式
 * @author yuahan
 *
 */
public class _8 {

	public static void main(String[] args) {
		char x = 'A';
		int y = 0;
		double z = 1D;
		
		System.out.println(true ? x : x);	//A
		
		System.out.println(true ? x : 0);	//A
		System.out.println(true ? x : y);	//65
		
		System.out.println(false ? y : x);	//65
		
		System.out.println(true ? z : y);	//1.0
		/*
		 * 1. 如果第二个和第三个操作数的数据类型相同，那么结果便是此类型
		 * 2. 如果第二个和第三个操作数的数据类型不同，且第三个操作数是一个长度更长的类型的'常量'，那么结果可以第二个操作数的类型
		 * 3. 如果第二个和第三个操作数的数据类型不同，且第二个操作数是一个长度更长的类型，那么结果必须是第二个操作数的类型。
		 */
	}
}

_9_10.java

package itepub.net._20100805;

/**
 * 半斤、八两
 * @author yuahan
 *
 */
public class _9_10 {
	public static void main(String[] args) {
		/*
		 * 1.使得 x += i 成立但是  x = x + i 不成立
		 * 复合赋值表达式是将右边的数据类型强制转换成左边的
		 * 2.使得 x = x + i 成立但是  x += i 不成立
		 * 当使用String操作+符时，其他的数据类型会变成String类型，而对于Object来说，+操作是不合法的
		 * */
		
		short x = 0;
		int i = 1234567;
		x += i;
		System.out.println(x); //-10617
//		x = x + i;//编译有问题
		
		
		Object a = "Buy ";
		String b = "Effective Java!";
		a = a + b;
		System.out.println(a);
//		a += b;//编译有问题
		
	}
}