java 一些奇怪的笔试题

例1：

package com.test;

public class Test1 {
	
	public void testExit() {
		try {
			System.exit(0);
		} finally {
			System.out.println("testExit");
		}
	}
	
	public void testReturn() {
		try {
			return;
		} finally {
			System.out.println("testReturn");
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Test1 t = new Test1();
		t.testReturn();
		t.testExit();
	}

}

会打印出什么？

答案：testReturn

例2：

package com.test;

public class Test2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		short s = 1;
//		s = s + 1;
		s++;
		s += 1;
	}

}

注释掉的那行编译时会报错。

byte也一样。

long和int不会报错。

例3：

package com.test;

public class Test3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		float f = 1.0f;
		double d = 1.0d;
//		float f2 = 1.0d;
		double d2 = 1.0f;
		float f3 = 1f;
		double d3 = 1d;
		float f4 = 1;
		double d4 = 1;
	}

}

注释掉的那行不能编译通过。

例4：

package com.test;

public class Test4 {
	int m;
	
	public void test1() {
		int n;
	}
	
	public void test2() {
		int n;
		
//		if (n == 1) {
//			
//		}
	}
	
	public void test3() {
		if (m == 0) {
			
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
	}

}

对于局部变量，如果没被用到，可以不初始化，否则一定要初始化。注释掉的代码，编译会报错。

对于成员变量，自动会初始化。

例4：

package com.test;

public class Test5 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Inner i1 = new Inner();
//		Inner2 i2 = new Inner2();
		Inner3 i3 = new Inner3();
//		Inner4 i4 = new Inner4();
//		Inner5 i5 = new Inner5();
//		Inner6 i6 = new Inner6();
		Test5 t5 = new Test5();
		Inner2 i2 = t5.new Inner2();
	}
	
	static class Inner {
		
	}
	
	class Inner2 {
		
	}
	
	private static class Inner3 {
		
	}
	
	private class Inner4 {
		
	}
	
	public class Inner5 {
		
	}
	
	protected class Inner6 {
		
	}

}

关于内部类，两种使用方法：

1、加static。

2 、先new一个外部类，再用外部类的实例来new内部类。

例6：

package com.test;

import java.util.ArrayList;
import java.util.List;

public class Test6 {

	public void testInt(int n) {
		n++;
	}

	public void testIntger(Integer n) {
		int m = n;
		m++;
		n = new Integer(m);
	}
	
	public void testList(List<Integer> list) {
		int n = list.get(0);
		n++;
		list = new ArrayList<Integer>();
		list.add(n);
	}
	
	public void testIntger2(Integer n) {
		n++;
	}
	
	public void testList2(List<Integer> list) {
		int n = list.get(0);
		n++;
		list.set(0, n);
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Test6 t = new Test6();
		int n = 1;
		t.testInt(n);
		System.out.println(n);
		
		t.testInt(Integer.valueOf(n));
		Integer m = new Integer(1);
		t.testIntger(m);
		System.out.println(m);
		
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		t.testList(list);
		System.out.println(list.get(0));
		
		t.testIntger2(m);
		System.out.println(m);
		
		t.testList2(list);
		System.out.println(list.get(0));
	}

}

只有方法testList2才会输出2。

testInt里，基本类型改变大小后，只会影响方法内部，方法返回后还是没变。

testIntger里，n = new Integer(m);后，n指向了新的地址，原来地址的值是没变的。

testList里，也是一样，list指向了新的地址。

testIntger2里，n++的分解动作，应该是

int m = n.intValue();
m++;

它有个从Integer到int的拆包过程。

只有testList2才改变了值。