如果你是应届生，那不能要高人为，好比大饼的故事，没有文凭还想拿高人为，就去中关村落缺什么补什么吧！
少数人根本确实很好，在校期间确实又做过一些项目，那仍旧是可以要到相对高的人为的。
1. Java根本部分
根本部分的顺序：基本语法，类干系的语法，内部类的语法，继续干系的语法，非常的语法，线程的语法，凑集的语法，io的语法，虚拟机方面的语法。
1、一个\"大众.java\公众源文件中是否可以包括多个类（不是内部类）？有什么限定？
可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相同等。
2、Java有没有goto?
java中的保留字，现在没有在java中利用。
3、说说&和&&的差异。
&和&&都可以用作逻辑与的运算符，表示逻辑与（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。
备注：这道题先说两者的共同点，再说出&&和&的分外之处，并列举一些经典的例子来表明自己理解透彻深入、实际履历丰富。 f
4、在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;
}
}
}
5、switch语句能否浸染在byte上，能否浸染在long上，能否浸染在String上?
在switch（expr1）中，expr1只能是一个整数表达式或者列举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，以是，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，以是，它们不能浸染于swtich语句中。
6、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编译器会对它进行分外处理，因此可以精确编译。
7、char型变量中能不能存贮一个中文汉字?为什么?
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，以是，char型变量中当然可以存储汉字啦。不过，如果某个分外的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个分外汉字。补充解释：unicode编码占用两个字节，以是，char类型的变量也是占用两个字节。
备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些干系的知识，做到畅所欲言，言无不尽。
8、用最有效率的方法算出2乘以8等於几?
2 << 3，
由于将一个数左移n位，就相称于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，以是，2乘以8等於几的最效率的方法是2 << 3。
9、请设计一个一百亿的打算器
首先要明白这道题目的稽核点是什么，一是大家首先要对打算机事理的底层细节要清楚、要知道加减法的位运算事理和知道打算机中的算术运算会发生越界的情形，二是要具备一定的面向工具的设计思想。
首先，打算机中用固天命量的几个字节来存储的数值，以是打算机中能够表示的数值是有一定的范围的，为了便于讲解和理解，我们先以byte类型的整数为例，它用1个字节进行存储，表示的最大数值范围为-128到+127。-1在内存中对应的二进制数据为11111111，如果两个-1相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,11111110，由于进位后超过了byte类型的存储空间，以是进位部分被舍弃，即终极的结果为11111110，也便是-2，这恰好利用溢位的办法实现了负数的运算。-128在内存中对应的二进制数据为10000000，如果两个-128相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,00000000，由于进位后超过了byte类型的存储空间，以是进位部分被舍弃，即终极的结果为00000000，也便是0，这样的结果显然不是我们期望的，这解释打算机中的算术运算是会发生越界情形的，两个数值的运算结果不能超过打算机中的该类型的数值范围。由于Java中涉及表达式运算时的类型自动提升，我们无法用byte类型来做演示这种问题和征象的实验，大家可以用下面一个利用整数做实验的例子程序体验一下：
int a = Integer.MAX_VALUE;
int b = Integer.MAX_VALUE;
int sum = a + b;
System.out.println(“a=”+a+”,b=”+b+”,sum=”+sum);
先不考虑long类型，由于int的正数范围为2的31次方，表示的最大数值约即是2100010001000，也便是20亿的大小，以是，要实现一个一百亿的打算器，我们得自己设计一个类可以用于表示很大的整数，并且供应了与其余一个整数进行加减乘除的功能，大概功能如下：
（）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数
（）有一个布局方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中
（）供应加减乘除的功能
public class BigInteger{
int sign;
byte[] val;
public Biginteger(String val) {
sign = ;
val = ;
}
public BigInteger add(BigInteger other) {
}
public BigInteger subtract(BigInteger other) {
}
public BigInteger multiply(BigInteger other){
}
public BigInteger divide(BigInteger other){
}
}
备注：要想写出这个类的完全代码，是非常繁芜的，如果有兴趣的话，可以参看jdk中自带的java.math.BigInteger类的源码。口试的人也知道谁都不可能在短韶光内写出这个类的完全代码的，他要的是你是否有这方面的观点和意识，他最主要的还是稽核你的能力，以是，你不要由于自己无法写出完全的终极结果就放弃答这道题，你要做的便是你比别人写得多，证明你比别人强，你有这方面的思想意识就可以了，毕竟别人可能连题目的意思都看不懂，什么都没写，你要敢于答这道题，纵然只答了一部分，那也与那些什么都不懂的人差异出来，拉开了间隔，算是矮子中的高个，机会当然就属于你了。其余，答案中的框架代码也很主要，表示了一些面向工具设计的功底，特殊是个中的方法命名很专业，用的英文单词很精准，这也是能力、履历、专业性、英语水平等多个方面的表示，会给人留下很好的印象，在编程能力和其他方面条件差不多的情形下，英语好除了可以使你得到更多机会外，薪水可以赶过一千元。
10、利用final关键字润色一个变量时，是引用不能变，还是引用的工具不能变？
利用final关键字润色一个变量时，是指引用变量不能变，引用变量所指向的工具中的内容还是可以改变的。例如，对付如下语句：
final StringBuffer a=new StringBuffer(\公众immutable\"大众);
实行如下语句将报告编译期缺点：
a=new StringBuffer(\"大众\"大众);
但是，实行如下语句则可以通过编译：
a.append(\"大众 broken!\"大众);
有人在定义方法的参数时，可能想采取如下形式来阻挡方法内部修正传进来的参数工具：
public void method(final StringBuffer param){
}
实际上，这是办不到的，在该方法内部仍旧可以增加如下代码来修正参数工具：
param.append(\"大众a\公众);
11、\公众==\"大众和equals方法究竟有什么差异？
（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的差异自然就出来了，混在一起说，则很难说清楚）
==操作符专门用来比较两个变量的值是否相等，也便是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是工具类型的，那么，这时候涉及了两块内存，工具本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = newObject();变量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方法，由你自己写代码来决定在什么情形即可认为两个工具的内容是相同的。
12、静态变量和实例变量的差异？
在语法定义上的差异：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的差异：实例变量属于某个工具的属性，必须创建了实例工具，个中的实例变量才会被分配空间，才能利用这个实例变量。静态变量不属于某个实例工具，而是属于类，以是也称为类变量，只要程序加载了类的字节码，不用创建任何实例工具，静态变量就会被分配空间，静态变量就可以被利用了。总之，实例变量必须创建工具后才可以通过这个工具来利用，静态变量则可以直策应用类名来引用。
例如，对付下面的程序，无论创建多少个实例工具，永久都只分配了一个staticVar变量，并且每创建一个实例工具，这个staticVar就会加1；但是，每创建一个实例工具，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。
public class VariantTest{
public static int staticVar = 0;
public int instanceVar = 0;
public VariantTest(){
staticVar++;
instanceVar++;
System.out.println(“staticVar=” + staticVar + ”,instanceVar=”+ instanceVar);
}
}
备注：这个解答除了说清楚两者的差异外，末了还用一个详细的运用例子来解释两者的差异，表示了自己有很好的讲授问题和设计案例的能力，思维敏捷，超过一样平常程序员，有写作能力！
13、是否可以从一个static方法内部发出对非static方法的调用？
不可以。由于非static方法是要与工具关联在一起的，必须创建一个工具后，才可以在该工具上进行方法调用，而static方法调用时不须要创建工具，可以直接调用。也便是说，当一个static方法被调用时，可能还没有创建任何实例工具，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个工具上的呢？这个逻辑无法成立，以是，一个static方法内部发出对非static方法的调用。
14、Integer与int的差异
int是java供应的8种原始数据类型之一。Java为每个原始类型供应了封装类，Integer是java为int供应的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的差异，int则无法表达出未赋值的情形，例如，要想表达出没有参加考试和考试成绩为0的差异，则只能利用Integer。在JSP开拓中，Integer的默认为null，以是用el表达式在文本框中显示时，值为空缺字符串，而int默认的默认值为0，以是用el表达式在文本框中显示时，结果为0，以是，int不适宜作为web层的表单数据的类型。
在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个工具是否是临时的，如果将OID定义为了int类型，还须要在hbm映射文件中设置其unsaved-value属性为0。
其余，Integer供应了多个与整数干系的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。
15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math类中供应了三个与取整有关的方法：ceil、floor、round，这些方法的浸染与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，Math.ceil(11.6)的结果为11,Math.ceil(-11.6)的结果是-12；最难节制的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，以是，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
16、下面的代码有什么欠妥之处?
1. if(username.equals(“zxx”){}
2. intx = 1;
return x==1?true:false;
17、请说出浸染域public，private，protected，以及不写时的差异
这四个浸染域的可见范围如下表所示。
解释：如果在润色的元素上面没有写任何访问润色符，则表示friendly。
浸染域 当前类同一package子孙类其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很随意马虎画出上面的图了。
18、Overload和Override的差异。Overloaded的方法是否可以改变返回值的类型?
Overload是重载的意思，Override是覆盖的意思，也便是重写。
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完备相同，通过子类创建的实例工具调用这个方法时，将调用子类中的定义方法，这相称于把父类中定义的那个完备相同的方法给覆盖了，这也是面向工具编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的非常，或者是抛出父类抛出的非常的子非常，由于子类可以办理父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限定，相称于子类中增加了一个全新的方法。
至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完备一样，是否可以让它们的返回值不同来实现重载Overload。这是弗成的，我们可以用反证法来解释这个问题，由于我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们常日都不会定义吸收返回结果的变量，这时候假设该类中有两个名称和参数列表完备相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，由于它无法通过返回结果类型来判断。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的浸染。对我们来说最熟习的覆盖便是对接口方法的实现，在接口中一样平常只是对方法进行了声明，而我们在实现时，就须要实现接口声明的所有方法。除了这个范例的用法以外，我们在继续中也可能会在子类覆盖父类中的方法。在覆盖要把稳以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完备匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回同等；
3、覆盖的方法所抛出的非常必须和被覆盖方法的所抛出的非常同等，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟习，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择得当的方法实行。在利用重载要把稳以下的几点：
1、在利用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的非常进行重载；
3、方法的非常类型和数目不会对重载造成影响；
4、对付继续来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
19、布局器Constructor是否可被override?
布局器Constructor不能被继续，因此不能重写Override，但可以被重载Overload。
20、接口是否可继续接口?抽象类是否可实现(implements)接口?抽象类是否可继续详细类(concrete class)?抽象类中是否可以有静态的main方法？
接口可以继续接口。抽象类可以实现(implements)接口，抽象类是否可继续详细类。抽象类中可以有静态的main方法。
备注：只要明白了接口和抽象类的实质和浸染，这些问题都很好回答，你想想，如果你是java措辞的设计者，你是否会供应这样的支持，如果不供应的话，有什么情由吗？如果你没有道理不供应，那答案便是肯定的了。
只有记住抽象类与普通类的唯一差异便是不能创建实例工具和许可有abstract方法。
21、写clone()方法时，常日都有一行代码，是什么？
clone 有缺省行为，super.clone();由于首先要把父类中的成员复制到位，然后才是复制自己的成员。
22、面向工具的特色有哪些方面
打算机软件系统是现实生活中的业务在打算机中的映射，而现实生活中的业务实在便是一个个工具协作的过程。面向工具编程便是按现实业务一样的办法将程序代码按一个个工具进行组织和编写，让打算机系统能够识别和理解用工具办法组织和编写的程序代码，这样就可以把现实生活中的业务工具映射到打算机系统中。
面向工具的编程措辞有，吗等4个紧张的特色。
1封装：
封装是担保软件部件具有优秀的模块性的根本，封装的目标便是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向工具的编程措辞中，工具是封装的最基本单位，面向工具的封装比传统措辞的封装更为清晰、更为有力。面向工具的封装便是把描述一个工具的属性和行为的代码封装在一个“模块”中，也便是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个工具中的属性。常日情形下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现工具的封装，就很随意马虎找出要分配到这个类上的方法了，就基本上算是会面向工具的编程了。把握一个原则：把对同一事物进行操作的方法和干系的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
例如，人要在黑板上画圆，这一共涉及三个工具：人、黑板、圆，画圆的方法要分配给哪个工具呢？由于画圆须要利用到圆心和半径，圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人往后只是调用圆的画圆方法、表示给圆发给而已，画圆这个方法不应该分配在人这个工具上，这便是面向工具的封装性，即将工具封装成一个高度自治和相对封闭的个体，工具状态（属性）由这个工具自己的行为（方法）来读取和改变。一个更便于理解的例子便是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，该当分配给火车，由于司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车须要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个，关照火车要实行刹车动作而已。
抽象：
抽象便是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将把稳力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那便是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下：
classPerson{
String name;
int age;
}
人本来是很繁芜的事物，有很多方面，但由于当前系统只须要理解人的姓名和年事，以是上面定义的类中只包含姓名和年事这两个属性，这便是一种抽像，利用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解便是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要长于划分问题的边界，当前系统须要什么，就只考虑什么。
继续：
在定义和实现一个类的时候，可以在一个已经存在的类的根本之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入多少新的内容，或修正原来的方法使之更适宜分外的须要，这便是继续。继续是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
多态：
多态是指程序中定义的引用变量所指向的详细类型和通过该引用变量发出的方法调用在编程时并不愿定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例工具，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。由于在程序运行时才确定详细的类，这样，不用修正源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的详细方法随之改变，即不修处死式代码就可以改变程序运行时所绑定的详细代码，让程序可以选择多个运行状态，这便是多态性。多态性增强了软件的灵巧性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例工具由daofactory.getDao()在实行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修正源代码，就可以改变userDao指向的详细类实现，从而导致userDao.insertUser()方法调用的详细代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法：
UserDao userDao =daofactory.getDao();
userDao.insertUser(user);
比喻：人用饭，你看到的是左手，还是右手？
23、java中实现多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或详细实现类的实例工具，而程序调用的方法在运行期才动态绑定，便是引用变量所指向的详细实例工具的方法，也便是内存里正在运行的那个工具的方法，而不是引用变量的类型中定义的方法。
24、abstract class和interface有什么差异?
含有abstract润色符的class即为抽象类，abstract类不能创建的实例工具。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在详细(Concrete)子类中实现，以是，不能有抽象布局方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法差异：
1.抽象类可以有布局方法，接口中不能有布局方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但该当也弗成），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继续一个抽象类。
下面接着再说说两者在运用上的差异：
接口更多的是在系统架构设计方法发挥浸染，紧张用于定义模块之间的通信左券。而抽象类在代码实现方面发挥浸染，可以实当代码的重用，例如，模板方法设计模式是抽象类的一个范例运用，假设某个项目的所有Servlet类都要用相同的办法进行权限判断、记录访问日志和处理非常，那么就可以定义一个抽象的基类，让所有的Servlet都继续这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理非常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：
public abstract classBaseServlet extends HttpServlet{
public final void service(HttpServletRequest request,HttpServletResponse response) throws IOExcetion,ServletException {
记录访问日志
进行权限判断
if(具有权限){
try{
doService(request,response);
}
catch(Excetpion e) {
记录非常信息
}
}
}
protected abstract void doService(HttpServletRequest request,HttpServletResponse response) throws IOExcetion,ServletException;
//把稳访问权限定义成protected，显得既专业，又严谨，由于它是专门给子类用的
}
public class MyServlet1 extendsBaseServlet
{
protected voiddoService(HttpServletRequest request, HttpServletResponse response) throwsIOExcetion,ServletException
{
本Servlet只处理的详细业务逻辑代码
}
}
父类方法中间的某段代码不愿定，留给子类干，就用模板方法设计模式。
备注：这道题的思路是先从总体阐明抽象类和接口的基本观点，然后再比较两者的语法细节，末了再说两者的运用差异。比较两者语法细节差异的条理是：先从一个类中的布局方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继续性等6个方面逐一去比较回答，接着从第三者继续的角度的回答，特殊是末了用了一个范例的例子来展现自己深厚的技能功底。
25、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
abstract的method不可以是static的，由于抽象的方法是要被子类实现的，而static与子类扯不上关系！
native方法表示该方法要用其余一种依赖平台的编程措辞实现的，不存在着被子类实现的问题，以是，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统干系的api实现，例如，在windows用c措辞实现的，以是，查看jdk的源代码，可以创造FileOutputStream的open方法的定义如下：
private native void open(Stringname) throws FileNotFoundException;
如果我们要用java调用别人写的c措辞函数，我们是无法直接调用的，我们须要按照java的哀求写一个c措辞的函数，又我们的这个c措辞函数去调用别人的c措辞函数。由于我们的c措辞函数是按java的哀求来写的，我们这个c措辞函数就可以与java对接上，java那边的对接办法便是定义出与我们这个c函数相对应的方法，java中对应的方法不须要写详细的代码，但须要在前面声明native。
关于synchronized与abstract合用的问题，我以为也弗成，由于在我几年的学习和开拓中，从来没见到过这种情形，并且我以为synchronized该当是浸染在一个详细的方法上才故意义。而且，方法上的synchronized同步所利用的同步锁工具是this，而抽象方法上无法确定this是什么。
26、什么是内部类？Static Nested Class和Inner Class的不同。
内部类便是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是工具的特性，只是为了找一个立足之处，以是须要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！
供应内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c措辞的全局变量，而内部类常日是用于创建内部工具用的，以是，把“全局变量”放在内部类中便是毫无意义的事情，既然是毫无意义的事情，就该当被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法表面，也可以定义在外部类的方法体中，如下所示：
public class Outer
{
int out_x = 0;
public void method()
{
Inner1 inner1 = new Inner1();
public class Inner2 //在方法体内部定义的内部类
{
public method()
{
out_x = 3;
}
}
Inner2 inner2 = new Inner2();
}
public class Inner1 //在方法体表面定义的内部类
{
}
}
在方法体表面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就彷佛类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对付这种情形，我们也可以在表面创建内部类的实例工具，创建内部类的实例工具时，一定要先创建外部类的实例工具，然后用这个外部类的实例工具去创建内部类的实例工具，代码如下：
Outer outer = new Outer();
Outer.Inner1 inner1 = outer.newInnner1();
在方法内部定义的内部类前面不能有访问类型润色符，就彷佛方法中定义的局部变量一样，但这种内部类的前面可以利用final或abstract润色符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例工具可以通报给其他类访问。这种内部类必须是先定义，后利用，即内部类的定义代码必须涌如今利用该类之前，这与方法中的局部变量必须先定义后利用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final润色符。
对付这些细节，只要在eclipse写代码试试，根据开拓工具提示的各种缺点信息就可以立时理解到。
在方法体内部还可以采取如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例工具，无需为该子类定义名称：
public class Outer
{
public void start()
{
new Thread(
new Runable(){
public void run(){};
}
).start();
}
}
末了，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么差异，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在表面引用Static Nested Class类的名称为“外部类名.内部类名”。在表面不须要创建外部类的实例工具，就可以直接创建Static Nested Class，例如，假设Inner是定义在Outer类中的Static Nested Class，那么可以利用如下语句创建Inner类：
Outer.Inner inner = newOuter.Inner();
由于static Nested Class不依赖于外部类的实例工具，以是，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直策应用Static Nested Class的名字，而不须要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不须要加上外部类的名字。
在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的运用办法很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final润色符。
备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义办法的语法差异，静态内部类，以及匿名内部类。
27、内部类可以引用它的包含类的成员吗？有没有什么限定？
完备可以。如果不是静态内部类，那没有什么限定！
如果你把静态嵌套类当作内部类的一种特例，那在这种情形下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：
class Outer
{
static int x;
static class Inner
{
void test()
{
syso(x);
}
}
}
答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说分外情形，让人家吃惊。
28、Anonymous Inner Class (匿名内部类)是否可以extends(继续)其它类，是否可以implements(实现)interface(接口)?
可以继续其他类或实现其他接口。不仅是可以，而是必须!
29、super.getClass()方法调用
下面程序的输出结果是多少？
importjava.util.Date;
publicclassTestextends Date{
public static voidmain(String[] args) {
new Test().test();
}
public void test(){
System.out.println(super.getClass().getName());
}
}
很奇怪，结果是Test
这属于脑筋急转弯的题目，在一个qq群有个网友恰好问过这个问题，我以为挺有趣，就研究了一下，没想到本日还被你面到了，哈哈。
在test方法中，直接调用getClass().getName()方法，返回的是Test类名
由于getClass()在Object类中定义成了final，子类不能覆盖该方法，以是，在
test方法中调用getClass().getName()方法，实在便是在调用从父类继续的getClass()方法，等效于调用super.getClass().getName()方法，以是，super.getClass().getName()方法返回的也该当是Test。
如果想得到父类的名称，该当用如下代码：
getClass().getSuperClass().getName();
30、String是最基本的数据类型吗?
基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继续这个类、不能修正这个类。为了提高效率节省空间，我们该当用StringBuffer类
