1、java是解释型语言，还是编译型语言？说说你知道的其他的编译型语言和解释型语言
java源程序，先有javac（java编译器）编译成与平台无关的字节码，这些字节码不面向任何具体平台，它只面向JVM。不同平台上的JVM都是不同的，但他们都提供了相同的接口。然后在由JVM中的（java）java解释器解释执行。所以，java在严格意义上来说，既不是编译型语言，也不是解释型语言。
C、C++、FORTRAN、Pascal等高级语言都是编译型语言。
Ruby、Python都是解释型语言。
2、CLASSPATH的作用？
设置CLASSPATH往往是这样设置的：
.;JAVA_HOME%\lib\dt.jar;%JAVA_HOME\lib\tools.jar
. 代表JRE需要在当前路径下搜索java类。并且需要加载dt.jat和tools.jar文件中的java类。
其实，这上面的是针对jdk1.4之前的，实际上，如果使用jdk1.5以上的版本，完全可以不设置CLASSPATH环境变量。在jdk1.4之后，Sun改进了JDK的设计，JRE会自动搜索当前路径下的类文件，而且使用java的编译和运行工具时，系统可以自动加载dt.jar和tools.jar文件中的java类，银次不再需要设计CLASSPATH环境变量。
3、java中有几种注释？
单行注释、多行注释和文档注释。
文档注释可以使用jdk自带的工具javadoc，也可以使用IDE工具，比如MyEclipse来生成。
使用MyEclipse很简单，右键单击包或者类，选择Export，在选择java，在选择Javadoc导出即可。
4、下面的代码有没有错
Sysotem.out.println(1.2/0);
答案：没错。因为如果是一个整形除以0，会报 java.lang.ArithmeticException的异常，但是浮点数除以0 结果是无穷大，不会有异常。
浮点数中提供了三种特殊的浮点数正无穷大、负无穷大和非数，用于表示溢出和出错。正无穷大通过Double或FLoat的POSITIVE_INFINITY表示；正无穷大通过Double或FLoat的NEGATIVE_INFINITY表示；正无穷大通过Double或FLoat的NaN表示；
必须指出的是：所有正无穷大数值都是相等的。所有负无穷大数值都是相等的。而NaN不与任何数值相等，甚至和NaN都不相等。
注意：只有浮点数除以0才可以得到正无穷大或负无穷大，因为java语言会自动把和浮点数运算的0（整数）当成0.0（浮点数）处理。如果一个整数值除以0，就会抛异常。
5、strictfp有什么作用
一般在main函数的修饰符，那么在main函数中，浮点运算就要进行严格的浮点运算。
6、表达式类型的自动提升.
当一个算术表达式中包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升。java定义如下的自动提升规则：
1、所有byte型、short型和char型将被提升到int型、
2、整个算术表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型。
举例说明：
public static void main(String[] args) {
short a=1;
a=a+1;//错误，short自动提升到了int，在赋值给a的时候，应该进行强转
}
7、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
8、System.out.println(2.0-1.1);
结果是0.899999999999
正如十进制无法正确的表示1/3的小数值，计算机采用的二进制无法正确的表示1/10
9、下面的方法能判断一个输是否是奇数吗？
public static boolean isOdd(int i){
return i%2==1;
}
答案是不能。当i是正数的时候，当然没有问题，当i是负奇数的时候，i%2是等于-1的，所以返回false，可是它确实是一个奇数。
要修正这个代码很简单
public static boolean isOdd(int i){
return i%2!=0
}
当然最好的做法是
public static boolean isOdd(int i){
return (i&1)!=0;
}
10、写一个程序，计算一天的微秒除以毫秒的结果
一天的微秒数24*60*60*1000*1000
一天的毫秒数24*60*60*1000
也许你会猜到，这是要判断整形数值溢出的问题。你就会如下写出程序
final static long a=24*60*60*1000*1000;
final static long b=24*60*60*1000;
你会很得意的写出两个长整型，并且开始计算。
可是结果。。。
结果你却发现等于a/b等于5了。
这是为什么，a和b明明都是长整型，为什么计算还会溢出的。
这是因为在计算24*60*60*1000*1000的时候，一直采用的是用int型咋计算，计算完后，才将几段结果保存到long常量a中，可是在计算的时候他已经溢出了，在放到long常量a中已经迟了。
我们应该怎么做呢？应该
final static long a=24L*60*60*1000*1000;
final static long b=24L*60 *60*1000
这样，他在计算的时候就一直采用的是long类型进行计算。
11、下面程序的输出结果
public static void main(String[] args)
{
char a='a';
int b=0;
System.out.println(true?a:0);
System.out.println(true?a:b);
}
结果不是你想象的
a
a
而是
a
97
至于原因，有点复杂，对与条件表达式：
1、如果如果第二个和第三个操作数具有相同的类型，那么它就是条件表达式的类型
2、如果一个操作数的类型是T，T表示byte，short，char，而另一个操作数是一个int类型的常量表达式，并且也它的值可以用T表示，那么条件表达式的类型就是T
3、否则，将对操作数类型运用二进制提升，而条件表达式的类型就是提升后的类型。
基于以上的规则，
System.ut.println(true?oa:0);符合了第二条
System.out.println(true?a:b);符合了第三条
所以才会有这样的结果，可想而知
System.out.println(true?a:5000);
System.out.println(true?a:1000000);
的结果应该是
a
97
因为1000000超出了T（byte，short，char）的范围了。
12、Java有没有goto?
java中的保留字，现在没有在java中使用。
13、说说&和&&的区别。
&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。If(x==33 & ++y>0) y会增长，If(x==33 && ++y>0)不会增长
&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。
备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。
14、在JAVA中如何跳出当前的多重嵌套循环？
在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如，
ok:
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println("i=" + i + ",j=" + j);
if (j == 5)
break ok;
}
}
另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
int arr[][] = { { 1, 2, 3 }, { 4, 5, 6, 7 }, { 9 } };
boolean found = false;
for (int i = 0; i < arr.length && !found; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println("i=" + i + ",j=" + j);
if (arr[i][j] == 5) {
found = true;
break;
}
}
}
15、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。
坑爹的是，在JS中，switcj里面是可以放String的，因为JS是个若类型的语言-_-
16、char型变量中能不能存贮一个中文汉字?为什么?
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些相关的知识，做到知无不言，言无不尽。
17、用最有效率的方法算出2乘以8等於几?
2 << 3，
因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。
18、请设计一个一百亿的计算器
首先要明白这道题目的考查点是什么，一是大家首先要对计算机原理的底层细节要清楚、要知道加减法的位运算原理和知道计算机中的算术运算会发生越界的情况，二是要具备一定的面向对象的设计思想。
首先，。。。。。
19、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：
final StringBuffer a=new StringBuffer("immutable");
执行如下语句将报告编译期错误：
a=new StringBuffer("");
但是，执行如下语句则可以通过编译：
a.append(" broken!");
有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：
public void method(final StringBuffer param){
}
实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
param.append("a");
20、"=="和equals方法究竟有什么区别？
（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
21、说出你知道的关系运算符
== 是否相等
< 小于
> 大于
<= 小于等于
>= 大于等于
!= 不等于
instanceof 判断类型
记住，还有个instanceof。
instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：
String s = "I AM an Object!";
boolean isObject = s instanceof Object;
我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
22、Java跳出循环的几种方式
java中断循环的方式有五种，分别是break，continue，break + 标号，continue + 标号，千万要记住还有一个return
23、switch语句可以是哪几种类型
byte,short,char,int ,记住了还有一个enum枚举类型，这是JDK1.5 的新特性
24、下面的代码有没有错误
int a=50;
if(a>10)
{
a+=10;
}
else if(a> 20)
{
a+=20;
}
else if(a>40)
{
a+=40;
}
答案：这段代码虽然编译没有错误，但是逻辑上错的一塌糊涂，else if是包含隐式条件的，即他上面的if条件不成立。
那么第一个else if条件就是a<=10&&a>20，有这样的数吗。
25.下面的代码有没有错误
int a=50;
if(a<10)
{
a+=10;
}
else if(a< 20)；
{
a+=20;
}
else if(a<40)
{
a+=40;
}
有错误，第一个else 分i后面有一个分号-_-
26、for循环的时候为什么不能使用float类型和double型
因为float的精度问题，可能会造成死循环或者不循环的情况，举两个例子：
final int start=999999999;
for(float i=start;i<start+50;i++)
{
System.out.println("asd");
}
这就是个死循环
final int start=999999999;
for(float i=start;i<start+20;i++)
{
System.out.println("asd");
}
这个直接不循环了
27、下面程序的输出结果
System.out.println(2+2+":这是2+2的答案");
结果是 4：这是2+2的答案
那么在下面的呢？
System.out.println("2+2="+2+2);
2+2=22；
至于为什么，自己想吧？
28、下面的代码会不会报错
public static void main(String[] args)
{
http://www.baidu.com;
System.out.println("http://www.baidu.com");
}
这段代码有没有错误呢？
答案是没有
第一行的http://www.baidu.com;会被拆分两个东西
http： 这是一个标签
//www.baidu.com ; 这是一行注释
所有一点问题都没有
29，下面代码的输出结果
final String pig="length: 10";
final String dog="length: "+pig.length();
System.out.println("他们是相等的吗？"+pig==dog);
好吧，也许你发现了这里的陷阱，虽然两个字符串的值都是"length: 10"，但是由于dog的字符串采用了方法调用，所实际上在内存地址上不是相当的，
那么pig==dog当然是false
那么程序的输出结果就是:
"他们是相等的吗？"false
真的是这样的吗？
正确的结果应该是：
false
对，只有一个flase。
解释："他们是相等的吗？"+pig==dog，这个字符串在输出的时候实际上这样的：
（"他们是相等的吗？"+pig）==dog
明白了吗，这当然只有一个false。
30、下面程序的输出结果
System.out.println("a\u0022.length()+\u0022b".length());
答案是多少，你很快的数了下字符串的实际长度，得出结果26，是这样的吗。
不是，结果是2
这里面的\u0022其实是一个转义字符，他代表实际的冒号 "
也就是说上面的字符串等价于：
"a".length()+"b".length()
所以答案是2
31、下面程序的输出结果
public static void main(String[] args)
{
/**
* 文件位于c:\com\use\code
*/
System.out.println("com/use/code");
}
答案是这个程序根本不能通过编译
错误在注释的地方，因为\u代表转义字符的开始，而后面却不是一个正确的转义字符，所以出现错误。
所以，即使在注释中也要注意转义字符的问题。
32、下面的程序的输出结果
public static void main(String[] args)
{
byte bytes[]=new byte[256];
for(int i=0;i<256;i++)
bytes[i]=(byte)i;
String str=new String(bytes);
for(int i=0,n=str.length();i<n;i++)
System.out.println((int)str.charAt(i));
}
也许你以为输出结果是从0到255的数字序列。
其实完全不是，他的结果是不确定的，在不同的系统上可能有不同的结果。
解释，每当你将一个byte序列转换为String的时候，你都在使用一个字符集来确定如何进行转换。如果，你想确定这中转换关系，必须显示的指定。上面的转换应该这样写才正确
String str=new String(bytes,"ISO-8859-1");
没错，Java Api提供了这样的String的构造器，允许你这样做。实际上，也只有指定为ISO-8859-1的时候，才是0到255的字符序列。