1、面向物件的特征有哪些方面？
面向物件的特征主要有以下幾個方面：
抽象：抽象是將一類物件的共同特征總結出來構造類的程序，包括資料抽象和行為抽象兩方面，抽象只關注物件有哪些屬性和行為，并不關注這些行為的細節是什么，
繼承：繼承是從已有類得到繼承資訊創建新類的程序，提供繼承資訊的類被稱為父類（超類、基類）；得到繼承資訊的類被稱為子類（派生類），繼承讓變化中的軟體系統有了一定的延續性，同時繼承也是封裝程式中可變因素的重要手段（如果不能理解請閱讀閻宏博士的《Java 與模式》或《設計模式精解》中關于橋梁模式的部分），
封裝：通常認為封裝是把資料和操作資料的方法系結起來，對資料的訪問只能通過已定義的介面，面向物件的本質就是將現實世界描繪成一系列完全自治、封閉的物件，我們在類中撰寫的方法就是對實作細節的一種封裝；我們撰寫一個類就是對資料和資料操作的封裝，可以說，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的編程介面（可以想想普通洗衣機和全自動洗衣機的差別，明顯全自動洗衣機封裝更好因此操作起來更簡單；我們現在使用的智能手機也是封裝得足夠好的，因為幾個按鍵就搞定了所有的事情），
多型性：多型性是指允許不同子型別的物件對同一訊息作出不同的回應，簡單的說就是用同樣的物件參考呼叫同樣的方法但是做了不同的事情，多型性分為編譯時的多型性和運行時的多型性，如果將物件的方法視為物件向外界提供的服務，那么運行時的多型性可以解釋為：當 A 系統訪問 B 系統提供的服務時，B系統有多種提供服務的方式，但一切對 A 系統來說都是透明的（就像電動剃須刀是 A 系統，它的供電系統是 B 系統，B 系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A 系統只會通過 B 類物件呼叫供電的方法，但并不知道供電系統的底層實作是什么，究竟通過何種方式獲得了動力），方法多載（overload）實作的是編譯時的多型性（也稱為前系結），而方法重寫（override）實作的是運行時的多型性（也稱為后系結），運行時的多型是面向物件最精髓的東西，要實作多型需要做兩件事：
1). 方法重寫（子類繼承父類并重寫父類中已有的或抽象的方法）；
2). 物件造型（用父型別參考參考子型別物件，這樣同樣的參考呼叫同樣的方法就會根據子類物件的不同而表現出不同的行為），
2、訪問修飾符 public,private,protected,以及不寫（默認）時的區別？
類的成員不寫訪問修飾時默認為 default，默認對于同一個包中的其他類相當于公開（public），對于不是同一個包中的其他類相當于私有（private），受保護（protected）對子類相當于公開，對不是同一包中的沒有父子關系的類相當于私有，Java 中，外部類的修飾符只能是 public 或默認，類的成員（包括內部類）的修飾符可以是以上四種，
3、String 是最基本的資料型別嗎？
不是，Java 中的基本資料型別只有 8 個 ：byte、short、int、long、float、double、char、boolean；除了基本型別（primitive type），剩下的都是參考型別（referencetype），Java 5 以后引入的列舉型別也算是一種比較特殊的參考型別，
4、float f=3.4;是否正確？
不正確，3.4 是雙精度數，將雙精度型（double）賦值給浮點型（float）屬于下轉型（down-casting，也稱為窄化）會造成精度損失，因此需要強制型別轉換float f =(float)3.4; 或者寫成 float f =3.4F;，
5、short s1 = 1; s1 = s1 + 1;有錯嗎?short s1 = 1; s1 += 1;有錯嗎？
對于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 型別，因此 s1+1 運算結果也是 int型，需要強制轉換型別才能賦值給 short 型，而 short s1 = 1; s1 += 1;可以正確編譯，因為 s1+= 1;相當于 s1 = (short(s1 + 1);其中有隱含的強制型別轉換，
6、Java 有沒有 goto？
goto 是 Java 中的保留字，在目前版本的 Java 中沒有使用，（根據 James Gosling（Java 之父）撰寫的《The Java Programming Language》一書的附錄中給出了一個 Java 關鍵字串列，其中有goto 和 const，但是這兩個是目前無法使用的關鍵字，因此有些地方將其稱之為保留字，其實保留字這個詞應該有更廣泛的意義，因為熟悉 C 語言的程式員都知道，在系統類別庫中使用過的有特殊意義的但詞或單詞的組合都被視為保留字）
7、int 和 Integer 有什么區別？
Java 是一個近乎純潔的面向物件編程語言，但是為了編程的方便還是引入了基本資料型別，但是為了能夠將這些基本資料型別當成物件操作，Java 為每一個基本資料型別都引入了對應的包裝型別（wrapper class），int 的包裝類就是 Integer，從 Java 5 開始引入了自動裝箱/拆箱機制，使得二者可以相互轉換，
Java 為每個原始型別提供了包裝型別：
原始型別: boolean，char，byte，short，int，long，float，double
包裝型別：Boolean，Character，Byte，Short，Integer，Long，Float，Double
class AutoUnboxingTest { public static void main(String[] args) { Integer a = new Integer(3); Integer b = 3; // 將 3 自動裝箱成 Integer 型別 int c = 3; System.out.println(a == b); // false 兩個參考沒有參考同一對 象 System.out.println(a == c); // true a 自動拆箱成 int 型別再和 c 比較 } }
最近還遇到一個面試題，也是和自動裝箱和拆箱有點關系的，代碼如下所示：
public class Test03 { public static void main(String[] args) { Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150; System.out.println(f1 == f2); System.out.println(f3 == f4); } }
如果不明就里很容易認為兩個輸出要么都是 true 要么都是 false，首先需要注意的是 f1、f2、f3、f4 四個變數都是 Integer 物件參考，所以下面的==運算比較的不是值而是參考，裝箱的本質是什么呢？當我們給一個 Integer 物件賦一個 int 值的時候，會呼叫 Integer 類的靜態方法 valueOf，如果看 valueOf 的源代碼就知道發生了什么，
public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); }
IntegerCache 是 Integer 的內部類，其代碼如下所示：
1 /** 2 * Cache to support the object identity semantics of autoboxing for 3 values between 4 * -128 and 127 (inclusive) as required by JLS. 5 * 6 * The cache is initialized on first usage. The size of the cache 7 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} 8 option. 9 * During VM initialization, java.lang.Integer.IntegerCache.high 10 property 11 * may be set and saved in the private system properties in the 12 * sun.misc.VM class. 13 */ 14 private static class IntegerCache { 15 static final int low = -128; 16 static final int high; 17 static final Integer cache[]; 18 static { 19 // high value may be configured by property 20 int h = 127; 21 String integerCacheHighPropValue = https://www.cnblogs.com/hwtnet/p/22 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); 23 if (integerCacheHighPropValue != null) { 24 try { 25 int i = parseint(integerCacheHighPropValue); 26 i = Math.max(i, 127); 27 // Maximum array size is Integer.MAX_VALUE 28 h = Math.min(i, Integer.MAX_VALUE - (-low) -1); 29 } 30 catch( NumberFormatException nfe) { 31 // If the property cannot be parsed into an int, 32 ignore it. 33 } 34 } 35 high = h; 36 cache = new Integer[(high - low) + 1]; 37 int j = low; 38 for (int k = 0; k < cache.length; k++) 39 cache[k] = new Integer(j++); 40 // range [-128, 127] must be interned (JLS7 5.1.7) 41 assert IntegerCache.high >= 127; 42 } 43 private IntegerCache() { 44 } 45 }
簡單的說，如果整型字面量的值在-128 到 127 之間，那么不會 new 新的 Integer物件，而是直接參考常量池中的 Integer 物件，所以上面的面試題中 f1f4 的結果是 false，提醒：越是貌似簡單的面試題其中的玄機就越多，需要面試者有相當深厚的功力，
8、&和&&的區別？
&運算子有兩種用法：(1)按位與；(2)邏輯與，&&運算子是短路與運算，邏輯與跟短路與的差別是非常巨大的，雖然二者都要求運算子左右兩端的布林值都是true 整個運算式的值才是 true，&&之所以稱為短路運算是因為，如果&&左邊的運算式的值是 false，右邊的運算式會被直接短路掉，不會進行運算，很多時候我們可能都需要用&&而不是&，例如在驗證用戶登錄時判定用戶名不是 null 而且不是空字串，應當寫為：username != null &&!username.equals(“”)，二者的順序不能交換，更不能用&運算子，因為第一個條件如果不成立，根本不能進行字串的 equals 比較，否則會生 NullPointerException 例外，注意：邏輯或運算子（|）和短路或運算子（||）的差別也是如此，
9、解釋記憶體中的堆疊(stack)、堆(heap)和方法區(method area)的用法，
通常我們定義一個基本資料型別的變數，一個物件的參考，還有就是函式呼叫的現場保存都使用 JVM 中的堆疊空間；而通過 new 關鍵字和構造器創建的物件則放在堆空間，堆是垃圾收集器管理的主要區域，由于現在的垃圾收集器都采用分代收集演算法，所以堆空間還可以細分為新生代和老生代，再具體一點可以分為 Eden、Survivor（又可分為 From Survivor 和 To Survivor）、Tenured；方法區和堆都是各個執行緒共享的記憶體區域，用于存盤已經被 JVM 加載的類資訊、常量、靜態變數、JIT 編譯器編譯后的代碼等資料；程式中的字面量（literal）如直接書寫的 100、”hello”和常量都是放在常量池中，常量池是方法區的一部分，，堆疊空間操作起來最快但是堆疊很小，通常大量的物件都是放在堆空間，堆疊和堆的大小都可以通過 JVM的啟動引數來進行調整，堆疊空間用光了會引發 StackOverflowError，而堆和常量池空間不足則會引發 OutOfMemoryError，
String str = new String("hello");
上面的陳述句中變數 str 放在堆疊上，用 new 創建出來的字串物件放在堆上，而”hello”這個字面量是放在方法區的，
補充 1：較新版本的 Java（從 Java 6 的某個更新開始）中，由于 JIT 編譯器的發展和”逃逸分析”技術的逐漸成熟，堆疊上分配、標量替換等優化技術使得物件一定分配在堆上這件事情已經變得不那么絕對了，
補充 2：運行時常量池相當于 Class 檔案常量池具有動態性，Java 語言并不要求常量一定只有編譯期間才能產生，運行期間也可以將新的常量放入池中，String類的 intern()方法就是這樣的，
看看下面代碼的執行結果是什么并且比較一下 Java 7 以前和以后的運行結果是否一致，
String s1 = new StringBuilder("go").append("od").toString(); System.out.println(s1.intern() == s1); String s2 = new StringBuilder("ja").append("va").toString(); System.out.println(s2.intern() == s2);
10、Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？
Math.round(11.5)的回傳值是 12，Math.round(-11.5)的回傳值是-11，四舍五入的原理是在引數上加 0.5 然后進行下取整，
11、switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上？
在 Java 5 以前，switch(expr)中，expr 只能是 byte、short、char、int，從 Java5 開始，Java 中引入了列舉型別，expr 也可以是 enum 型別，從 Java 7 開始，expr 還可以是字串（String），但是長整型（long）在目前所有的版本中都是不可以的，
12、用最有效率的方法計算 2 乘以 8？
2 << 3（左移 3 位相當于乘以 2 的 3 次方，右移 3 位相當于除以 2 的 3 次方），
補充：我們為撰寫的類重寫 hashCode 方法時，可能會看到如下所示的代碼，其實我們不太理解為什么要使用這樣的乘法運算來產生哈希碼（散列碼），而且為什么這個數是個素數，為什么通常選擇 31 這個數？前兩個問題的答案你可以自己百度一下，選擇 31 是因為可以用移位和減法運算來代替乘法，從而得到更好的性能，說到這里你可能已經想到了：31 * num 等價于(num << 5) - num，左移 5位相當于乘以 2 的 5 次方再減去自身就相當于乘以 31，現在的 VM 都能自動完成這個優化，
public class PhoneNumber { private int areaCode; private String prefix; private String lineNumber; @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + areaCode; result = prime * result + ((lineNumber == null) ? 0 : lineNumber.hashCode()); result = prime * result + ((prefix == null) ? 0 : prefix.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; PhoneNumber other = (PhoneNumber) obj; if (areaCode != other.areaCode) return false; if (lineNumber == null) { if (other.lineNumber != null) return false; } else if (!lineNumber.equals(other.lineNumber)) return false; if (prefix == null) { if (other.prefix != null) return false; } else if (!prefix.equals(other.prefix)) return false; return true; } }
13、陣列有沒有 length()方法？String 有沒有 length()方法？
陣列沒有 length()方法 ，有 length 的屬性，String 有 length()方法，JavaScript中，獲得字串的長度是通過 length 屬性得到的，這一點容易和 Java 混淆，
14、在 Java 中，如何跳出當前的多重嵌套回圈？
在最外層回圈前加一個標記如 A，然后用 break A;可以跳出多重回圈，（Java 中支持帶標簽的 break 和 continue 陳述句，作用有點類似于 C 和 C++中的 goto 陳述句，但是就像要避免使用 goto 一樣，應該避免使用帶標簽的 break 和 continue，因為它不會讓你的程式變得更優雅，很多時候甚至有相反的作用，所以這種語法其實不知道更好）
15、構造器（constructor）是否可被重寫（override）？
構造器不能被繼承，因此不能被重寫，但可以被多載，
16、兩個物件值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對？
不對，如果兩個物件 x 和 y 滿足 x.equals(y) == true，它們的哈希碼（hash code）應當相同，Java 對于 eqauls 方法和 hashCode 方法是這樣規定的：
(1)如果兩個物件相同（equals 方法回傳 true），那么它們的 hashCode 值一定要相同；
(2)如果兩個物件的 hashCode 相同，它們并不一定相同，當然，你未必要按照要求去做，但是如果你違背了上述原則就會發現在使用容器時，相同的物件可以出現在 Set 集合中，同時增加新元素的效率會大大下降（對于使用哈希存盤的系統，如果哈希碼頻繁的沖突將會造成存取性能急劇下降），
補充：關于 equals 和 hashCode 方法，很多 Java 程式都知道，但很多人也就是僅僅知道而已，在 Joshua Bloch 的大作《Effective Java》（很多軟體公司，《Effective Java》、《Java 編程思想》以及《重構：改善既有代碼質量》是 Java程式員必看書籍，如果你還沒看過，那就趕緊去買一本吧）中是這樣介紹equals 方法的：首先 equals 方法必須滿足自反性（x.equals(x)必須回傳 true）、
對稱性（x.equals(y)回傳 true 時，y.equals(x)也必須回傳 true）、傳遞性（x.equals(y)和 y.equals(z)都回傳 true 時，x.equals(z)也必須回傳 true）和一致性（當 x 和 y 參考的物件資訊沒有被修改時，多次呼叫 x.equals(y)應該得到同樣的回傳值），而且對于任何非 null 值的參考 x，x.equals(null)必須回傳 false，
實作高質量的 equals 方法的訣竅包括：
(1) 使用==運算子檢查”引數是否為這個物件的參考”；
(2) 使用 instanceof 運算子檢查”引數是否為正確的型別”；
(3) 對于類中的關鍵屬性，檢查引數傳入物件的屬性是否與之相匹配；
(4) 撰寫完 equals方法后，問自己它是否滿足對稱性、傳遞性、一致性；
(5) 重寫 equals 時總是要重寫 hashCode；
(6) 不要將 equals 方法引數中的 Object 物件替換為其他的型別，在重寫時不要忘掉@Override 注解，
17、是否可以繼承 String 類？
String 類是 final 類，不可以被繼承，
補充：繼承 String 本身就是一個錯誤的行為，對 String 型別最好的重用方式是關聯關系（Has-A）和依賴關系（Use-A）而不是繼承關系（Is-A），
18、當一個物件被當作引數傳遞到一個方法后，此方法可改變這個物件的屬性，并可回傳變化后的結果，那么這里到底是值傳遞還是參考傳遞？
是值傳遞，Java 語言的方法呼叫只支持引數的值傳遞，當一個物件實體作為一個引數被傳遞到方法中時，引數的值就是對該物件的參考，物件的屬性可以在被呼叫程序中被改變，但對物件參考的改變是不會影響到呼叫者的，C++和 C#中可以通過傳參考或傳輸出引數來改變傳入的引數的值，在 C#中可以撰寫如下所示的代碼，但是在 Java 中卻做不到，
說明：Java 中沒有傳參考實在是非常的不方便，這一點在 Java 8 中仍然沒有得到改進，正是如此在 Java 撰寫的代碼中才會出現大量的 Wrapper 類（將需要通過方法呼叫修改的參考置于一個 Wrapper 類中，再將 Wrapper 物件傳入方法），這樣的做法只會讓代碼變得臃腫，尤其是讓從 C 和 C++轉型為 Java 程式員的開發者無法容忍，
19、String 和 StringBuilder、StringBuffer 的區別？
Java 平臺提供了兩種型別的字串：String 和 StringBuffer/StringBuilder，它們可以儲存和操作字串，其中 String 是只讀字串，也就意味著 String 參考的字串內容是不能被改變的，而 StringBuffer/StringBuilder 類表示的字串物件可以直接進行修改，StringBuilder 是 Java 5 中引入的，它和 StringBuffer 的方法完全相同，區別在于它是在單執行緒環境下使用的，因為它的所有方面都沒有被synchronized 修飾，因此它的效率也比 StringBuffer 要高，
面試題 1 - 什么情況下用+運算子進行字串連接比呼叫
StringBuffer/StringBuilder 物件的 append 方法連接字串性能更好？
面試題 2 - 請說出下面程式的輸出，
class StringEqualTest { public static void main(String[] args) { String s1 = "Programming"; String s2 = new String("Programming"); String s3 = "Program"; String s4 = "ming"; String s5 = "Program" + "ming"; String s6 = s3 + s4; System.out.println(s1 == s2); System.out.println(s1 == s5); System.out.println(s1 == s6); System.out.println(s1 == s6.intern()); System.out.println(s2 == s2.intern()); } }
補充：解答上面的面試題需要清除兩點：
(1)String 物件的 intern 方法會得到字串物件在常量池中對應的版本的參考（如果常量池中有一個字串與 String 物件的 equals 結果是 true），如果常量池中沒有對應的字串，則該字串將被添加到常量池中，然后回傳常量池中字串的參考；
(2)字串的+操作其本質是創建了 StringBuilder 物件進行 append 操作，然后將拼接后的 StringBuilder 物件用toString 方法處理成 String 物件，這一點可以用 javap -c StringEqualTest.class命令獲得 class 檔案對應的 JVM 位元組碼指令就可以看出來，
20、多載（Overload）和重寫（Override）的區別，多載的方法能否根據回傳型別進行區分？
方法的多載和重寫都是實作多型的方式，區別在于前者實作的是編譯時的多型性，而后者實作的是運行時的多型性，多載發生在一個類中，同名的方法如果有不同的引數串列（引數型別不同、引數個數不同或者二者都不同）則視為多載；重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的回傳型別，比父類被重寫方法更好訪問，不能比父類被重寫方法宣告更多的例外（里氏代換原則），多載對回傳型別沒有特殊的要求，
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/5233.html
標籤：其他
上一篇：華為 人工智能 筆經+面經 分享