1，Switch 语句内的表达式必须为： byte  ,char ,short ,int 这四种之一。

2，使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

例如，对于如下语句：
 final StringBuffer a=new StringBuffer("immutable");执行如下语句将报告编译期错误：
a=new StringBuffer("");但是，执行如下语句则可以通过编译：
a.append(" broken!"); 

即：引用不可改变，但是，引用的对象中的值可以改变。

3，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

System.out.println(Math.round(11.5));
System.out.println(Math.round(-11.5));
结果 12，-11

Math类是java.lang中的一个类，它保留了一些常用的数学函数。和System类一样，它里面定义的所有变量和方法都是静态的。

static long round(double arg)  :返回只入不舍的最近的长整型值，即大于等于的整型值。（该方法已被重载）

static double rint(double arg):返回最近接的整数值 （12.0，，-12.0）
4，构造器Constructor是否可被override

不可以 ，每一个类必须有自己的构造函数，负责构造自己这部分的构造。子类不会覆盖父类的构造函数，相反必须负责在一开始调用父类的构造函数
5，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

（1）不同 的接口之间，也可以存在继承关系。和类的继承一样，这种继承关系也是通过extends关键字来实现的。

（2）抽象类可以实现接口，如

interface fruit{
	public void color();
	public void weight();	
}
abstract class apple implements fruit{
	int x,y;
	public void color(){
		System.out.println("red");
	}
	
	public void weight(){
		System.out.println("heavy");
	}
}
public class test20 {
	public static void main(String args[])
	  {
		apple ap=new apple();    //但是这里的实例化抽象类是错误的
	  }
}
（3）抽象类是可以继承具体类的

class apple {
	int x,y;
	public void color(){
		System.out.println("red");
	}
	
	public void weight(){
		System.out.println("heavy");
	}
}
 abstract class bigapple extends apple{
	 abstract public void bigsize();
 }
public class test20 {
	public static void main(String args[])
	  {
		apple ap=new apple();    
	  }
}
（4）抽象类中可以有静态的main方法，如

class apple {
	int x,y;
	public void color(){
		System.out.println("red");
	}
	
	public void weight(){
		System.out.println("heavy");
	}
}
 
abstract public class test20 {
	public static void main(String args[])
	  {
		apple ap=new apple(); 
		ap.color();
	  }
}
结果为：red
6，写clone()方法时，通常都有一行代码，是什么？

super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

clone（）方法的解析见“http://blog.csdn.net/mengxiangyue/article/details/6818611”

7，java中实现多态的机制是什么

java中实现多态的机制靠的是父类或者接口定义的引用变量可以指向子类或者具体的实现类的实例对象，而程序调的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
一句话说就是：父类的引用指向子类的对象（在子类中重写了父类的某些方法）
8，super.getClass()方法调用
从网上搜集了一个比较有用的解释：
import java.util.Date;
public  class Test extends Date
{
      public void test()
      {
              System.out.println(super.getClass().getName());
      }
      public static void main(String[] args) 
      {
              new Test().test();
      }
}
答案是：test

如果在test方法中，直接调用getClass().getName()方法的化，相当于调用this.getClass().getName(),这样返回的就是Test类名
由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，Date类也是没有这个方法的，在test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。
如果想得到父类的名称，应该用如下代码：
getClass().getSuperclass().getName();
Object的getClass()方法的释义是：返回此 Object 的运行时类。
9, String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

String 类是不可变类，因为有关键字immutable.(答案是没有变)

"http://blog.csdn.net/ljb_blog/article/details/6295867"
10，如何把一段逗号分割的字符串转换成一个数组?

public static void main(String[] args) 
      {
              String ss="wo,shi,中,国,人,.";
              String []str=ss.split(",");
              for(String sg:str)
            	  System.out.println(sg);
       }
split(String sign)方法，根据指定的分隔符对字符串进行完全分割。str.split(String sign);参数为：分割字符串的分隔符，也可以使用正则表达式；返回值，根据分隔符分割后的字符串，一个字符串数组。
11，try{}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
 public static int test(){
	  try{
		  int a[]=new int[3];
		  a[0]=4;
		  a[2]=5;		 
		  return -1;
		  
	  }	 
	  finally{		 
		  System.out.println("test over!");
		 // return 2;
	  }

结果： test over!
-1