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

來源：奇酷教育發表于：2016-12-08 11:24:47

基礎1 switch支持的類型：byte, short, int, char, enum,注意：不支持long,double，JDK7之后，開始支持String。簡單示例 public c

基礎

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的區別：

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

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

對于幾個固定值的判斷，建議使用switch語句，因為switch語句會將具體的答案加載進內存，相對高效一點。
重載和重寫的區別
- 重載：允許存在一個以上的同名函數，只要它們的參數類型不同即可。
- 重寫：當子類繼承父類，沿襲了父類的功能到子類中，子類雖具備該功能，但功能內容不一致，這是使用覆蓋特性，保留父類的功能定義，并重寫功能內容。
單例模式

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

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

 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語句來訪問本類中的構造函數，
  子類中至少會有一個構造函數會訪問到父類中的構造函數。

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