Java面试题集（一）

作为一名java开发软件工程，一定要记住，基础非常重要，往往就是一些基础，很简单，但是你就是不知道实现原理，为什么使用，有没有自己去发现，对比，差异从而总结，有些东西看似简单，但是不一定你描述清楚，直观，简洁，故要要坚持在每天闲暇之余学习其中几道题目，日积月累，等到出去面试时，一切都水到渠成，面试时就自然会游刃有余了。

答题时，先答是什么，再答有什么作用和要注意什么（这部分最重要，展现自己的心得）

答案的段落分别，层次分明，条理清晰都非常重要，从这些表面的东西也可以看出一个人的习惯、办事风格、条理等。

要讲你做出答案的思路过程，或者说你记住答案的思想都写下来。把答题想着是辩论赛。答题就是给别人讲道理、摆事实。答题不局限于什么格式和形式，就是要将自己的学识展现出来。

 别因为人家题目本来就模棱两可，你就心里胆怯和没底气了，不敢回答了。你要大胆地指出对方题目很模糊和你的观点，不要把面试官想得有多高，其实他和你就是差不多的，你想想，如果他把你招进去了，你们以后就是同事了，可不是差不多的吗？

 以下部分都是自己精心总结，非常有用，即使你已经工作一段时间，千万记住不要小看基础，感觉简单而忽略，往往细节决定成败，个人深有体会，因为简单感觉面试官不会问到，就是因为这样的想法而错过了一个很好的面试机会。


一. 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异常。而&如果第一个表示式为false，还要计算第二个表达式如If(x==33 & ++y>0) y会增长，If(x==33 && ++y>0)不会增长

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如0x31 & 0x0f的结果为0x01。

备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富.

4、在JAVA中如何跳出当前的多重嵌套循环？ 

让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如要在二维数组中查找到某个数字。

[java] view plain copy
 
  1. int arr[][] = {{1,2,3},{4,5,6,7},{9}};  
  2.   
  3. boolean found = false;//作为跳出多重循环标记  
  4.   
  5. for(int i=0;i<arr.length && !found;i++){  
  6.   
  7. for(int j=0;j<arr[i].length;j++){  
  8.   
  9.    System.out.println(“i=” + i + “,j=” + j);  
  10.   
  11.    if(arr[i][j]  == 5) {  
  12.      
  13.      found = true;  
  14.   
  15.      break;  
  16.   
  17.   }  
  18.   
  19.  }  
  20.   
  21. }   

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类型的变量也是占用两个字节。

备注：是否能存储一个中文汉字，则要看该中文汉字是以什么编码，unicode编码占2个字节，utf-8编码中文占3个字节，gbk编码中文占2个字节，英文占一个字节，char占2个字节。

8、用最有效率的方法算出2乘以8等于几? 

2 << 3

因为将一个数左移n位，就相当于乘以了2的n次方，那么一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以2乘以8等于几的最效率的方法是2 << 3。

备注：左移是2的n次方，乘法，而右移是2的-n次方，除法

9、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？ 

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

 final StringBuffer a=new StringBuffer("immutable");
执行如下语句将报告编译期错误：

a=new StringBuffer("");
但是执行如下语句则可以通过编译：

a.append(" broken!"); 

10、"=="和equals方法究竟有什么区别？

==操作符专门用来比较两个变量的值是否相等，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

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方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

11、静态变量和实例变量的区别？

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar 变量，并且每创建一个实例对象，这个staticVar就会加1；但是每创建一个实例对象，就会分配一个instanceVar，即可能分配多个 instanceVar，并且每个instanceVar的值都只自加了1次。

[java] view plain copy
 
  1. public class VariantTest{  
  2.   
  3.     public static int staticVar = 0; //静态变量只会创建一次，值每执行一次加一次  
  4.   
  5.     public int instanceVar = 0; //实例变量每调用一次，创建一次，值每执行一次只加一次  
  6.   
  7.     public VariantTest(){  
  8.   
  9.          staticVar++;  
  10.   
  11.          instanceVar++;  
  12.   
  13.        System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);  
  14.   
  15.    }  
  16.   
  17. }  

备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！

12、是否可以从一个static方法内部发出对非static方法的调用？ 

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，通过类名直接调用。也就是说当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以一个static方法内部不可以发出对非static方法的调用。

13、Integer与int的区别

Int是基本数据类型，而Integer是int的包装类型

Int的默认值为0，而Inter的默认值为null。故Integer可以区分出未赋值和值为0的区别

在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以int不适合作为web层的表单数据的类型。

在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。

14、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.round(x+0.5)，即将原来的数字加上0.5后再向下取整，所以Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

15、请说出作用域public，private，protected，以及不写时（defalut）的区别？

 作用域      当前类   同包     子类    其他

 public            √         √             √        √

 protected     √         √            √        ×

 default        √         √             ×       ×

 private        √         ×           ×       ×

类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。

备注：记住作用域的从大到小public,protected,defalut,priavate,就可以逐渐推出范围

16、Overload（重载）和Override（重写）的区别？Overloaded（重载）的方法是否可以改变返回值的类型? 

Overload是重载的意思，Override是覆盖的意思，也就是重写。

重载Overload发生在一个类中，方法名相同，参数列表不同。

重写Override发生在子类与父类之间，方法名和参数列表完全相同。子 类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法 的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么 呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的 参数列表完全一样，是否可以让它们的返回值不同来实现重载Overload。这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时 也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们通常都 不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断， 因为是根据参数列表不同区别出java编程者调用了哪个方法。

    override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，JVM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

17、构造器Constructor是否可被override? 

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

18、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承具体类。抽象类中可以有静态的main方法。

19、写clone()方法时，通常都有一行代码，是什么？ 

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

20、面向对象的特征有哪些方面

面向对象的编程语言有，吗等4个主要的特征。

1.抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

2.继承： 继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统 有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部 分）。

3.封装： 通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我 们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的 编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个 按键就搞定了所有的事情）。

4.多态性： 多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和 运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方 式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统 只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载（overload）实现的是编译时的多 态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做 两件事：1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2.对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

21、java中实现多态的机制是什么？ 

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

22、abstract class和interface有什么区别? 

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体子类中实现，所以不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法.

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7. 一个类可以实现多个接口用逗号分隔，但只能继承一个抽象类。

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在 代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权 限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限 判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：

[java] view plain copy
 
  1. //定义抽象基类让子类继承该方法  
  2.   
  3. public abstract class BaseServlet extends HttpServlet{  
  4.   
  5.     public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{//final修饰的方法表示该方法不可被继承  
  6.   
  7.        记录访问日志  
  8.   
  9.       进行权限判断  
  10.   
  11.       if(具有权限){  
  12.   
  13.           try{  
  14.   
  15.              doService(request,response);  
  16.   
  17.           }catch(Excetpion e){  
  18.   
  19.              记录异常信息  
  20.   
  21.          }  
  22.    
  23.     }  
  24.   
  25. }  
  26.   
  27. //注意访问权限定义成protected，显得既专业又严谨，因为它是专门给子类用的  
  28.   
  29. protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{  
  30.   
  31.        //进行一些业务逻辑处理  
  32.   
  33.     }  
  34.   
  35. }  
  36.   
  37. public class MyServlet1 extends BaseServlet{  
  38.   
  39. protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{  
  40.   
  41.       //本Servlet只处理的具体业务逻辑代码  
  42.   
  43.    }  
  44.   
  45. }  

父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。

   备注：这道 题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造 方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等6个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的 例子来展现自己深厚的技术功底。

23、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 

abstract的method 不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！

native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现 的问题，所以，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的 api实现，例如，在windows用c语言实现的，所以，查看jdk 的源代码，可以发现FileOutputStream的open方法的定义如下：

private native void open(String name) throws FileNotFoundException;

关于synchronized与abstract合用的问题，我觉得也不行，因为在我几 年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的 synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。

24、什么是内部类？Static Nested Class 和 Inner Class的不同。

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员,内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：

[java] view plain copy
 
  1. public class Outer{  
  2.   
  3.     int out_x  = 0;  
  4.   
  5.     public void method(){  
  6.   
  7.     Inner1 inner1 = new Inner1();  
  8.   
  9.     public class Inner2 {//在方法体内部定义的内部类  
  10.   
  11.     public method(){  
  12.   
  13.         out_x = 3;  
  14.   
  15.    }  
  16.   
  17. }  
  18.   
  19. Inner2 inner2 = new Inner2();  
  20.   
  21. }  
  22.   
  23. public class Inner1 { //在方法体外面定义的内部类  
  24.   
  25. }  
  26.   
  27. }  

在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：

Outer outer = new Outer();

Outer.Inner1 inner1 = outer.new Innner1();

在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是该局部变量前必须加final修饰符。

在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：

[java] view plain copy
 
  1. public class Outer{  
  2.   
  3.     public void start(){  
  4.   
  5.        new Thread(  
  6.   
  7.          new Runable(){  
  8.   
  9.            public void run(){};  
  10.   
  11.           }  
  12.   
  13.           ).start();  
  14.   
  15.       }  
  16.   
  17. }  

最后，在方法外部定义的内部类前面可以加上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 = new Outer.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修饰符。

备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。

25、内部类可以引用它的包含类的成员吗？有没有什么限制？ 

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：

[java] view plain copy
 
  1. class Outer{  
  2.   
  3.    static int x;//外部类的静态成员  
  4.   
  5.    static class Inner{//静态内部类  
  6.   
  7.    void test(){  
  8.   
  9.       syso(x);  
  10.   
  11.   }  
  12.   
  13.  }  
  14.   
  15. }  

答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员。

26、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)? 

可以继承其他类或实现其他接口。不仅是可以，而是必须!

27、super.getClass()方法调用？

下面程序的输出结果是多少？

[java] view plain copy
 
  1. import java.util.Date;  
  2.   
  3. public  class Test extends Date{  
  4.   
  5.     public static void main(String[] args) {  
  6.   
  7.        new Test().test();  
  8.   
  9.    }  
  10.   
  11.    public void test(){  
  12.   
  13.      System.out.println(super.getClass().getName());  
  14.   
  15.   }  
  16.   
  17. }  

------------执行结果--------------------

Test

在test方法中，直接调用getClass().getName()方法，返回的是Test类名

由于getClass()在Object类中定义成了final，子类不能覆盖该方法， 所以，在test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用 super.getClass().getName()方法，所以super.getClass().getName()方法返回的也应该是Test。

如果想得到父类的名称，应该用如下代码：

getClass().getSuperClass().getName();

28、String是最基本的数据类型吗? 

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

29、String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

没有。因为String被设计成不可变类，所以它的所有对象都是不可变对象。在这段代码 中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，这时s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者 说不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时应该考虑使用StringBuffer类，它 允许修改，而不是每个不同的字符串都要生成一个新的对象。并且这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：

[java] view plain copy
 
  1. public class Demo{  
  2.     private String s;  
  3.     ...  
  4.     public Demo {  
  5.         s = "Initial Value";  
  6.     }  
  7.     ...  
  8. }  

而非

[java] view plain copy
 
  1. s = new String("Initial Value");  

后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。

30、是否可以继承String类? 

String类是final类故不可以继承。

31、String s = new String("xyz");创建了几个字符串对象? 二者之间有什么区别？

两个对象，一个是静态存储区的"xyz",一个是用new创建在堆上的对象。

32、String 和StringBuffer的区别

String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的 字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可 以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。

接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。

[java] view plain copy
 
  1. StringBuffer sbf = new StringBuffer();    
  2.   
  3. for(int i=0;i<100;i++)  
  4.   
  5. {  
  6.   
  7. sbf.append(i);  
  8.   
  9. }  

上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。

[java] view plain copy
 
  1. String str = new String();    
  2.   
  3. for(int i=0;i<100;i++)  
  4.   
  5. {  
  6.   
  7.    str = str + i;  
  8.   
  9. }  

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法。

33、如何把一段逗号分割的字符串转换成一个数组?

1. 用正则表达式，代码大概为：String [] result = orgStr.split(“,”);

2. 用 StingTokenizer ,代码为：StringTokenizer  tokener = StringTokenizer(orgStr,”,”);

String [] result = new String[tokener .countTokens()];

Int i=0;

while(tokener.hasNext(){result[i++]=toker.nextToken();}

34、数组有没有length()这个方法? String有没有length()这个方法？ 

数组没有length()这个方法，有length的属性。String有有length()这个方法。

35、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";

答：对于如下代码：

String s1 = "a";

String s2 = s1 + "b";

String s3 = "a" + "b";

System.out.println(s2 == "ab");//注意s2是字符串拼接创建2个字符串对象

System.out.println(s3 == "ab");

-----------------执行结果---------------------------

false

true

javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。

36、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后? 

请先看下面程序代码的运行结果：

[java] view plain copy
 
  1. public  class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.          System.out.println(new Test().test());  
  6.   
  7.     }  
  8.   
  9.     static int test(){//静态方法属于类的方法，直接调用，执行主函数  
  10.   
  11.     int x = 1;  
  12.   
  13.     try{  
  14.   
  15.      return x;  
  16.   
  17.    }finally{  
  18.   
  19.       ++x;  
  20.   
  21.    }  
  22.   
  23.   }  
  24.   
  25. }  

---------执行结果 ---------

1

运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回就是子函数说，我不运行了你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。

37、下面的程序代码输出的结果是多少？

[java] view plain copy
 
  1. public class  smallT{  
  2.   
  3.     public static void  main(String args[]){  
  4.   
  5.        smallT t  = new  smallT();  
  6.   
  7.        int  b  =  t.get();  
  8.   
  9.        System.out.println(b);  
  10.   
  11.     }  
  12.   
  13.     public int  get(){//普通方法，创建对象调用  
  14.   
  15.         try{  
  16.   
  17.           return 1 ;  
  18.   
  19.        }finally{  
  20.   
  21.          return 2 ;  
  22.   
  23.      }  
  24.   
  25.   }  
  26.   
  27. }  

------------执行结果--------------------------

2

我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

在讲解答案时可以用下面的程序来帮助分析：

[java] view plain copy
 
  1. public  class Test {  
  2.   
  3.      public static void main(String[] args) {  
  4.   
  5.          System.out.println(new Test().test());;  
  6.   
  7.      }  
  8.   
  9.     int test(){  
  10.   
  11.        try{  
  12.   
  13.           return func1();  
  14.   
  15.       }finally{  
  16.   
  17.          return func2();  
  18.   
  19.      }  
  20.   
  21.    }  
  22.   
  23.    int func1(){  
  24.   
  25.        System.out.println("func1");  
  26.   
  27.       return 1;  
  28.   
  29.    }  
  30.   
  31.    int func2(){  
  32.   
  33.      System.out.println("func2");  
  34.   
  35.      return 2;  
  36.   
  37.   }  
  38.   
  39. }  

-----------执行结果-----------------

func1

func2

2

结论：finally中的代码比return 和break语句后执行

38、final, finally, finalize的区别。 

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 典型案例内部类要访问局部变量，局部变量必须定义成final类型。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等，JVM不保证此方法总被调用。

39、运行时异常与一般异常有何异同？ 

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

40、error和exception有什么区别? 

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

41、请写出你最常见到的运行异常（runtime exception）。 

ArithmeticException（算术异常）

ClassCastException （类转换异常）

IllegalArgumentException （非法参数异常）

IndexOutOfBoundsException （下表越界异常）

NullPointerException （空指针异常）

SecurityException （安全异常）

42、请JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？

Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throw）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理；try用来指定一块预防所有“异常”的程序；catch子句紧跟在try块后面，用来指定你想要捕捉的“异常”的类型；throw语句用来明确地抛出一个“异常”；throws用来标明一个成员函数可能抛出的各种“异常”；finally为确保一段代码不管发生什么“异常”都被执行一段代码；可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，“异常”的框架就放到栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理，栈就会展开，直到遇到有处理这种“异常”的try语句。

43、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法?  

第一种：

new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：

new Thread(){

     public void run(){

}

}.start();

第二种：

new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：

new Thread(new Runnable(){

     public void run(){

     }

  }

).start();

有两种实现方法，分别是继承Thread类与实现Runnable接口

用synchronized关键字修饰同步方法

44、sleep() 和 wait() 有什么区别? 

     （网上的答案：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。）

sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定 的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了 cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可 以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是 马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增 加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。对于wait的讲解一定要配合例子 代码来说明，才显得自己真明白。

[java] view plain copy
 
  1. package com.huawei.interview;  
  2.   
  3. public class MultiThread {  
  4.   
  5.      public static void main(String[] args) {  
  6.   
  7.          new Thread(new Thread1()).start();  
  8.   
  9.         try {  
  10.   
  11.            Thread.sleep(10);  
  12.   
  13.          } catch (InterruptedException e) {  
  14.   
  15.            e.printStackTrace();  
  16.   
  17.         }  
  18.   
  19.       new Thread(new Thread2()).start();  
  20.   
  21.    }  
  22.   
  23.    private static class Thread1 implements Runnable{  
  24.   
  25.           public void run() {  
  26.   
  27.            /** 
  28.  
  29.             由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。 
  30.  
  31.             我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。 
  32.  
  33.             */  
  34.   
  35.             synchronized (MultiThread.class) {  
  36.   
  37.                  System.out.println("enter thread1...");  
  38.   
  39.                  System.out.println("thread1 is waiting");  
  40.   
  41.                 try {  
  42.   
  43.                    /** 
  44.                     释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围， 
  45.                     另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。 
  46.                    */  
  47.                 MultiThread.class.wait();  
  48.   
  49.                } catch (InterruptedException e) {  
  50.   
  51.                    e.printStackTrace();  
  52.   
  53.          }  
  54.   
  55.         System.out.println("thread1 is going on...");  
  56.   
  57.         System.out.println("thread1 is being over!");  
  58.   
  59.     }  
  60.   
  61.    }  
  62.   
  63. }  
  64.   
  65. private static class Thread2 implements Runnable{  
  66.   
  67.        public void run() {  
  68.   
  69.        synchronized (MultiThread.class) {  
  70.   
  71.              System.out.println("enter thread2...");  
  72.   
  73.              System.out.println("thread2 notify other thread can release wait status..");  
  74.   
  75.             //由于notify方法并不释放锁， 即使thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得到锁。  
  76.   
  77.             MultiThread.class.notify();  
  78.   
  79.            System.out.println("thread2 is sleeping ten millisecond...");  
  80.   
  81.            try {  
  82.   
  83.                Thread.sleep(10);  
  84.   
  85.             } catch (InterruptedException e) {  
  86.   
  87.               e.printStackTrace();  
  88.   
  89.           }  
  90.   
  91.           System.out.println("thread2 is going on...");  
  92.   
  93.           System.out.println("thread2 is being over!");  
  94.   
  95.       }  
  96.   
  97.     }  
  98.   
  99.   }  
  100.   
  101. }  

45、同步和异步有何异同，在什么情况下分别使用他们？举例说明。 

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

46、多线程有几种实现方法?同步有几种实现方法? 

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

47、启动一个线程是用run()还是start()?  

启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

48、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 

分几种情况：

1.其他方法前是否加了synchronized关键字，如果没加，则能。

2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。

3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。

4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。

49、线程的基本概念、线程的基本状态以及状态之间的关系 ?

一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上 都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即main方法执行的那个线程。如果只是一个cpu，它怎么能够同时执 行多段程序呢？这是从宏观上来看的，cpu一会执行a线索，一会执行b线索，切换时间很快，给人的感觉是a,b在同时执行，好比大家在同一个办公室上网， 只有一条链接到外部网线，其实，这条网线一会为a传数据，一会为b传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。

状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。

调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状 态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转 为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

50、简述synchronized和java.util.concurrent.locks.Lock的异同 ？ 

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。 synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的 tryLock方法可以非阻塞方式去拿锁。

举例说明：

[java] view plain copy
 
    1. package com.huawei.interview;  
    2.   
    3. import java.util.concurrent.locks.Lock;  
    4.   
    5. import java.util.concurrent.locks.ReentrantLock;  
    6.   
    7. public class ThreadTest {  
    8.   
    9.      private int j;  
    10.   
    11.      private Lock lock = new ReentrantLock();  
    12.   
    13.      public static void main(String[] args) {  
    14.   
    15.              ThreadTest tt = new ThreadTest();  
    16.   
    17.              for(int i=0;i<2;i++){  
    18.   
    19.                 new Thread(tt.new Adder()).start();  
    20.   
    21.                 new Thread(tt.new Subtractor()).start();  
    22.   
    23.              }  
    24.   
    25.      }  
    26.   
    27.      private class Subtractor implements Runnable{  
    28.   
    29.                public void run() {  
    30.   
    31.                while(true){  
    32.   
    33.                   lock.lock();  
    34.   
    35.                try{  
    36.   
    37.                  System.out.println("j--=" + j--);  
    38.   
    39.                }finally{  
    40.   
    41.                   lock.unlock();  
    42.   
    43.                }  
    44.   
    45.            }  
    46.   
    47.        }  
    48.   
    49. }  
    50.   
    51. private class Adder implements Runnable{  
    52.   
    53.       public void run() {  
    54.   
    55.       while(true){  
    56.   
    57.         lock.lock();  
    58.   
    59.         try{  
    60.   
    61.            System.out.println("j++=" + j++);  
    62.   
    63.         }finally{  
    64.   
    65.           lock.unlock();  
    66.   
    67.        }  
    68.   
    69.      }  
    70.   
    71.    }  
    72.   
    73.   }  
    74.   
    75. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/qlqwjy/p/7683733.html