面试-Java基础（一）

1 switch支持的类型：byte, short, int, char, enum,

注意：不支持long,double，JDK7之后，开始支持String。

2 if和switch的区别：

if ：1.对具体的值进行判断  2.对区间判断  3.对运算结果是boolean类型的表达式进行判断

switch :1.对具体的值进行判断；2.值的个数通常是固定的。

对于几个固定值的判断，建议使用switch语句，因为switch语句会将具体的答案加载进内存，相对高效一点。

3 重载和重写的区别

　　重载：允许存在一个以上的同名函数，只要它们的参数类型不同即可。

　　重写：当子类继承父类，沿袭了父类的功能到子类中，子类虽具备该功能，但功能内容不一致，这是使用覆盖特性，保留父类的功能定义，并重写功能内容。

4 单例模式

饿汉式

private static Single s = new Single ( ) ;          
        private Single ( ) { }  
          public static Single getInstance () 
          {          
           return s ;
          }

懒汉式

class Single {      
   public static Single getInstance (){          
        if ( s== null ){              
           synchronized (Single.class){//锁不读可以提高效率
              if ( s== null ){
                  s = new Single () ;
               }
           }          
           return s ;
      }
  }

5 特殊关键字：final

1. 可以修饰类、函数、变量；  
2. 被final修饰的类不可以被继承。为了避免被继承，被子类复写。final class Demo { }  
3. 被final修饰的方法不可以被复写。final void show () { }  
4. 被final 修饰的变量是一个常量，只能赋值一次。  
5. 内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

异常：

try{}catch(){}finally{}  
 1.在catch中return(),finally{}会不会执行？
  答：会，会在return之后执行。  
 2.finally()在什么情况下不会执行
  答：只有一种情况不会执行，当执行到System.exit(0)时，finally不会执行。

public class Test {  public static void main(String[] args) {
      System.out.println("haha:" + haha(true));
  }  
private static boolean haha(boolean isTrue) {      
    try {          
         int i = 1 / 0;          
         return  isTrue ? System.out.printf("return try !null ", "test") != null : System.out.printf("return try null ", "test") == null;
      } catch (Exception e) {
          System.out.println("catch");          
          return  isTrue ? System.out.printf("return catch !null ", "test") != null : System.out.printf("return catch null ", "test") == null;
      } finally {            
          System.out.println("");
          System.out.println("finally");
      }        
  }
}

//打印结果：
catch
return catch !null 
finally
haha:true

Java静态代码块、构造函数、构造代码块

　　先看下面一段代码，运行Test，会打印什么？

package test;  
public class Test {      
   public static void main(String... args) {
          TestA a;
          a = new TestA();
          a = new TestA();
          TestA aa = new TestA();
      }
  }  
  class TestA {
      {
          System.out.println("TestA code create");
      }      
          private TestB b = new TestB();      
          private static TestC c = new TestC();      
          
          public TestA() {
              System.out.println("TestA create");
      }      
          
          static {
             System.out.println("TestA static create");
      }
  }  
  class TestB {      
     public TestB() {
          System.out.println("TestB create");
      }
  }  
  class TestC {      
     public TestC() {
          System.out.println("TestC create");
      }
  }

打印结果：

TestC create
TestA static create
TestA code create
TestB create
TestA create
TestA code create
TestB create
TestA create
TestA code create
TestB create
TestA create


static特点：

 1.    随着类的加载而加载（随着类的消失而消失，生命周期最长）  
  2.    优先于对象存在  
  3.    被所有对象所共享  
  4.    可以直接被类所调用  
  5.    static是一个修饰符，用于修饰成员

构造代码块

作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。

  和构造函数的区别：
  构造代码块是给所有对象进行统一初始化；而构造函数是给对应的对象初始化
  构造代码块中定义的是不同对象共性的初始化内容

静态代码块

static
  {
      静态代码块中的执行语句；
  }
  特点：随着类的加载而执行，只执行一次（再new一个对象也不会执行，类只加载一次），
  如果定义在有主函数的类中，则优先于主函数执行。用于给类进行初始化。
  有些类不用创建对象，无法用构造函数初始化，就通过静态代码块初始化。

  执行顺序：静态代码块先执行，如果有对象，构造代码块先执行，然后是构造函数。
  如果没有对象，则构造代码块和构造函数都不会执行。

Java-封装、继承、多态

　　抽象类的特点：

1.    抽象方法一定在抽象类中。  
 2.    抽象方法和抽象类都必须被abstract关键字修饰。  
 3.    抽象类不可以用new创建对象，因为调用抽象方法没有意义。  
 4.    抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。强迫子类复写，强迫子类做一些事。  
 5.    抽象类中可以不定义抽象方法，如果不定义抽象方法，那么抽象类的功能就是为了不让该类建立对象。

抽象关键字不可以和哪些关键字共存？

答（1）private不能：抽象方法就是给子类覆盖的，私有了就不能覆盖了。
   （2）static不能：static可以直接用类名调用，而调用抽象方法没有意义。
   （3）final 不能：final修饰的方法不可以被复写，修饰的类不可以被继承。与abstract冲突。

接口的特点

接口是对外暴露的规则。
  ●    接口是程序的功能扩展。
  ●    接口可以多实现。
  ●    类与接口直接是实现关系，而且类可以继承一个类的同时实现多个接口。
  ●    接口与接口之间可以有继承关系，可以多继承。
       因为接口没有方法体，不会存在两个父类出现同一个方法但是方法体不同的情况，
       不会引起冲突，如下：  

public class Test implements d{     
      public static void main(String... args) {
      }      
      
      @Override
      public void as() {
      }
  }  
      
      interface d extends e,f {
  }  
      interface f{      
      void as();
  }  
      interface e{      
      void as();
  }

接口和抽象类的异同点：

相同点：都是不断向上抽取而来的。不可以被实例化

 不同点：1.    抽象类需要被继承，而且只能单继承；接口需要被实现，而且可以多实现  
        2.    抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法；
        接口只能定义抽象方法，必须有子类实现。  
        3.    抽象类的继承，是is a关系，在定义该体系的基本共性内容；
              接口的实现是like a 关系，在定义体系额外功能。

继承

子类的实例化过程：
  结论：子类的所有的构造函数，默认都会访问父类中空参数构造函数，因为子类中每一个构造函数内的第一行都有一句隐式的super() ;
  当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式来指定要访问的构造函数。
  当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，
  子类中至少会有一个构造函数会访问到父类中的构造函数。