2021最新 Java基礎面試題精選（附刷題小程序）

時間  2021-08-13
標籤 java 面試 正則表達式 算法 小程序 數組 安全 服務器 微信 網絡 欄目 Java 简体版
原文   原文鏈接

推薦使用小程序閱讀

爲了能讓您更加方便的閱讀
本文全部的面試題目均已整理至下面的小程序《面試手冊》
能夠經過微信掃描(或長按)下圖的二維碼享受更好的閱讀體驗!java

ah_xct

1. Java 基本概念

1.1 Java源程序的擴展名是什麼？

.java面試

1.2 什麼是標識符？

在java語言中可以咱們本身起名的都叫標識符正則表達式

1.3 標識符有哪些特色？

標識符是大小寫字母、數字字符、$和_組成，不能以數字開頭，也不能是java關鍵字，而且區分大小寫算法

1.4 請說明環境變量Path 與 classpath 區別

path是系統用來指定可指定文件的完整路徑。Path是用來搜索所執行的可執行文件路徑的，若是執行的可執行文件不在當前目錄下，那就會依次搜索path中設置的路徑。小程序

classpath是指定你在程序中所使用的類(.class)文件所在的位置。數組

1.5 java程序經編譯後產生的字節碼文件擴展名是什麼？

字節碼文件擴展名是 .class安全

1.6 請說出經常使用的DOS命令並解釋？

  • d: 回車
    盤符切換
  • dir (directory)
    列出當前目錄下的文件以及文件夾
  • cd (change directory)
    改變指定目錄(進入指定目錄)
  • cd..
    退回到上一層目錄
  • cd \
    退回到跟目錄
  • md (make directory)
    建立目錄
  • rd (remove directory)
    刪除目錄
  • del (delete)
    刪除文件，刪除一堆後綴名同樣的文件*.txt
  • cls (clear screen)
    清屏
  • exit
    退出dos命令行

1.7 請解釋Java語言的跨平臺特性？

Java語言是跨平臺運行的，其實就是不一樣的操做系統，使用不一樣的JVM映射規則，讓其與操做系統無關，完成了跨平臺性。JVM對上層的Java源文件是不關心的，它關注的只是由源文件生成的類文件(class file)。服務器

1.8 請說明JDK、JRE、JVM的區別？

  • JDK
    Java Development Kit(Java開發工具包)。JDK是整個JAVA的核心，包括了Java運行環境(Java Runtime Environment)，一堆Java工具（javac/java/javap等）
  • JRE
    Java Runtime Environment(java運行時環境)。也就是咱們說的JAVA平臺。全部的Java程序都要在JRE下才能運行。包括JVM和JAVA核心類庫和支持文件。與JDK相比，它不包含開發工具(編譯器、調試器和其餘工具)。
  • JVM
    Java Virtual Mechinal(JAVA虛擬機)。JVM是JRE的一部分，它是一個虛構出來的計算機，是經過在實際的計算機上仿真模擬各類計算機功能來實現的。

2. Java 基礎

2.1 註釋的分類及做用？

  • 單行註釋
    註釋單行代碼或爲單行代碼添加描述的時候使用
  • 多行註釋
    註釋多行代碼或爲代碼添加多行描述的時候使用
  • 文檔註釋
    生產java幫助文檔的時候使用，開發中經常使用來描述類、描述方法

2.2 請說出Java中數據類型的分類?基本數據類型都有哪些?

  • 基本數據類型
    • byte
    • short
    • int
    • long
    • float
    • double
    • char
    • boolean
  • 引用數據類型
    • 數組
    • 類
    • 接口

2.3 Java中數據的類型轉換有幾種?分別是什麼?

  • 強制類型轉換
    容量大的類型向容量小的類型轉換時使用
  • 隱式類型轉換
    容器小的類型向容量大的類型轉換時使用

2.4 Java語言中的字符char能夠存儲一箇中文漢字嗎?爲何呢?

char型變量是用來存儲Unicode編碼的字符的，unicode編碼字符集中包含了漢字，因此，char型變量中能夠存儲漢字。不過，若是某個特殊的漢字沒有被包含在unicode編碼字符集中，那麼，這個char型變量中就不能存儲這個特殊漢字。
補充說明：unicode編碼佔用兩個字節，因此，char類型的變量也是佔用兩個字節。微信

2.5 請說明 && 和 & 的區別？

&和&&均可以用做邏輯與的運算符，表示邏輯與(and)，當運算符兩邊的表達式的結果都爲true時，整個運算結果才爲true，不然，只要有一方爲false，則結果爲false。網絡

&&還具備短路的功能，即若是第一個表達式爲false，則再也不計算第二個表達式

&還能夠用做位運算符，當&操做符兩邊的表達式不是boolean類型時，&表示按位與操做。

2.6 請說明 == 與 = 的區別？

  • ==
    比較運算符，用來比較操做符兩邊的變量的值是否相等。
  • =
    賦值運算符，把操做符右邊的值，賦值給左邊的變量

2.7 三元運算符的基本格式是什麼？

三元運算符的格式是: 條件表達式 ? 表達式1 : 表達式2

2.8 三元運算符的執行流程是什麼？

三元運算符的執行流程: 首先計算條件表達式的值看其返回結果是true仍是false,若是是true就執行表達式1,若是是false就執行表達式2

2.9 使用鍵盤錄入數據的三個步驟是什麼？

  • 第一步導包
    格式: import java.util.Scanner ;位置: 在class上邊
  • 第二步建立Scanner對象
    格式: Scanner sc = new Scanner(System.in) ;
  • 第三步獲取鍵盤錄入數據
    格式: int x = sc.nextInt() ;

2.10 請說明for、while、do…while三種循環的格式以及執行流程，以及它們的區別。

  • for循環語句格式
    for(初始化語句;判斷條件語句;控制條件語句) {
    循環體語句;
    }
    • 執行流程：
  1. 執行初始化語句
  2. 執行判斷條件語句，看其結果是true仍是false，若是是false，循環結束；若是是true，繼續執行。
  3. 執行循環體語句
  4. 執行控制條件語句
  5. 回到b繼續
while循環語句格式
while(判斷條件語句) {
循環體語句;
}
  • 執行流程：
  1. 執行判斷條件語句，看其結果是true仍是false
    若是是false，循環結束。
    若是是true，繼續執行。
  2. 執行循環體語句
  3. 回到a繼續
do…while循環語句格式
do {
循環體語句;
}while((判斷條件語句);
  • 執行流程：
  1. 執行循環體語句
  2. 執行判斷條件語句，看其結果是true仍是false，若是是false，循環結束；若是是true，繼續執行。
  3. 回到a繼續
三種循環語句的區別
  • do…while循環至少會執行一次循環體
  • for循環和while循環只有在條件成立的時候纔會去執行循環體

注意：寫程序優先考慮for循環，再考慮while循環，最後考慮do…while循環

2.11 定義一個方法的格式是什麼,以及方法的注意事項?

  • 格式
    修飾符 返回值類型 方法名(參數類型 參數名1, 參數類型 參數名2 ….){
    方法體 ;
    return 返回值 ;
    }
  • 注意事項
    A. 方法不調用不執行
    B. 方法與方法是平級關係，不能嵌套定義
    C. 方法定義的時候參數之間用逗號隔開
    D. 方法調用的時候不用在傳遞數據類型
    E. 若是方法有明確的返回值，必定要有return帶回一個值

2.12 private 關鍵字在哪裏使用？ 被 private 修飾的成員有什麼特色？

類中的成員須要私有的時候使用private關鍵字
特色：
是一個權限修飾符。
能夠修飾成員(成員變量和成員方法)
被private修飾的成員只在本類中才能訪問

2.13 爲何要有 this 關鍵字？this 關鍵字的含義？

this用來解決成員變量與局部變量重名問題
this關鍵字表明的是本類對象引用；誰調用我,this就表明誰.

2.14 final 關鍵字是什麼意思，能夠修飾那些成員？被修飾的成員有哪些特色？

final最終的意思。

  • 可修飾

    • 類
    • 成員變量
    • 成員方法

  • 特色

    • final修飾類，此類不能被繼承。
    • final修飾變量，變量就成了常量，只能被賦值一次
    • final修飾方法，方法不能被重寫

2.15 形式參數是基本類型要的是什麼?是類名、抽象類名、接口名時分別要的是什麼?

形式參數是基本類型要的是一個基本類型的變量或者具體的常量值

  • 類名時
    要的是一個該類的對象
  • 抽象類名時
    要的是一個繼承自該類的一個子類對象
  • 接口時
    要的是一個實現了該接口的子類對象

2.16 返回值類型是基本類型返回的是什麼?是類名、抽象類名、接口名分別返回的是什麼?

返回值是基本數據類型的時候返回的是一個具體的值

  • 類名時
    本質上返回的是一個該類對應的子類對象
  • 抽象類名時
    返回的應該是一個繼承自該類的子類對象
  • 接口名的時
    返回的是一個實現了該接口的子類對象

2.17 package它有什麼做用？

package，包的意思，其實就是文件夾，它能夠對類進行分類管理

2.18 import的做用?

在不一樣包下的類之間相互訪問的時候，發現，每次使用不一樣包下的類的時候，都須要加包的全路徑。比較麻煩，這個時候，java就提供了( import )導包的功能。
使用import能夠將包中的類導入進來，之後使用類的時候，不需導包，直接使用，簡化了書寫。

2.19 請解釋 ==與equals()方法的區別？

== 解讀

對於基本類型和引用類型 == 的做用效果是不一樣的，以下所示：

  • 基本類型：比較的是值是否相同；
  • 引用類型：比較的是引用是否相同；

代碼示例：

String x = "string";
String y = "string";
String z = new String("string");
System.out.println(x==y); // true
System.out.println(x==z); // false
System.out.println(x.equals(y)); // true
System.out.println(x.equals(z)); // true

代碼解讀：由於 x 和 y 指向的是同一個引用，因此 == 也是 true，而 new String()方法則重寫開闢了內存空間，因此 == 結果爲 false，而 equals 比較的一直是值，因此結果都爲 true。

equals 解讀

equals 本質上就是 ==，只不過 String 和 Integer 等重寫了 equals 方法，把它變成了值比較。看下面的代碼就明白了。

首先來看默認狀況下 equals 比較一個有相同值的對象，代碼以下：

class Cat {
  public Cat(String name) {
    this.name = name;
  }
  private String name;
  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

Cat c1 = new Cat("mbb");
Cat c2 = new Cat("mbb");
System.out.println(c1.equals(c2)); // false

輸出結果出乎咱們的意料，居然是 false？這是怎麼回事，看了 equals 源碼就知道了，源碼以下：

public boolean equals(Object obj) {
  return (this == obj);
}

原來 equals 本質上就是 ==。

那問題來了，兩個相同值的 String 對象，爲何返回的是 true？代碼以下：

String s1 = new String("mbb");
String s2 = new String("mbb");
System.out.println(s1.equals(s2)); // true

一樣的，當咱們進入 String 的 equals 方法，找到了答案，代碼以下：

public boolean equals(Object anObject) {

  if (this == anObject) {
    return true;
  }

  if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = value.length;
    if (n == anotherString.value.length) {
      char v1[] = value;
      char v2[] = anotherString.value;
      int i = 0;

      while (n-- != 0) {
        if (v1[i] != v2[i])
          return false;
        i++;
      }

      return true;
    }
  }
  return false;
}

原來是 String 重寫了 Object 的 equals 方法，把引用比較改爲了值比較。

總結 ：== 對於基本類型來講是值比較，對於引用類型來講是比較的是引用；而 equals 默認狀況下是引用比較，只是不少類從新了 equals 方法，好比 String、Integer 等把它變成了值比較，因此通常狀況下 equals 比較的是值是否相等。

2.20 請簡述泛型是什麼?有什麼用?在哪裏用？

  • 泛型是什麼？
    泛型是一種特殊的類型，它把指定類型的工做推遲到客戶端代碼聲明並實例化類或方法的使用進行。也被稱爲參數化類型，能夠把類型當作參數同樣傳遞過來，在傳遞過來以前我不明確，可是在使用的時候就就明確了。
  • 泛型的好處
    • 提升了程序的安全性
    • 將運行期遇到的問題轉移到了編譯期
    • 省去了類型強轉的麻煩
  • 泛型的常見應用
    • 泛型類
    • 泛型方法
    • 泛型接口

2.21 如何編寫一個泛型方法，讓它可以接受泛型參數並返回泛型類型？並舉例

泛型方法，指把泛型定義在方法上，使用泛型類型來替代原始類型

public static T[] sort(T[] t){
  Arrays.sort(t);
  return t;
}

2.22 請簡述Java中如何使用泛型編寫帶有參數的類？並舉例

泛型類，指把泛型定義在類上，使用泛型類型來替代原始類型

class GenericClass {
  private T t;
  public void setT(T t) {
    this.t = t;
  }
  
  public T getT() {
    return t;
  }
}

2.23 請說說文件名稱過濾器FilenameFilter的做用？

FilenameFilter是文件名過濾器，用來過濾不符合規則的文件名，並返回合格的文件。

2.24 請簡述遞歸是什麼?注意事項是什麼?

所謂遞歸，是指程序調用自身。
注意，遞歸不會無休止地調用下去，它必然有一個出口，當知足條件時程序也就結束了，否則的話，那就是死循環了。

2.25 兩個對象的 hashCode() 相同，則 equals() 也必定爲 true，對嗎？

不對，兩個對象的 hashCode() 相同，equals() 不必定 true。

代碼示例：

String str1 = "通話";
String str2 = "重地";
System. out. println(String. format("str1：%d | str2：%d", str1. hashCode(),str2. hashCode()));
System. out. println(str1. equals(str2));

執行的結果：

str1：1179395 | str2：1179395
false

代碼解讀：很顯然「通話」和「重地」的 hashCode() 相同，然而 equals() 則爲 false，由於在散列表中，hashCode() 相等即兩個鍵值對的哈希值相等，然而哈希值相等，並不必定能得出鍵值對相等。

2.26 Java 中的 Math. round(-1. 5) 等於多少？

等於 -1，由於在數軸上取值時，中間值（0.5）向右取整，因此正 0.5 是往上取整，負 0.5 是直接捨棄。

3. Java 變量

3.1 請寫出Java標識符的命名規則

  • 包
    所有小寫
  • 單層包
    小寫，舉例：itcast，com
  • 多層包
    小寫，並用 . 隔開，舉例：cn.itcast， com.baidu
  • 類或者接口：
    • 一個單詞
      首字母大寫，舉例：Student，Demo
    • 多個單詞
      每一個單詞首字母大寫，舉例：HelloWorld，StudentName
  • 方法或者變量：
    • 一個單詞
      首字母小寫，舉例：name，main
    • 多個單詞
      從第二個單詞開始，每一個單詞首字母大寫，舉例：studentAge，showStudentNames()
  • 常量
    所有大寫
    • 一個單詞
      大寫，舉例：PI
    • 多個單詞
      大寫，並用 _ 隔開，舉例：STUDENT_MAX_AGE

3.2 變量是什麼?

變量，在程序運行時，值能夠被修改的量。

3.3 變量的定義格式是什麼?

數據類型 變量名 = 變量值

3.4 成員變量與局部變量的區別？

  • 在類中的位置不一樣
    成員變量：在類中方法外
    局部變量：在方法定義中或者方法聲明上

  • 在內存中的位置不一樣
    成員變量：在堆內存
    局部變量：在棧內存

  • 生命週期不一樣
    成員變量：隨着對象的建立而存在，隨着對象的消失而消失
    局部變量：隨着方法的調用而存在，隨着方法的調用完畢而消失

  • 初始化值不一樣
    成員變量：有默認初始化值
    局部變量：沒有默認初始化值，必須定義，賦值，而後才能使用。

3.5 靜態變量與成員變量的區別？

  • 所屬不一樣
    靜態變量屬於類，因此也稱爲爲類變量
    成員變量屬於對象，因此也稱爲實例變量(對象變量)

  • 內存中位置不一樣
    靜態變量存儲於方法區的靜態區
    成員變量存儲於堆內存

  • 內存出現時間不一樣
    靜態變量隨着類的加載而加載，隨着類的消失而消失
    成員變量隨着對象的建立而存在，隨着對象的消失而消失

  • 調用不一樣
    靜態變量能夠經過類名調用，也能夠經過對象調用
    成員變量只能經過對象名調用

4. Java String

4.1 String s = 「a」+「b」+」c」; 建立了多少對象,分別是什麼？

  • 5個對象
    • a
    • b
    • c
    • ab
    • abc

由於字符串的特色是一旦被建立就不能被改變,全部在使用常量進行相加的時候,都是在建立新的字符串對象，最後在把字符串"abc"這個常量值賦值給引用變量s

4.2 如何實現StringBuffer和String的相互轉換？

  1. 經過String類的構造方法
  2. 經過StringBuffer類中的toString()方法
  3. 經過StringBuffer類中的substring()方法 (注：不經常使用)
    String 轉換到 StringBuffer的方式：
  4. 經過StringBuffer類的構造方法
  5. 經過StringBuffer類的append()、insert()方法

4.3 如何實現String和int數據的相互轉換

  1. String – Integer – int經過Integer類的intValue()方法
  2. 經過Integer類的parseInt(String s)方法
    Int 轉換到 String的方式：
  3. Int – Integer – String Integer的toSting()
  4. 經過String類的valueOf()方法
  5. 經過Integer類的toSting(int i)方法
  6. 經過與字符串""相鏈接

4.4 如何實現【基本數據類型】與【基本數據封裝類】之間的相互轉換

  1. 經過包裝類的構造方法
  2. 經過包裝類的靜態方法valueOf()
    包裝類 轉換到 基本數據類型的方式：
  3. 經過包裝類的方法xxxValue()

4.5 請說明String與StringBuffer兩者之間的區別？

String類表示內容不能夠改變的字符串
StringBuffer類表示內容能夠被修改的字符串

4.6 請說明StringBuffer與StringBilder兩者之間的區別？

  • StringBilder
    是線程不安全的，運行效率高

    若是一個字符串變量是在方法裏面定義，這種狀況只可能有一個線程訪問它，不存在不安全的因素了，則用StringBuilder。

  • StringBuffer
    是線程安全的，運行要低於StringBilder

    若是要在類裏面定義成員變量，而且這個類的實例對象會在多線程環境下使用，那麼最好用StringBuffer。

4.7 什麼是正則表達式？

正則表達式使用單個字符串來描述、匹配一系列符合某個句法規則的字符串。在不少文本編輯器裏，正則達表示一般被用來檢索、替換那些符合某個模式的文本。

4.8 如何實現Date與long相互轉換?

  • Date 轉 long
    經過Date類的getTime()方法
  • long 轉 Date
    經過Date類的構造方法

4.9 如何實現Date與String相互轉換？

  • Date 轉 String

    • Date類的toString()方法
    • DateFormat類的format()方法

  • String 轉 Date

    • Date類的構造方法

      已過期，被DateFormat類的parse(String s)方法取代

    • DateFormat類的parse()方法

4.10 String 屬於基礎的數據類型嗎？

String 不屬於基礎類型
基礎類型有 8 種：

  • byte
  • boolean
  • char
  • short
  • int
  • float
  • long
  • double

而 String 屬於對象

4.11 String str=「i」 與 String str=new String(「i」)同樣嗎？

不同，由於內存的分配方式不同。String str="i"的方式，Java 虛擬機會將其分配到常量池中；而 String str=new String(「i」) 則會被分到堆內存中。

4.12 如何將字符串反轉？

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

示例代碼：

// StringBuffer reverse
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("abcdefg");
System.out.println(stringBuffer.reverse()); // gfedcba

// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("abcdefg");
System. out. println(stringBuilder.reverse()); // gfedcba

4.13 String 類的經常使用方法都有那些？

  • indexOf()：返回指定字符的索引。
  • charAt()：返回指定索引處的字符。
  • replace()：字符串替換。
  • trim()：去除字符串兩端空白。
  • split()：分割字符串，返回一個分割後的字符串數組。
  • getBytes()：返回字符串的 byte 類型數組。
  • length()：返回字符串長度。
  • toLowerCase()：將字符串轉成小寫字母。
  • toUpperCase()：將字符串轉成大寫字符。
  • substring()：截取字符串。
  • equals()：字符串比較。

5. Java 類、抽象類、接口、內部類、代碼塊

5.1 類是什麼？ 對象是什麼？舉例說明

是一組相關屬性和行爲的集合是一個抽象的東西,對象則是該類的一個具體的體現。

舉例: 學生就是一個類,而後每個學生都是學生的一個個具體的體現,因此每個學生就是一個學生。

5.2 類由哪些內容組成？

類由成員變量和成員方法組成
成員變量對應的就是事物的屬性(就是事物固有的信息,好比: 人的屬性有身高 , 姓名 , 年齡 , 學歷…) , 成員方法對應的是行爲(行爲: 就是該事物能夠作的事情,好比:人的行爲有: 吃飯,睡覺…)

5.3 什麼是匿名對象？何時使用匿名對象？

匿名對象指：沒有起名字的對象
使用匿名對象:
a:調用方法，僅僅只調用一次的時候
b:匿名對象能夠做爲實際參數傳遞

5.4 構造方法的做用是什麼？構造方法的特色是什麼？構造方法的注意事項？ 構造方法中可不能夠寫return 語句呢？

構造方法的做用是用於給類的成員變量賦值,完成類的初始化工做

  • 構造方法的特色:
    構造方法的名稱和類名相同
    構造方法沒有返回值類型,連void也沒有
    構造方法沒有具體的返回值

  • 構造方法的注意事項:

    • 若是一個類沒有給出構造方法,系統將會提供一個默認無參的構造方法

    • 若是咱們給出類構造方法,系統將不會提供默認無參的構造方法,這個時候若是咱們還想使用無參的構造方法來建立對象,那麼就須要咱們給出無參的構造方法
      能夠寫空的return語句.

5.5 一個類的缺省構造方法能夠有參數嗎？

一個類的缺省構造方法沒有參數

5.6 請說明一個對象的建立過程作了哪些事情？

Student s = new Student();

  1. 將Student.class 字節碼文件加載到內存
  2. 在棧內存中，開闢一個空間存儲 s變量，用來記錄Student對象的引用
  3. 在堆內存中，開闢一個空間存儲 new Student()對象的成員信息
  4. 加載類中靜態成員
  5. 執行類中靜態代碼塊
  6. 加載對象中普通成員
  7. 執行構造代碼塊
  8. 執行構造方法
  9. 將new Student()的地址賦值給 s 變量

5.7 子父類中構造方法的執行有什麼特色？爲何要這樣？

  1. 子類有全部的構造方法默認都會訪問父類中空參數的構造方法。
    由於子類會繼承父類中的數據，可能還會使用父類的數據。因此，子類初始化以前，必定要先完成父類數據的初始化。
    每個構造方法的第一條語句默認都是：super()
  2. 若是父類中沒有空參數的構造方法，經過下列方式解決
  • 子類經過super去顯示調用父類其餘的帶參的構造方法
  • 子類經過this去調用本類的其餘構造方法(本類其餘構造也必須首先能夠訪問了父類構造)

注意：super(…)或者this(…)必須出如今第一條語句上，不然，就會有父類數據的屢次初始化

5.8 靜態代碼塊，構造代碼塊，構造方法的執行順序是什麼以及執行特色？

  1. 先執行全部的靜態代碼塊，再執行全部的構造代碼塊，最後執行構造方法
  2. 靜態代碼塊只執行一次, 構造代碼塊和構造方法,每建立一次對象就執行一次

5.9 抽象類是什麼,抽象類的特色?

  • 抽象類的定義
    使用了關鍵字abstract聲明的類叫作「抽象類」。若是一個類裏包含了一個或多個抽象方法，類就必須指定成abstract（抽象）。「抽象方法」，屬於一種不完整的方法，只含有一個聲明，沒有方法主體。

  • 抽象類的特色:

    • 能夠是抽象類

      若是子類仍是抽象類,那麼咱們仍是不能進行實例化，還須要一個子類去繼承

    • 也能夠是非抽象類

      子類必須重寫父類的抽象方法

    • 抽象類的定義格式: abstract class 類名{}

    • 抽象方法的定義格式: public abstract 返回值類型 方法名();

    • 抽象類中能夠存在抽象方法,也能夠存在非抽象方法

    • 抽象類不能直接進行實例化,咱們可使用多態的形式進行進行間接實例化

    • 抽象類的子類

5.10 抽象類中有沒有構造方法,若是有它是用來作什麼的?

抽象類雖然不能進行實例化,可是抽象類中是存在構造方法,該構造方法的做用是用於子類訪問父類數據時的初始化.

5.11 接口中成員變量的特色,以及成員方法的特色?

接口中的成員變量都是常量,存在默認的訪問修飾符:

public static final

接口中的成員方法都是抽象方法,存在默認的訪問修飾符:

public abstract

5.12 請說出類與類,類與接口,以及接口與接口的關係以及特色?

  • 類與類
    是繼承的關係,只支持單繼承,能夠是多層繼承。
  • 類與接口
    是實現的關係,能夠是多實現
  • 特色
    • 一個類能夠繼承一個類的同時,還能夠實現多個接口
    • 接口與接口是繼承的關係,能夠是單繼承也能夠是多繼承

5.13 抽象類和接口的區別?

成員區別

  • 抽象類
    • 成員變量
      能夠是變量，也能夠是常量
  • 構造方法
    有
  • 成員方法
    能夠抽象，也能夠非抽象
  • 接口：
    • 成員變量
      只能夠常量
    • 成員方法
      只能夠抽象

關係區別

  • 類與類
    繼承，單繼承
  • 類與接口
    實現，單實現，多實現
  • 接口與接口
    繼承，單繼承，多繼承

設計理念區別

  • 抽象類
    被繼承體現的是：「is a」的關係。 抽象類中定義的是該繼承體系的共性功能。
  • 接口
    被實現體現的是：「like a」的關係。 接口中定義的是該繼承體系的擴展功能。

5.14 內部類有哪些訪問特色？

  1. 內部類能夠直接訪問外部類的成員，包括私有
  2. 外部類要訪問內部類的成員，必須先建立內部類對象

5.15 匿名內部類的格式是什麼?其本質是什麼?

  • 匿名內部類的格式
    new 類名或者接口名() {
    方法重寫 ;
    } ;
  • 本質
    匿名內部類本質是一個繼承了某一個類或者實現了某一個接口的子類對象

5.16 抽象類必需要有抽象方法嗎？

不須要，抽象類不必定非要有抽象方法。

示例代碼：

abstract class Cat {

  public static void sayHi() {
    System.out.println("hi~");
  }
}

上面代碼，抽象類並無抽象方法但徹底能夠正常運行。

5.17 抽象類能使用 final 修飾嗎？

不能，定義抽象類就是讓其餘類繼承的，若是定義爲 final 該類就不能被繼承，這樣彼此就會產生矛盾，因此 final 不能修飾抽象類

6. 封裝、繼承、多態

6.1 請解釋什麼是方法的重載?

方法重載指在同一個類中，容許存在一個以上的同名方法，只要它們的參數個數或者參數類型不一樣便可。

方法重載特色：
a) 與返回值類型無關，只看方法名和參數列表
b) 在調用時，虛擬機經過參數列表的不一樣來區分同名方法

6.2 使用面向對象【封裝】的好處有哪些？

隱藏實現細節，提供公共的訪問方式；
提升了代碼的複用性；
提升安全性。

6.3 Java 中的類的繼承特色是什麼以及繼承的注意事項？

繼承的特色: 在java語言中類的繼承只支持單繼承,不支持多繼承.可是能夠多層繼承。

繼承的注意事項:

  1. 子類只能繼承父類非私有的成員
  2. 子類不能繼承父類的構造方法,可是能夠經過super去訪問父類的構造方法
  3. 不要爲了某個功能去使用繼承

6.4 繼承的好處是什麼？

  1. 提升了代碼的維護型
  2. 提供了代碼的複用性
  3. 讓類與類之間產生了關係, 是多態的前提

6.5 this 和 super 分別是什麼，他們各自的應用場景是什麼？

  • this
    表明的是本類對象的引用 , 誰調用我這個方法,這個方法裏邊的this就表明誰。通常的使用場景是,當局部變量隱藏了成員變量的時候,咱們可使用this去明確指定要訪問的是成員變量

  • super
    表明的是父類存儲空間的一個標誌(能夠理解爲父類對象的引用),咱們可使用super來訪問父類的成員

6.6 什麼是方法重寫？須要注意哪些問題？

方法重寫：指子類中出現了和父類中如出一轍的方法聲明，也被稱爲方法覆蓋，方法複寫

須要注意的問題：

1. 父類中私有方法不能被重寫
2. 子類重寫父類方法時，訪問權限不能更低
3. 父類靜態方法，子類也必須經過靜態方法進行重寫。（其實這個算不上方法重寫，可是現象確實如此）

6.7 方法重寫和重載有什麼區別？

  • 重載Overload
    表示同一個類中能夠有多個名稱相同的方法，但這些方法的參數列表各不相同(即參數個數或類型不一樣),與返回值類型無關。
  • 重寫Override
    發生在子父類中的一個現象, 子類中出現了和父類中如出一轍的方法,與返回值有關.

6.8 什麼是多態,多態的前提是什麼?

一種事物在不一樣時刻表現出來的狀態就是多態

多態的前提：

  • 須要有繼承
  • 須要有方法重寫(其實沒有也是能夠的,可是沒有意義)，不一樣狀態的表現就是就是靠方法重寫體現的
  • 須要有父類的引用指向子類對象：Fu f = new 子類()

6.9 多態中成員(成員變量,成員方法,靜態成員方法)的訪問特色是什麼?

  • 訪問成員變量
    編譯看左邊 , 運行看左邊

    由於成員變量其實就是屬性,屬性就是隻該事物的描述信息,因此使用父類在訪問的時候,訪問的就是父類的成員變量

  • 成員方法
    編譯看左邊,運行看右邊

    這個是多態的本質,存在動態綁定的機制

  • 靜態成員方法
    編譯看左邊,運行看左邊

    因此說靜態算不上重寫

6.10 多態的好處?

  1. 提供了代碼的維護性(經過繼承保證)
  2. 提供了代碼的擴展性(經過多態保證),這個特色也體現了多態的最多見的應用,做爲參數傳遞.

6.11 多態的弊端是什麼,若是咱們想訪問子類的特有的功能咱們應該怎麼辦?

多態的弊端,不能訪問子類中特有的功能
若是咱們還想使用子類中特有的功能,咱們須要使用向下轉型

向下轉型: 就是將父類的引用強制轉換成子類的引用,在向下轉型的過程當中須要注意一個異常: ClassCastException

7. Java 容器

7.1 數組有幾種建立的方式？分別是什麼？

2種。動態建立和靜態建立。

7.2 請簡述集合和數組的異同點？

集合：

  • 能夠存儲不一樣類型的元素(一般使用存儲一種類型元素)
  • 集合的長度能夠改變

數組：

  • 必須存儲相同一類型的元素
  • 數組的長度固定

7.3 迭代器Iterator是什麼？怎麼使用？有什麼特色？

Iterator 接口提供遍歷任何 Collection 的接口。咱們能夠從一個 Collection 中使用迭代器方法來獲取迭代器實例。迭代器取代了 Java 集合框架中的 Enumeration，迭代器容許調用者在迭代過程當中移除元素。

Iterator 使用代碼以下：

List<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
while(it.hasNext()){
  String obj = it.next();
  System.out.println(obj);
}

Iterator的特色是更加安全，由於它能夠確保，在當前遍歷的集合元素被更改的時候，就會拋出 ConcurrentModificationException 異常。

7.4 請簡述常見的數據結構有哪些？

  • 線性表
  • 鏈表
  • 棧
  • 隊列
  • 樹
  • 哈希表

7.5 請簡述ArrayList、Vector、LinkedList三者的特色？

ArrayList

底層數組結構

  • 特色
    • 線程不一樣步
    • 效率高
    • 元素查找快
    • 增刪慢；

Vector

底層數組結構

  • 特色
    • 線程同步
    • 安全
    • 元素查找快
    • 增刪慢

LinkedList

底層鏈表結構

  • 特色
    • 線程不一樣步
    • 效率高
    • 元素增刪快
    • 查找慢

7.6 請簡述ArrayList、Vector、LinkedList，分別在何時使用？

線程安全

Vector

非線程安全

  • 查找多
    ArrayList
  • 增刪多
    LinkedList

7.7 請簡述併發修改異常產生的緣由？如何解決？

異常

ConcurrentModificationException

在迭代器迭代的過程當中，集合中的元素個數發生了改變，此時致使併發修改異常。

解決方式

  1. 經過列表迭代器自帶的方法完成元素增刪操做。
  2. 經過for循環遍歷集合，使用集合中的方法完成元素增刪操做。

7.8 請簡述List<? extends T>和List<? super T>之間有什麼區別？

  • List<? extends T>
    向下限制
    ? extends T ： 表明接收的泛型類型爲T類型或T子類類型
  • List<? super T>
    向上限制
    ? super T ：表明接收的泛型類型爲T類型或T父類類型

7.9 請簡述Set集合的特色？

  1. 不能存儲重複元素；
  2. 元素是按照某種排序規則存儲的

7.10 請簡述HashSet是如何保證元素惟一性的?

HashSet集合中存儲的元素，經過重寫hashCode() 與 equals()方法來保證元素惟一性

7.11 請簡述TreeSet是如何保證元素惟一性與排序的？

  1. 實現天然排序接口 Comparable，重寫 compareTo(T t)方法
  2. 實現比較器排序接口 Comparator，重寫 compare(T t1, T t2)方法

7.12 請說明Map接口和Collection接口的區別

Map接口是雙列集合頂層接口，每一個位置存儲一對元素(key, value)
Collection接口是單列集合頂層接口，每一個位置存儲一個元素

7.13 請說出Map集合的遍歷方式

  1. 鍵找值
  2. 鍵值對對象，找鍵，找值

7.14 請說明HashMap和Hashtable的區別

  • HashMap
    • 線程不一樣步
    • 效率高
    • 能夠存儲null鍵null值
  • Hashtable
    • 線程同步
    • 數據安全
    • 不能夠存儲null鍵null值

7.15 請解釋Collection與Collections的區別

  • Collection
    單列集合的頂層接口，包含集合中經常使用的方法。
  • Collections
    集合工具類，包含獲取集合最大元素值、集合排序等方法。

7.16 Java 容器都有哪些？

Java 容器分爲 Collection 和 Map 兩大類，其下又有不少子類，以下所示：

  • Collection
  • List
    • ArrayList
    • LinkedList
    • Vector
    • Stack
  • Set
    • HashSet
    • LinkedHashSet
    • TreeSet
  • Map
    • HashMap
    • LinkedHashMap
    • TreeMap
    • ConcurrentHashMap
    • Hashtable

7.17 List、Set、Map 之間的區別是什麼？

List、Set、Map 的區別主要體如今兩個方面：元素是否有序、是否容許元素重複。

三者之間的區別，以下表：

7.18 如何決定使用 HashMap 仍是 TreeMap？

對於在 Map 中插入、刪除、定位一個元素這類操做，HashMap 是最好的選擇，由於相對而言 HashMap 的插入會更快，但若是你要對一個 key 集合進行有序的遍歷，那 TreeMap 是更好的選擇。

7.19 說一下 HashMap 的實現原理？

HashMap 基於 Hash 算法實現的，咱們經過 put(key,value)存儲，get(key)來獲取。當傳入 key 時，HashMap 會根據 key. hashCode() 計算出 hash 值，根據 hash 值將 value 保存在 bucket 裏。當計算出的 hash 值相同時，咱們稱之爲 hash 衝突，HashMap 的作法是用鏈表和紅黑樹存儲相同 hash 值的 value。當 hash 衝突的個數比較少時，使用鏈表不然使用紅黑樹。

7.20 說一下 HashSet 的實現原理？

HashSet 是基於 HashMap 實現的，HashSet 底層使用 HashMap 來保存全部元素，所以 HashSet 的實現比較簡單，相關 HashSet 的操做，基本上都是直接調用底層 HashMap 的相關方法來完成，HashSet 不容許重複的值。

7.21 如何實現數組和 List 之間的轉換？

  • 數組轉 List
    使用 Arrays.asList(array) 進行轉換。

  • List 轉數組
    使用 List 自帶的 toArray() 方法。

  • 代碼示例：

    // list to array
List<String> list = new ArrayList<String>();
list.add("這個");
list.add("小程序");
list.add("很贊");
list.toArray();

// array to list
String[] array = new String[]{"這個","小程序","很贊"};
Arrays.asList(array);

7.22 Array 和 ArrayList 有何區別？

  • Array 能夠存儲基本數據類型和對象，ArrayList 只能存儲對象。
  • Array 是指定固定大小的，而 ArrayList 大小是自動擴展的。
  • Array 內置方法沒有 ArrayList 多，好比 addAll、removeAll、iteration 等方法只有 ArrayList 有。

7.23 在 Queue 中 poll()和 remove()有什麼區別？

  • 相同點：都是返回第一個元素，並在隊列中刪除返回的對象。

  • 不一樣點：若是沒有元素 poll()會返回 null，而 remove()會直接拋出 NoSuchElementException 異常。

  • 代碼示例：

    Queue<String> queue = new LinkedList<String>();
queue.offer("string"); // add
System.out.println(queue.poll());
System.out.println(queue.remove());
System.out.println(queue.size());

7.24 Iterator 和 ListIterator 有什麼區別？

  • Iterator 能夠遍歷 Set 和 List 集合，而 ListIterator 只能遍歷 List。
  • Iterator 只能單向遍歷，而 ListIterator 能夠雙向遍歷（向前/後遍歷）。
  • ListIterator 從 Iterator 接口繼承，而後添加了一些額外的功能，好比添加一個元素、替換一個元素、獲取前面或後面元素的索引位置。

7.25 怎麼確保一個集合不能被修改？

可使用 Collections.unmodifiableCollection(Collection c) 方法來建立一個只讀集合，這樣改變集合的任何操做都會拋出 Java. lang. UnsupportedOperationException 異常。

示例代碼以下：

List<String> list = new ArrayList<>();
list. add("x");
Collection<String> clist = Collections.unmodifiableCollection(list);
clist.add("y"); // 運行時此行報錯
System.out.println(list.size());

8. Java 異常

8.1 請說說什麼是異常？異常的分類？

  • 什麼是異常？
    Java異常是java提供的用於處理程序中錯誤的一種機制。
    所謂錯誤是指在程序運行的過程當中發生的一些異常事件（如：除0錯誤，數組下標越界，所要讀取的文件不存在）。設計良好地程序應該在程序異常發生時提供處理這些錯誤的方法，使得程序不會由於異常的發送而阻斷或產生不可預見的結果。

    Java程序的執行過程當中如出現異常事件，能夠生成一個異常類對象，該異常對象封裝了異常事件的信息，並將被提交給java運行時系統，這個過程稱爲拋出異常。

    當java運行時系統接收到異常對象時，會尋找能處理這一異常的代碼並把當前異常對象交其處理，這一過程稱爲捕獲異常。

  • 異常的分類

    • Exception
      全部異常類的父類，其子類對應了各類各樣的可能出現的異常事件，通常須要用戶顯示的聲明或捕獲。
    • Error
      稱爲錯誤，由java虛擬機生成並拋出，包括動態連接失敗，虛擬機錯誤等，程序對其不作處理。
    • Runtime Exception
      一類特殊的異常，如被0除、數組下標超範圍等，其產生比較頻繁，處理麻煩，若是顯示的聲明或捕獲將會對程序可讀性和運行效率影響很大。所以由系統自動檢測並將它們交給缺省的異常處理程序（用戶可沒必要對其處理）。

8.2 請說出異常處理的方式？

  • 捕獲異常

    try{

}catch(XxxException e){

}finally{

}

  • 拋出異常

    throw \ throws()

  • 異常五個關鍵字

    • try
      try{…}語句制定了一段代碼，這段代碼就是一次捕獲並處理異常的範圍。在執行過程當中，這段代碼可能會產生並拋出一種或幾種類型的異常對象，它後面的catch語句要分別對這些異常作相應的處理。若是沒有異常發生，全部的catch代碼段都被略過不執行。
    • catch
      在catch語句塊中是對異常進行處理的代碼，每一個try語句塊能夠伴隨一個或多個catch語句，用於處理可能產生的不一樣類型的異常對象。在catch中聲明的異常對象（catch(XxxException e)）封裝了異常事件發生的信息，在catch語句塊中可使用這個對象的一些方法獲取這些信息。
    • finally
      finally語句爲異常處理提供一個統一的出口，使得在控制流程轉到程序的其餘部分之前，可以對程序的狀態作統一的管理。不管try所指定的程序塊中是否拋出異常，finally所指定的代碼都要執行。一般在finally語句中能夠進行資源的清除工做。
    • throw
      throws關鍵字一般被應用在聲明方法時，用來指定可能拋出的異常。多個異常可使用逗號隔開。當在主函數中調用該方法時，若是發生異常，就會將異常拋給指定異常對象。
    • throws
      throw關鍵字一般用在方法體中，而且拋出一個異常對象。程序在執行到throw語句時當即中止，它後面的語句都不執行。一般throw拋出異常後，若是想在上一級代碼中捕獲並處理異常，則須要在拋出異常的方法中使用throws關鍵字在方法聲明中指定要拋出的異常；若是要捕獲throw拋出的異常，則必須使用try{}catch{}語句。

8.3 請說說編譯期異常和運行期異常的區別？

  • 編譯時異常
    程序正確，但由於外在的環境條件不知足引起。對商用軟件系統，程序開發者必須考慮並處理這類異常。Java編譯器強制要求處理這類異常，若是不捕獲這類異常，程序將不能被編譯。
  • 運行期異常
    這意味着程序存在bug，如數組越界，0被除，傳入參數不知足規則等，這類異常須要更改程序來避免，java編譯器強制要求處理這類異常。
  • 錯誤
    通常不多見，也很難經過程序解決。它可能源於程序的bug，但通常更可能源於環境問題，如內存耗盡。錯誤在程序中無須處理，而由運行環境處理。

8.4 請說說throws與throw的區別？

  • throws
    一般被應用在聲明方法時，用來指定可能拋出的異常。多個異常可使用逗號隔開。當在主函數中調用該方法時，若是發生異常，就會將異常拋給指定異常對象。
  • throw
    一般用在方法體中，而且拋出一個異常對象。程序在執行到throw語句時當即中止，它後面的語句都不執行。一般throw拋出異常後，若是想在上一級代碼中捕獲並處理異常，則須要在拋出異常的方法中使用throws關鍵字在方法聲明中指定要拋出的異常；若是要捕獲throw拋出的異常，則必須使用try{}catch{}語句。

8.5 請說說final、finally與finalize的區別？

  • final
    用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。內部類要訪問局部變量，局部變量必須定義成final類型。
  • finally
    是異常處理語句結構的一部分，表示老是執行。
  • finalize
    是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，能夠覆蓋此方法提升垃圾收集時的其餘資源回收，例如關閉文件等。JVM不保證此方法總被調用。

8.6 請說說異常的注意事項及如何使用異常處理？

  1. 子類重寫父類方法時，子類的方法必須拋出相同的異常或父類異常的子類。
  2. 若是父類拋出了多個異常，子類重寫父類時，只能拋出相同的異常或者是他的子集，子類不能拋出父類沒有的異常。
  3. 若是被重寫的方法沒有異常拋出，那麼子類的方法絕對不能夠拋出異常，若是子類方法內有異常發生，那麼子類只能try…catch，不能throws

8.7 請說出最多見到的RuntimeException異常

  • NullPointerException
    空指針引用異常
  • ClassCastException
    類型強制轉換異常
  • IllegalArgumentException
    傳遞非法參數異常
  • ArithmeticException
    算術運算異常
  • ArrayStoreException
    向數組中存放與聲明類型不兼容對象異常
  • IndexOutOfBoundsException
    下標越界異常
  • NumberFormatException
    數字格式異常

8.8 請簡述IO流的分類

  • 字節流
    • 字節輸入流 InputStream
    • 字節輸出流 OutputStream
  • 字符流
    • 字符輸入流 Reader
    • 字符輸出流 Writer

9. Java IO

9.1 請簡述字符編碼是什麼？請說出常見字符編碼表？

  • 字符編碼是什麼？
    字符編碼（英語：Character encoding）也稱字集碼，是把字符集中的字符編碼爲指定集合中某一對象，以便文本在計算機中存儲和經過通訊網絡的傳遞。常見的例子包括將拉丁字母表編碼成摩斯電碼和ASCII。其中，ASCII將字母、數字和其餘符號編號，並用7比特的二進制來表示這個整數。一般會額外使用一個擴充的比特，以便以1個字節的方式存儲。
  • 常見的字符編碼表以下
    • ASCII
    • GB2312
      是一個簡體中文字符集，由6763個經常使用漢字和682個全角的非漢字字符組成。
    • GBK
      GBK編碼標準兼容GB2312，共收錄漢字21003個、符號883個，並提供1894個造字碼位，簡、繁體字融於一庫
    • GB18030
      是在GBK基礎上增長了一部分漢字
      Big5：在臺灣、香港與澳門地區，使用的是繁體中文字符集
    • Unicode
      將世界上全部的符號都歸入其中，不管是英文、日文、仍是中文等，你們都使用這個編碼表，這樣就利於同一的管理,在這個編碼表中每個字符佔兩個字節
    • UTF-8
      爲了提升Unicode的編碼效率，因而就出現了UTF-8編碼。UTF-8能夠根據不一樣的符號自動選擇編碼的長短。好比英文字母能夠只用1個字節就夠了。

9.2 請說出學習過的IO流中的經常使用方法？

  • 字節輸入流 InputStream
    • read()
      讀取一個字節
    • read(byte[])
      讀取一個字節數組
  • 字節輸出流
    • write(int)
      寫入一個字節
    • write(byte[])
      寫入一個字節數組
  • 字符輸入流
    • read()
      讀取一個字符
    • read(char[])
      讀取一個字符數組
  • 字符緩衝輸入流
    • readLine()
      讀取一行字符串
  • 字符輸出流
    • write(int)
      寫入一個字符
    • write(char[])
      寫入一個字符數組
    • write(String)
      寫入一個字符串
  • 字符緩衝輸出流
    • newLine()
      寫入一個換行符

9.3 請說出轉換流OutputStreamWriter與InputStreamReader 的做用？

  • OutputStreamWriter
    使用編碼表對字節流的數據進行編碼
  • InputStreamReader
    使用編碼表對字節流中的數據進行解碼

9.4 請簡述打印流(PrintStream、PrintWriter)的特色？

  • PrintStream的特色
    在OutputStream基礎之上提供了加強的功能，便可以方便地輸出各類類型的數據（而不只限於byte類型）的格式化表示形式。PrintStream的方法從不拋出IOException
  • PrintWriter的特色
    提供了PrintStream的全部打印方法，其方法也從不拋出IOException。
  • 區別
    做爲處理流使用時，PrintStream只能封裝OutputStream類型的字節流，而PrintWriter既能夠封裝OutputStream類型的字節流，還可以封裝Writer類型的字符輸出流並加強其功能。

9.5 BIO、NIO、AIO 有什麼區別？

  • BIO
    Block IO 同步阻塞式 IO，就是咱們日常使用的傳統 IO，它的特色是模式簡單使用方便，併發處理能力低。
  • NIO
    New IO 同步非阻塞 IO，是傳統 IO 的升級，客戶端和服務器端經過 Channel（通道）通信，實現了多路複用。
  • AIO
    Asynchronous IO 是 NIO 的升級，也叫 NIO2，實現了異步非堵塞 IO ，異步 IO 的操做基於事件和回調機制。

9.6 Files的經常使用方法都有哪些？

  • Files.exists()：檢測文件路徑是否存在。
  • Files.createFile()：建立文件。
  • Files.createDirectory()：建立文件夾。
  • Files.delete()：刪除一個文件或目錄。
  • Files.copy()：複製文件。
  • Files.move()：移動文件。
  • Files.size()：查看文件個數。
  • Files.read()：讀取文件。
  • Files.write()：寫入文件。

感謝您的點贊、評論、關注；
您還能夠掃碼關注「公衆號」獲取粉絲福利。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程