1、請你說一下什么是面向對象？
Java是面向對象的編程語言，不同于C語言是面向過程的。對于面向對象和面向過程的區別，舉一個簡單的例子說明一下（我們以洗衣機洗衣服為例）：
面向過程：面向過程的編程方式，程序會將要完成的某一個任務拆解成一系列的小步驟 (函數)，如：
-
① 打開洗衣機：
method01() -
② 放入要洗的衣服：
method02() -
③ 放入洗衣服：
method03() -
④ 清洗：
method04() -
⑤ 烘干：
method05()
面向對象：面向對象的編程方式，程序會將要完成的洗衣機洗衣服的任務拆分成如下兩個對象：
-
人(
Person)：Person在洗衣機洗衣服這個程序任務中有三個作用，分別是打開洗衣機、放入要洗的衣服、放入洗衣粉。 -
洗衣機(
Machine)：Machine在洗衣機洗衣服這個程序任務中有兩個作用，分別是清洗、烘干。
從上面這個例子能看出，面向過程的編程方式比較直接且高效，而面向對象的編程方式更易復用、擴展和維護！
2、請你簡述一下面向對象的三個基本特征？
繼承：承是Java中面向對象最顯著的一個特征，繼承是從已有的類中派生出新的類，新的類可以吸收已有的屬性、行為，并擴展新的能力。Java中不支持多繼承，但是接口可以支持多實現。
封裝：將同一類事物的特征和功能包裝在一起，只對外暴露需要調用的接口。封裝也稱為信息的隱藏，在Java中接口是體現封裝最常用的方法，在接口中我們沒有任何功能的實現(具體實現都交給實現類)，只是定義了一系列抽象的方法聲明用于外部調用。
多態：封裝和繼承都是為多態來服務的，多態是指同一個行為具有多個不同的表現形式。在Java中方法的重載和重寫是實現多態的2種方式。
重載發生在一個類中，同名的方法如果有不同的參數列表（參數類型不同、參數個數不同或者二者都不同）則視為重載。方法重載體現了編譯時的多態性。
- 重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，重載對返回類型沒有特殊的要求。方法重寫體現了運行時的多態性。
- 多態的三要素：繼承 、重寫、父類指向子類引用！
3、為什么說 Java 是一種半解釋半編譯的程序設計語言呢？
什么是編譯形語言，什么又是解釋形語言？
- 編譯型語言：把做好的源程序全部編譯成二進制代碼的可運行程序。然后，就可以直接運行這個程序。執行速度快，效率高，依靠編譯器，跨平臺性稍差。
- 解釋型語言：把已經做好的源程序，翻譯一句，執行一句，直到結束。執行速度慢，效率低，依靠編譯器，但是跨平臺性稍好。
那么為什么說Java 是編譯型語言呢？
第一個觀點認為 Java 是編譯型語言，因為Java程序想要運行，那么第一步就是要使用Javac進行編譯(將Java源文件編譯成.class二進制文件)。沒有經過編譯的.java文件，是沒辦法運行的！
那么為什么又說Java 是解釋型語言呢？
那么第二個觀點則是認為Java是解釋型語言，Java經過編譯，Javac 將.java源文件編譯成.class二進制文件之后，仍然需要借助 JVM 的解釋執行。
綜合上面兩個觀點來看，Java似乎既有編譯型語言的特點，又有解釋型語言的特點，也沒有看到哪本權威的書籍上認定Java就是哪一種類型的語言。
4、請你說一下Java中的8大基本類型是那些？
如圖所示：
8種基本數據類型和取值范圍：
| 基本類型 | 大小(位/bit) | 字節數(byte) | 最小值 | 最大值 | 默認值 | 包裝器類型 |
|---|---|---|---|---|---|---|
| boolean | - | - | false | true | false | Boolean |
| char | 16 bits | 2 bytes | Unicode 0 | Unicode 2^16-1 | 空 | Character |
| byte | 8 bits | 1 byte | -2^7 | 2^7-1 | 0 | Byte |
| short | 16 bits | 2 bytes | -2~15 | 2^15-1 | 0 | Short |
| int | 32 bits | 4 bytes | -2^31 | 2^31-1 | 0 | Integer |
| long | 64 bits | 8 bytes | -2^63 | 2^63-1 | 0 | Long |
| float | 32 bits | 4 bytes | 0.0 | Fload | ||
| double | 64 bits | 8 bytes | 0.0 | Double |
注意：對于boolean值，在Java規范中并沒有給出其儲存大小，在《Java虛擬機規范》中給出了4個字節，和boolean數組1個字節的定義，具體還要看虛擬機實現是否按照規范來，所以1個字節、4個字節都是有可能的。除了void之外，其他8種基本數據類型被稱為八大基本數據類型。
圖中從左向右的轉換都是隱式轉換，無需再代碼中進行強制轉換。從右向左均要進行強制類型轉換，才能通過編譯。強制轉換會丟失精度。
5、請你講講抽象類和接口有什么區別?
(一) 繼承方面：
- 抽象類只能單繼承；而接口可以多實現；
(二) 成員屬性方面：
- 抽象類中可以有普通屬性，也可以有常量；
-
接口中的成員變量全部默認是常量，使用
public static final修飾，這個可以省略不寫;
(三) 代碼塊方面：
- 抽象類可以含初始化塊；接口不能含初始化塊;
(四) 構造函數方面：
- 抽象類可以有構函數，但是這里的構造函數不是用來創建對象的，而且用來被實現類調用進行初始化操作的;
- 接口不能有構造函數;
(五) 方法方面：
- 接口在JDK1.8之后可以定義抽象方法(無方法體)、default 修飾的默認方法(有方法體)、static修飾的靜態方法(有方法體)，
JDK1.8以前是只能有抽象方法。
- public interface Test {
- static void test() {
- }
- default void test2(){
- }
- void test3();// 默認是abstract修飾
- }
抽象類中除了靜態方法和抽象方法外還可以有普通方法。
二者相同之處
- 接口與抽象類都不能被實例化，需要被其他進行實現或繼承。
- 接口與抽象類里面都能包含抽象方法，實現接口或繼承抽象類的子類都必須實現這些抽象方法。
6、請判斷當一個對象被當作參數傳遞給一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞?
是值傳遞。java 編程語言只有值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的。
java中只有值傳遞，基本類型傳遞的是值的副本，引用類型傳遞的是引用的副本
7、請你說一下JVM/JRE/JDK的區別？
直接看一張圖就可以理解他們的區別了：
- JVM = Java虛擬機
- JRE = JVM + 基礎類庫
- JDK = JVM + 基礎類庫 + 編譯工具
8、請你說一下方法重載和方法重寫的區別？
重載：方法重載發生在同一個類中，重載的方法之間方法名必須相同，參數列表不同（參數的類型、參數的個數），方法的返回值和訪問修飾符可以不同，發生在編譯時期（方法重載實現了編譯時多態）。
重寫：方法重寫發生在子父類中，子類重寫父類的方法，方法名稱必須相同，參數列表也必須相同，方法的返回值小于等于父類方法的返回值，訪問修飾符方位大于等于父類方法（如果父類方法修飾符為private，則子類就無法重寫了）。
9、請你說一下List接口和Set接口的區別？
-
List：有序、可重復集合。按照對象插入的順尋保存數據，允許多個Null元素對象，可以使用iterator迭代器遍歷，也可以使用get(int index)方法獲取指定下標元素。 -
Set：無序、不可重復集合只允許有一個Null元素對象，取元素時，只能使用iterator迭代器逐一遍歷。 -
Map： key-value 鍵值對形式的集合，添加或獲取元素時，需要通過key來檢索到value。
Collecttion 集合體系結構簡圖：
10、為什么重寫了equals()方法還需要重寫hashCode()方法？
equals()只是判斷對象屬性是否相同，hashCode()要判斷二者地址是否相同。java中如果要判斷兩個對象是否相等，需要同時滿足地址 + 屬性都相同!
-
如果兩個對象相同（即：用
equals()比較返回true），那么它們的hashCode值一定要相同； -
如果兩個對象的
hashCode相同，它們并不一定相同；
舉例子：
只重寫 equals() 方法，不重寫 hashcode() 方法：
- public class Student {
- private String name;
- private int age;
- public Student(String name, int age) {
- super();
- this.name = name;
- this.age = age;
- }
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Student other = (Student) obj;
- if (age != other.age)
- return false;
- if (name == null) {
- if (other.name != null)
- return false;
- } else if (!name.equals(other.name))
- return false;
- return true;
- }
- // 省略 get，set方法...
- }
執行下面的程序看看效果：
- public class hashTest {
- @Test
- public void test() {
- Student stu1 = new Student("Jimmy",24);
- Student stu2 = new Student("Jimmy",24);
- System.out.println("兩位同學是同一個人嗎？"+stu1.equals(stu2));
- System.out.println("stu1.hashCode() = "+stu1.hashCode());
- System.out.println("stu1.hashCode() = "+stu2.hashCode());
- }
- }
如果重寫了 equals() 而未重寫 hashcode() 方法，可能就會出現兩個沒有關系的對象 equals 相同（因為equals都是根據對象的特征進行重寫的），但 hashcode 不相同的情況。因為此時 Student 類的 hashcode() 方法就是 Object 默認的 hashcode()方 法，由于默認的 hashcode()方法是根據對象的內存地址經哈希算法得來的，所以 stu1 != stu2，故兩者的 hashcode 值不一定相等。
根據 hashcode 的規則，兩個對象相等其 hash 值一定要相等，矛盾就這樣產生了。上面我們已經解釋了為什么要使用 hashcode 算法，所以即使字面量相等，但是產生兩個不同的 hashCode 值顯然不是我們想要的結果。
如果我們在重寫 equals() 時，也重寫了 hashCode() 方法：
- public class Student {
- private String name;
- private int age;
- public Student(String name, int age) {
- super();
- this.name = name;
- this.age = age;
- }
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + age;
- result = prime * result + ((name == null) ? 0 : name.hashCode());
- return result;
- }
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- Student other = (Student) obj;
- if (age != other.age)
- return false;
- if (name == null) {
- if (other.name != null)
- return false;
- } else if (!name.equals(other.name))
- return false;
- return true;
- }
- // 省略 get，set方法...
- }
再來看執行結果：
- 兩位同學是同一個人嗎？true
- stu1.hashCode() = 71578563
- stu1.hashCode() = 71578563
從 Student 類重寫后的 hashcode() 方法中可以看出，重寫后返回的新的 hash 值與 Student 的兩個屬性是有關，這樣就確保了對象和對象地址之間的關聯性。
總結
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注我們的更多內容！
原文鏈接：https://csp1999.blog.csdn.net/article/details/117168128
