Java基礎面試題，你能做對多少？

基礎

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

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

//簡單示例
  public class MyDemo {      
         public static void main(String... args) {
          Demo demo = Demo.A;          
            switch (demo) {              
                       case A:                  
                    break;              
                       case B:                  
                    break;
          }
      }      
          enum Demo {
          A,
          B,
          C
      }
  }

餓漢式

• 2 if和switch的區(qū)別：

  if ：1.對具體的值進行判斷  2.對區(qū)間判斷  3.對運算結果是boolean類型的表達式進行判斷

  switch :1.對具體的值進行判斷；2.值的個數(shù)通常是固定的。

  對于幾個固定值的判斷，建議使用switch語句，因為switch語句會將具體的答案加載進內存，相對高效一點。

• 重載和重寫的區(qū)別

  • 重載：允許存在一個以上的同名函數(shù)，只要它們的參數(shù)類型不同即可。

  • 重寫：當子類繼承父類，沿襲了父類的功能到子類中，子類雖具備該功能，但功能內容不一致，這是使用覆蓋特性，保留父類的功能定義，并重寫功能內容。

• 單例模式

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 ;
      }
  }

特殊關鍵字：final

1. 可以修飾類、函數(shù)、變量；  
2. 被final修飾的類不可以被繼承。為了避免被繼承，被子類復寫。final class Demo { }  
3. 被final修飾的方法不可以被復寫。final void show () { }  
4. 被final 修飾的變量是一個常量，只能賦值一次。  
5. 內部類定義在類中的局部位置上時，只能訪問該局部被final修飾的局部變量。

      異常：（關于問題1，謝謝ylt提醒）

 try{}catch(){}finally{}  
 1.在catch中return(),finally{}會不會執(zhí)行？
  答：會，會在return之后執(zhí)行。  
 2.finally()在什么情況下不會執(zhí)行
  答：只有一種情況不會執(zhí)行，當執(zhí)行到System.exit(0)時，finally不會執(zhí)行。

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靜態(tài)代碼塊、構造函數(shù)、構造代碼塊

• 先看下面一段代碼，運行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.    優(yōu)先于對象存在  
  3.    被所有對象所共享  
  4.    可以直接被類所調用  
  5.    static是一個修飾符，用于修飾成員

構造代碼塊

作用：給對象進行初始化，對象一建立就運行，而且優(yōu)先于構造函數(shù)執(zhí)行。

  和構造函數(shù)的區(qū)別：
  構造代碼塊是給所有對象進行統(tǒng)一初始化；而構造函數(shù)是給對應的對象初始化
  構造代碼塊中定義的是不同對象共性的初始化內容

靜態(tài)代碼塊

 static
  {
      靜態(tài)代碼塊中的執(zhí)行語句；
  }
  特點：隨著類的加載而執(zhí)行，只執(zhí)行一次（再new一個對象也不會執(zhí)行，類只加載一次），
  如果定義在有主函數(shù)的類中，則優(yōu)先于主函數(shù)執(zhí)行。用于給類進行初始化。
  有些類不用創(chuàng)建對象，無法用構造函數(shù)初始化，就通過靜態(tài)代碼塊初始化。

  執(zhí)行順序：靜態(tài)代碼塊先執(zhí)行，如果有對象，構造代碼塊先執(zhí)行，然后是構造函數(shù)。
  如果沒有對象，則構造代碼塊和構造函數(shù)都不會執(zhí)行。

Java-封裝、繼承、多態(tài)

抽象類的特點：

 1.    抽象方法一定在抽象類中。  
 2.    抽象方法和抽象類都必須被abstract關鍵字修飾。  
 3.    抽象類不可以用new創(chuàng)建對象，因為調用抽象方法沒有意義。  
 4.    抽象類中的抽象方法要被使用，必須由子類復寫所有的抽象方法后，建立子類對象調用。如果子類只覆蓋了部分抽象方法，那么該子類還是一個抽象類。強迫子類復寫，強迫子類做一些事。  
 5.    抽象類中可以不定義抽象方法，如果不定義抽象方法，那么抽象類的功能就是為了不讓該類建立對象。

抽象關鍵字不可以和哪些關鍵字共存？

 答（1）private不能：抽象方法就是給子類覆蓋的，私有了就不能覆蓋了。
   （2）static不能：static可以直接用類名調用，而調用抽象方法沒有意義。
   （3）final 不能：final修飾的方法不可以被復寫，修飾的類不可以被繼承。與abstract沖突。

接口的特點

       接口是對外暴露的規(guī)則。
  ●    接口是程序的功能擴展。
  ●    接口可以多實現(xiàn)。
  ●    類與接口直接是實現(xiàn)關系，而且類可以繼承一個類的同時實現(xiàn)多個接口。
  ●    接口與接口之間可以有繼承關系，可以多繼承。
       因為接口沒有方法體，不會存在兩個父類出現(xiàn)同一個方法但是方法體不同的情況，
       不會引起沖突，如下：  
       
  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.    抽象類需要被繼承，而且只能單繼承；接口需要被實現(xiàn)，而且可以多實現(xiàn)  
        2.    抽象類中可以定義抽象方法和非抽象方法，子類繼承后，可以直接使用非抽象方法；
        接口只能定義抽象方法，必須有子類實現(xiàn)。  
        3.    抽象類的繼承，是is a關系，在定義該體系的基本共性內容；
              接口的實現(xiàn)是like a 關系，在定義體系額外功能。

繼承

  子類的實例化過程：
  結論：子類的所有的構造函數(shù)，默認都會訪問父類中空參數(shù)構造函數(shù)，因為子類中每一個構造函數(shù)內的第一行都有一句隱式的super() ;
  當父類中沒有空參數(shù)的構造函數(shù)時，子類必須手動通過super或者this語句形式來指定要訪問的構造函數(shù)。
  當然：子類的構造函數(shù)第一行也可以手動指定this語句來訪問本類中的構造函數(shù)，
  子類中至少會有一個構造函數(shù)會訪問到父類中的構造函數(shù)。

對象的初始化過程，見下圖：

打印結果