【面试题】java基础（一）

面试准备的时候遇到很多问题，在网上找的答案都是说的一大堆，这里总结归纳一下，方便之后查看。

　　1、谈谈final、finally、finalize的区别。

　　final     ：  修饰类，则该类不能被继承，因此一个类不能即被声明为abstract，又被声明为final；

　　　　　   　修饰变量，该变量声明时必须给定初始值，在以后的引用中只能读取，不可修改；

　　　　　　   修饰方法，该方法只能使用，不能重载。

　　finally  ： 在异常处理中，如果使用finally块，程序不管是否被捕捉到异常或者异常是否被处理，都要执行finally代码块中的程序。

　　finalize：方法名称，是Object中的方法，这个方法在对象被垃圾收集器删除之前进行调用，子类可覆盖finalize()方法以整理系统资源或执行其它清理工作；

　　　　　　可以在此进行一些扩展，如果调用这个方法时，抛出了无法捕获的异常，GC将终止对这个对象的回收，等到下次GC时再进行回收。

　　2、java访问修饰符权限的区别。

　　　　public　　   所有类都可以访问；

　　　　protected    只允许包内、子类访问；

　　　　默认　　     只允许包内访问；

　　　　private        只允许类内访问。

　　3、String是否可以继承，“+”怎样实现？

　　　　String是final类，不可继承。“+”是通过StringBuilder类（java1.5之前是StringBuffer）的append方法实现。

　　既然说到字符串的实现原理，那么再来看一个实例问题。

　　4、下列代码的运行结果是什么？

String s=null;
s=s+"abc";
System.out.println(s);

　　答案：nullabc

　　解析：

　　　　字符串拼接原理：运行时， 两个字符串str1, str2的拼接首先会调用 String.valueOf(obj)，这个Obj为str1，而String.valueOf(Obj)中的实现是return obj == null ? “null” : obj.toString()；

　　　　接下来根据String.valueOf(obj)转换的str1生成StringBuilder， 调用的StringBuilder(str1)构造方法， 把StringBuilder初始化，长度为str1.length()+16，并且调用append(str1)！ 接着调用StringBuilder.append(str2), 把第二个字符串拼接进去， 然后调用StringBuilder.toString返回结果！

　　　　StringBuilder(str) 底层调用：

public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
}

　　5、String、StringBuffer、StringBuilder的区别

　　简单点说：String：不可变；StringBuffer：可变，线程安全；StringBuilder：可变，线程不安全；

　　详细点：String因为其不可变性，导致拼接字符串时会产生很多无用的中间对象，频繁进行这样的操作对性能有所影响；

　　　　　　StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append等方法，可以将字符串添加到已有序列的任意位置，本质是一个线程安全的可修改的字符序列。

　　　　　　StringBuilder本质上没什么区别，就是去掉了保证线程安全的部分，减少了开销。

　　总结：

　　　　1、在字符串不经常发生变化的业务场景优先使用String(代码更清晰简洁)。如常量的声明，少量的字符串操作(拼接，删除等)。

　　　　2、在单线程情况下，如有大量的字符串操作情况，应该使用StringBuilder来操作字符串。不能使用String"+"来拼接而是使用，避免产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。如JSON的封装等。

　　　　3、在多线程情况下，如有大量的字符串操作情况，应该使用StringBuffer。如HTTP参数解析和封装等。

　　6、以下代码运行结果是什么？

public class BwfOuterClass {

      private int x = 1;

      private int y = 2;

      private class BwfInnerClass{

           private int x = 3;

           public void print(){

                 System.out.println("x+y="+(x+y) );

           }

      }

      public static void main(String[] args) {

           new BwfOuterClass().new BwfInnerClass().print();

      }

}

　　答案：x+y=5

　　在java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这三种：成员内部类、局部内部类、匿名内部类，如下图所示：

　　

　　

　　本题考的是成员内部类。成员内部类是最普通的内部类，它的定义为位于另一个类的内部，类似于一个成员属性。可以使用修饰符private、default、protected、public。

　　  本题中BwfInnerClass是BwfOuterClass的成员内部类，成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。但是值得注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

　　   外部类.this.成员变量

　　　  外部类.this.成员方法

　　本题中，如果把print方法做如下修改：

　　public void print(){

　　  System.out.println("x+y=" + (BwfOuterClass.this.x+y));

　　}

　　则输出结果为：x+y=3

　　7、看下面代码求值：

/要求：使用已知的变量，在控制台输出30，20，10。
     　class Outer {
            public int num = 10;
            class Inner {
                public int num = 20;
                public void show() {
                    int num = 30;
                    System.out.println(?);
                    System.out.println(??);
                    System.out.println(???);
                }
            }
        }

        class InnerClassTest {
            public static void main(String[] args) {
                Outer.Inner oi = new Outer().new Inner();
                oi.show();
            }
        }

　　答案：num、this.num、Outer.this.num

　　　　解析:这题你如何明白了上面总结中的第二点，那么非常简单，考察的就是1、局部变量 2、this，和3、Outer.this，也就是内部类访问外部类属性方法的原理。这考察三个东西，

　　　　　　　1、在一个方法中，使用直接使用变量名，肯定使用的是局部变量，因为会把大的成员变量给隐藏掉，这题中，也就是说show方法中的num会将内部类中的成员变量num隐藏掉，而内部类中的成员变量num又会把外部类中的成员变量num隐藏掉，所以通过直接输出num，会是show方法中的局部变量的值30.

　　　　　　　2、使用this.num调用，其this代表的是调用该方法的对象，调用show方法的是oi，oi也就是内部类对象，所以oi.num也就标识内部类的成员变量num的值20

　　　　　　　3、Outer.this.num，调用的外部类中的成员变量num的值也就是10，这个如果不清楚就看上面总结中的第二点，就是那个原理。

　　8、按要求补齐代码

按照要求，补齐代码
        interface Inter { void show(); }
        class Outer { //补齐代码 }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
        要求在控制台输出”HelloWorld”

　　答案：

interface Inter { void show(); }
        class Outer {
　　　　　　//补齐代码
　　　　　　public static Inter method(){
　　　　　　　　return new Inter(){
　　　　　　　　　　void show(){
　　　　　　　　　　　　System.out.println("HelloWorld");
　　　　　　　　　　}
　　　　　　　　};
　　　　　　}
　　　　 }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }　

　　9、Anonymous Inner Class（匿名内部类）是否可以继承其他类？是否可以实现接口？

　　答案：匿名内部类必须继承一个类或实现一个接口，指定给new的类型为匿名类的超类型，但匿名类不能有显示的extends或implements子句，也不能有任何修饰符。

　　10、为什么局部内部类调用的外部变量必须是final修饰的？

　　答案：因为生命周期的原因。方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。

　　为了解决局部变量的生命周期与局部内部类的对象的生命周期的不一致性问题。