一些Java面试题

 1.考察String类型的字符串是不可变的

	public static class StringTest{
		String str = new String("old");
		char[] ch = {'a','b','c'};
		public static void main(String[] args) {
			StringTest st = new StringTest();
			st.change(st.str,st.ch);
			System.out.print(st.str+"and");
			System.out.print(st.ch);
		}
		public void change(String str,char ch[]) {
			str = "new";
			ch[0]='n';
		}
	}//结果为 oldandnbc

解析：str的类型是String，String的值是不能修改的，所谓的修改只会新创建新的String，而ex.str依然指向原来的String地址，所以它的值没有改变。数组传递的是引用,即指向地址空间的变量,所以用这个变量来修改值时也就修改了内存地址空间里的值,因为这个地址里的数据是所有指向该地址的变量所共有的,所以在调用函数时,数组的值会发生改变。

2.考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。

class TestA {
	    public TestA() {
	        System.out.println("HelloA");
	    }
	    { System.out.println("I'm A class"); }
	    static { System.out.println("static A"); }
	}
	public class TestB extends TestA {
	    public TestB() {
	        System.out.println("HelloB");
	    }
	    { System.out.println("I'm B class"); }	    
	    static { System.out.println("static B"); }	    
	    public static void main(String[] args) {
			new TestB();
		}
	}
	/*结果为
     static A
     static B
     I'm A class
     HelloA
     I'm B class
     HelloB
	 */

 解析：对象的初始化顺序：（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；（2）当static语句执行完之后,再执行main方法；（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

3. getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（IOException！）       （考察多个catch语句块的执行顺序。）

 public void getCustomerInfo() {
        try {
            // do something that may cause an Exception
        } catch (java.io.FileNotFoundException ex) {
            System.out.print("FileNotFoundException!");
        } catch (java.io.IOException ex) {
            System.out.print("IOException!");
        } catch (java.lang.Exception ex) {
            System.out.print("Exception!");
        }
    }

 解析：当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个。

4.下面方法输入2时返回值是多少（6）    （考察switch case 语句）

public static int getValue(int i) {
	int result = 0;
	switch (i) {
	case 1:
		result =result+i;
	case 2:
		result = result+ i*1;
	case 3:
		result = result + i*2;
	}
	return result;
}
public static void main(String[] args) {
	Test01 t = new Test01();
	int a=t.getValue(2);
	System.out.println(a);
}//结果为 6

 解析：当case后没有break时就继续执行下一个case语句；有default就会执行default

5.选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（A）

public abstract class MyClass {

     public int constInt = 5;
     //add code here
     public void method() {
     }
}
//A public abstract void method(int a);

//B constInt = constInt + 5;

//C public int method();

//D public abstract void anotherMethod() {}

 解析：考察抽象类抽象方法 （1）A选项正确 （2）B选项由于抽象类中初始化变量后变量值不可以更改所以错误 （3）C选项不可以定义相同方法名不同返回值类型的方法（可以定义相同方法名不同参数的方法）（4）D选项抽象方法不能有方法体

另：抽象类和接口的区别：

（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。

（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。

（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。

（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"has-a"关系。

（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。

（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。

6. ArrayList list = new ArrayList(20);中的list扩充几次？答案是0次

解析：如果是ArrayList list = new ArrayList();不给定初始容量时默认长度为10，使用移位方式扩容每次增加为之前的1.5倍。

ArrayList list = new ArrayList(20);直接给定初始容量的不需要扩容。

7.Java接口的修饰符可以（A B D） 
A private B protected C final D abstract 

解析：private可以修饰（在内部类中）但是一般不使用   protected修饰后只能在本包内调用   接口默认是abstract的