九阳真经-java基础面试
java基礎
集合
整體框架
?
通用實現
??Iterable（接口）接口是java 集合框架的頂級接口,實現此接口使集合對象可以通過迭代器遍歷自身元素
├Collection（接口）
├List列表（接口）有序的 collection（也稱為序列）,允許重復的元素
?│├LinkedList（實現類）使用雙向鏈表實現存儲，允許所有元素（包括 null）。非線程安全,要保證同步,可以使用List list = Collections.synchronizedList(new LinkedList());進行包裝,可以被當作堆棧和隊列來使用。（雙向鏈表不能用單向鏈表替代，因為單項鏈表是無序的無法保證LinkedList的有序性）
│├ArrayList （實現類） 底層使用的是數組結構,特點:查詢速度快,增刪操作較慢,而且線程不同步.要保證同步,可以使用:List list = Collections.synchronizedList(new ArrayList());進行包裝,默認容量為10.常用方法:add,addAll,remove,indexOf,subList,contains,isEmpty…. 初始容量定義：10 擴容：oldCapacity + (oldCapacity >> 1)，即原集合長度的1.5倍。
?│└Vector也是一個有序集合,允許重復元素,底層動態分配的Object[]數組實現并且線程安全. 初始容量定義：10 擴容：如果擴容因子>0 oldCapacity + 擴容因子，否則按照oldCapacity*2 進行擴容
?│ └Stack（派生類） Stack是繼承于Vector的子類，它主要用來模擬”棧“，因此也具備了peek()、pop()、push()等主要用于棧操作的方法，性能不行。ArrayDeque可以代替
?└Set集（接口） Set是一種沒有重復元素的集合,它所有的方法都是直接繼承自Collection接口,并且添加了一個對重復元素的限制.Set要求強化了equals和hashCode兩個方法,以使Set集合可以對元素進行排序和對比.
(SortedSet和NavigableSet接口)
???? 通用實現
├HashSet通過哈希表存儲元素,它是Set通用類中性能最好的一個,但不保證元素的排序 默認容量 和擴容機制和hashmap一致。
├TreeSet 元素按一定規則排序,所以他的性能要比HashSet差許多.
└LinkedHashSet在HashSet的基礎上,增添了一個鏈表結構,來保證數據的按插入先后存儲有序,因為需要維持一個鏈表,所以它的性能比HashSet稍微差一點,介于HashSet和TreeSet之間.
專用實現
├EnumSet是一個高性能的枚舉類型的Set實現類,其內部元素必須都是相同的枚舉類型.
└CopyOnWriteArraySet是一個支持COW(copy-on-write)機制的集合.CopyOnWriteArraySet對集合的任何修改操作如,add,remove,set時,都會先復制一份,所以在CopyOnWriteArraySet可以安全的并發進行迭代和元素插入刪除操作,不需要同步鎖,實現了讀寫分離,但是讀操作不具備實時性.CopyOnWriteArraySet只適用集合頻繁迭代但很少修改的情景.
Map 映射Map是一個包含鍵值對的集合,一個map不能有重復的鍵(key),而且每個鍵至多只能對應一個值.Map同Collection一樣,它的所有通用實現都會提供一個轉換器構造函數,接收一個Map類型集合,并以此初始化自己,這樣只要是Map的實現都可以相互之間轉換.
（SortedMap和NavigableMap兩個接口）
通用實現
├HashMap? 是線程不安全的實現，且HashMap中可以使用null作為key或者value。
??? ??1、 默認分配到空間是16=2^4 。2、手動為hashmap分配空間的時候 a：空間大小要為2的次冪（可以減少hash沖突，避免一些數組空間永遠不被使用）b：0.75*size > 實際要存儲的元素個數 3、hashmap 會在元素個數達到size*0.75（默人loadFactor）進行擴容。4、擴容的時候舊數組的長度左移一位。
├LinkedHashMap使用一個雙向鏈表來維護key-value對的次序，其也是一個有序的Map集合，順序與key-value對的插入順序保持一致
├TreeMap是一個紅黑樹的結構，每個key-value作為紅黑樹的一個節點。TreeMap也會對key進行排序，也分為自然排序和定制排序兩種
├Hashtable是一個比較古老的Map實現類，它是一個線程安全的Map實現，且不允許使用null作為key和value。由于該類是比較久遠的類，其性能較低，所以現在用的也比較少
HashTable中hash數組默認大小是11，增加的方式是 old*2+1。
?
專用實現
├EnumMap是一個高性能的以枚舉為鍵的Map集合,它內部是以數組實現.EnumMap將Map集合的豐富功能和安全性與數組的快速訪問結合起來,如果想要實現一個用枚舉映射值得結構,應當使用EnumMap
├IdentityHashMap存儲元素時,不使用equal方法比較鍵對象,而是使用==來對比,適用于實現對象拓撲結構轉換,比如對象序列化或深度拷貝時,作為一個”節點表”來跟蹤處理那些已經處理過的對象引用.
├WeakHashMap只存儲弱引用類型的key,當它內部的元素的鍵不再被外界引用時,其鍵值對就可以被垃圾回收期(GC)回收,被從WeakHashMap中移除.WeakHashMap提供最簡單利用弱引用的方
法,這對實現”registry-like”數據結構非常有用.
并發實現
└ConcurrentHashMap是一個高并發高性能的基于哈希表的實現,當檢索元素時永不會阻塞,并且當執行update允許客戶端選定執行并發級別更新.它是HashMap的替代,ConcurrentHashMap除了實現ConcurrentMap還支持HashTable所有遺留的獨有的操作.
?
注：線程安全就是多線程訪問??????????????????????? 時，采用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用。不會出現數據不一致或者數據污染。
線程不安全就是不提供數據訪問保護，有可能出現多個線程先后更改數據造成所得到的數據是臟數據
散列表（Hash table，也叫哈希表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它通過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫做散列函數，存放記錄的數組叫做散列表。
解決哈希沖突的辦法
1.開放定制法
2.鏈地址法
3.公共溢出區法
建立一個特殊存儲空間，專門存放沖突的數據。此種方法適用于數據和沖突較少的情況。
4.再散列法
準備若干個hash函數，如果使用第一個hash函數發生了沖突，就使用第二個hash函數，第二個也沖突，使用第三個……
?
細說 HashMap
?
?
還有一個條件是存儲的元素大于64
?
?
?
?
?
?
?
通過 鏈地址法解決散列沖突的實現方式 ，發生沖突之后在數據上加一個指針
指向下一個結點
四種訪問權限
| 訪問權限 | 本類 | 本包的類 | 子類 | 非子類的外包類 |
| public | 是 | 是 | 是 | 是 |
| protected | 是 | 是 | 是 | 否 |
| default | 是 | 是 | 否 | 否 |
| private | 是 | 否 | 否 | 否 |
?
四種引用類型
所以在 JDK.1.2 之后，Java 對引用的概念進行了擴充，將引用分為了：強引用（Strong Reference）、軟引用（Soft Reference）、弱引用（Weak Reference）、虛引用（Phantom Reference）4 種，這 4 種引用的強度依次減弱。
一，強引用
Java中默認聲明的就是強引用，比如：
Object obj = new Object(); //只要obj還指向Object對象，Object對象就不會被回收 obj = null;? //手動置null只要強引用存在，垃圾回收器將永遠不會回收被引用的對象，哪怕內存不足時，JVM也會直接拋出OutOfMemoryError，不會去回收。如果想中斷強引用與對象之間的聯系，可以顯示的將強引用賦值為null，這樣一來，JVM就可以適時的回收對象了
二，軟引用
軟引用是用來描述一些非必需但仍有用的對象。在內存足夠的時候，軟引用對象不會被回收，只有在內存不足時，系統則會回收軟引用對象，如果回收了軟引用對象之后仍然沒有足夠的內存，才會拋出內存溢出異常。這種特性常常被用來實現緩存技術，比如網頁緩存，圖片緩存等。
在 JDK1.2 之后，用java.lang.ref.SoftReference類來表示軟引用。
下面以一個例子來進一步說明強引用和軟引用的區別：
在運行下面的Java代碼之前，需要先配置參數 -Xms2M -Xmx3M，將 JVM 的初始內存設為2M，最大可用內存為 3M。
首先先來測試一下強引用，在限制了 JVM 內存的前提下，下面的代碼運行正常
| public class TestOOM { ??? ????public static void main(String[] args) { ???????? testStrongReference(); ??? } ??? private static void testStrongReference() { ??????? // 當 new byte為 1M 時，程序運行正常 ??????? byte[] buff = new byte[1024 * 1024 * 1]; ??? } } 但是如果我們將 byte[] buff = new byte[1024 * 1024 * 1];替換為創建一個大小為 2M 的字節數組 byte[] buff = new byte[1024 * 1024 * 2]; ? |
則內存不夠使用，程序直接報錯，強引用并不會被回收
接著來看一下軟引用會有什么不一樣，在下面的示例中連續創建了 10 個大小為 1M 的字節數組，并賦值給了軟引用，然后循環遍歷將這些對象打印出來。
| public class TestOOM { ??? private static List<Object> list = new ArrayList<>(); ??? public static void main(String[] args) { ???????? testSoftReference(); ??? } ??? private static void testSoftReference() { ??????? for (int i = 0; i < 10; i++) { ??????????? byte[] buff = new byte[1024 * 1024]; ??????????? SoftReference<byte[]> sr = new SoftReference<>(buff); ??????????? list.add(sr); ??????? } ??????? ????????System.gc(); //主動通知垃圾回收 ??????? ????????for(int i=0; i < list.size(); i++){ ??????????? Object obj = ((SoftReference) list.get(i)).get(); ??????????? System.out.println(obj); ??????? } ??????? ????} ??? } ? |
打印結果：
我們發現無論循環創建多少個軟引用對象，打印結果總是只有最后一個對象被保留，其他的obj全都被置空回收了。
這里就說明了在內存不足的情況下，軟引用將會被自動回收。
值得注意的一點 , 即使有 byte[] buff 引用指向對象, 且 buff 是一個strong reference, 但是 SoftReference sr 指向的對象仍然被回收了，這是因為Java的編譯器發現了在之后的代碼中, buff 已經沒有被使用了, 所以自動進行了優化。
如果我們將上面示例稍微修改一下：
| ? private static void testSoftReference() { ??????? byte[] buff = null; ? ??????? for (int i = 0; i < 10; i++) { ??????????? buff = new byte[1024 * 1024]; ??????????? SoftReference<byte[]> sr = new SoftReference<>(buff); ??????????? list.add(sr); ??????? } ? ??????? System.gc(); //主動通知垃圾回收 ??????? ????????for(int i=0; i < list.size(); i++){ ??????????? Object obj = ((SoftReference) list.get(i)).get(); ??????????? System.out.println(obj); ??????? } ? ??????? System.out.println("buff: " + buff.toString()); ??? } ? |
則 buff 會因為強引用的存在，而無法被垃圾回收，從而拋出OOM的錯誤。
如果一個對象惟一剩下的引用是軟引用，那么該對象是軟可及的（softly reachable）。垃圾收集器并不像其收集弱可及的對象一樣盡量地收集軟可及的對象，相反，它只在真正 “需要” 內存時才收集軟可及的對象。
三，弱引用
弱引用的引用強度比軟引用要更弱一些，無論內存是否足夠，只要 JVM 開始進行垃圾回收，那些被弱引用關聯的對象都會被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 來表示弱引用。
我們以與軟引用同樣的方式來測試一下弱引用：
| ?? private static void testWeakReference() { ??????? for (int i = 0; i < 10; i++) { ??????????? byte[] buff = new byte[1024 * 1024]; ??????????? WeakReference<byte[]> sr = new WeakReference<>(buff); ??????????? list.add(sr); ??????? } ??????? ????????System.gc(); //主動通知垃圾回收 ??????? ????????for(int i=0; i < list.size(); i++){ ??????????? Object obj = ((WeakReference) list.get(i)).get(); ??????????? System.out.println(obj); ??????? } ??? } ? |
?
?打印結果：
?
可以發現所有被弱引用關聯的對象都被垃圾回收了。
四，虛引用
虛引用是最弱的一種引用關系，如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，它隨時可能會被回收，在 JDK1.2 之后，用 PhantomReference 類來表示，通過查看這個類的源碼，發現它只有一個構造函數和一個 get() 方法，而且它的 get() 方法僅僅是返回一個null，也就是說將永遠無法通過虛引用來獲取對象，虛引用必須要和 ReferenceQueue 引用隊列一起使用。
| public class PhantomReference<T> extends Reference<T> { ??? /** ???? * Returns this reference object's referent.? Because the referent of a ???? * phantom reference is always inaccessible, this method always returns ???? * <code>null</code>. ???? * ???? * @return? <code>null</code> ???? */ ??? public T get() { ??????? return null; ??? } ??? public PhantomReference(T referent, ReferenceQueue<? super T> q) { ??????? super(referent, q); ??? } } ? |
那么傳入它的構造方法中的 ReferenceQueue 又是如何使用的呢？
五，引用隊列（ReferenceQueue）
引用隊列可以與軟引用、弱引用以及虛引用一起配合使用，當垃圾回收器準備回收一個對象時，如果發現它還有引用，那么就會在回收對象之前，把這個引用加入到與之關聯的引用隊列中去。程序可以通過判斷引用隊列中是否已經加入了引用，來判斷被引用的對象是否將要被垃圾回收，這樣就可以在對象被回收之前采取一些必要的措施。
與軟引用、弱引用不同，虛引用必須和引用隊列一起使用。
?
字符串拼接
原理分析
1.加號拼接
打開編譯后的字節碼我們可以發現加號拼接字符串jvm底層其實是調用StringBuilder來實現的，也就是說”a” + “b”等效于下面的代碼片。
?
| String a = "a"; StringBuilder sb = new StringBuilder(); sb.append(a).append("b"); String str = sb.toString(); ? |
?
?
?
但并不是說直接用“+”號拼接就可以達到StringBuilder的效率了，因為用“+”號每拼接一次都會新建一個StringBuilder對象，并且最后toString()方法還會生成一個String對象。在循環拼接十萬次的時候，就會生成十萬個StringBuilder對象，十萬個String對象，這簡直就是噩夢。
?
2.concat拼接
concat的源代碼如下，可以看到，concat其實就是申請一個char類型的buf數組，將需要拼接的字符串都放在這個數組里，最后再轉換成String對象。
| ? public String concat(String str) { ??????? int otherLen = str.length(); ??????? if (otherLen == 0) { ??????????? return this; ??????? } ??????? int len = value.length; ??????? char buf[] = Arrays.copyOf(value, len + otherLen); ??????? str.getChars(buf, len); ??????? return new String(buf, true); ??? } ? |
?
???
?
3.StringBuilder/StringBuffer
這兩個類實現append的方法都是調用父類AbstractStringBuilder的append方法，只不過StringBuffer是的append方法加了sychronized關鍵字，因此是線程安全的。append代碼如下，他主要也是利用char數組保存字符，通過ensureCapacityInternal方法來保證數組容量可用還有擴容。
?
| public AbstractStringBuilder append(String str) { ??????? if (str == null) ??????????? return appendNull(); ??????? int len = str.length(); ??????? ensureCapacityInternal(count + len); ??????? str.getChars(0, len, value, count); ??????? count += len; ??????? return this; ??? } ? |
他擴容的方法的代碼如下，可見，當容量不夠的時候，數組容量右移1位（也就是翻倍）再加2，以前的jdk貌似是直接寫成int newCapacity = (value.length * 2) + 2，后來優化成了右移，可見，右移的效率還是比直接乘更高的。
?
| private int newCapacity(int minCapacity) { ??????? // overflow-conscious code ??????? int newCapacity = (value.length << 1) + 2; ??????? if (newCapacity - minCapacity < 0) { ??????????? newCapacity = minCapacity; ??????? } ??????? return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0) ??????????? ? hugeCapacity(minCapacity) ??????????? : newCapacity; } ? |
原因分析
1.循環拼接字符串
通過實驗我們發現，在循環拼接同一個字符串的時候，他們效率的按快慢排序是
StringBulider > StringBuffer >> String.concat > “+”。
StringBulider比StringBuffer更快這個容易理解，因為StringBuffer的方法是sychronized修飾的，同步的時候會損耗掉一些性能。StringBulider和String.concat的區別，主要在擴容上，String.concat是需要多少擴多少，而StringBulider是每次翻兩倍，指數級擴容。在10萬次拼接中，String.concat需要擴容10萬次，而StringBuilder只需要擴容log100000次（大約17次），除此之外，concat每次都會生成一個新的String對象，而StringBuilder則不必，那StringBuilder如此快就不難解釋了。至于直接用“+”號連接，之前已經說了，它會產生大量StringBuilder和String對象，當然就最慢了。
2.大量字符串拼接
在只拼接少量字符串的情況下的時候，他們效率的按快慢排序是
String.concat > StringBulider > StringBuffer > “+”。
為什么在拼接少量字符串的時候，String.concat就比StringBuilder快了呢，原因大致有兩點，一是StringBuilder的調用棧更深，二是StringBuilder產生的垃圾對象更多，并且它重寫的toString方法為了做到不可變性采用了“保護性拷貝”，因此效率不如concat。
?
StringBuilder和StringBuffer的初始容量都是16,程序猿盡量手動設置初始值。以避免多次擴容所帶來的性能問題；
StringBuilder和StringBuffer的擴容機制是這種：首先試著將當前數組容量count擴充為2*count+2，如果2*count+2<count+str.length() 則擴充為count+ str.length()
內置數據類型
Java語言提供了八種基本類型。六種數字類型（四個整數型，兩個浮點型），一種字符類型，還有一種布爾型。
byte：
- byte 數據類型是8位、有符號的，以二進制補碼表示的整數；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默認值是 0；
- byte 類型用在大型數組中節約空間，主要代替整數，因為 byte 變量占用的空間只有 int 類型的四分之一；
- 例子：byte a = 100，byte b = -50。
short：
- short 數據類型是 16 位、有符號的以二進制補碼表示的整數
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 數據類型也可以像 byte 那樣節省空間。一個short變量是int型變量所占空間的二分之一；
- 默認值是 0；
- 例子：short s = 1000，short r = -20000。
int：
- int 數據類型是32位、有符號的以二進制補碼表示的整數；
- 最小值是 -2,147,483,648（-2^31）；
- 最大值是 2,147,483,647（2^31 - 1）；
- 一般地整型變量默認為 int 類型；
- 默認值是 0 ；
- 例子：int a = 100000, int b = -200000。
long：
- long 數據類型是 64 位、有符號的以二進制補碼表示的整數；
- 最小值是 -9,223,372,036,854,775,808（-2^63）；
- 最大值是 9,223,372,036,854,775,807（2^63 -1）；
- 這種類型主要使用在需要比較大整數的系統上；
- 默認值是 0L；
- 例子： long a = 100000L，Long b = -200000L。
"L"理論上不分大小寫，但是若寫成"l"容易與數字"1"混淆，不容易分辯。所以最好大寫。
float：
- float 數據類型是單精度、32位、符合IEEE 754標準的浮點數；
- float 在儲存大型浮點數組的時候可節省內存空間；
- 默認值是 0.0f；
- 浮點數不能用來表示精確的值，如貨幣；
- 例子：float f1 = 234.5f。
double：
- double 數據類型是雙精度、64 位、符合IEEE 754標準的浮點數；
- 浮點數的默認類型為double類型；
- double類型同樣不能表示精確的值，如貨幣；
- 默認值是 0.0d；
- 例子：double d1 = 123.4。
boolean：
- boolean數據類型表示一位的信息；
- 只有兩個取值：true 和 false；
- 這種類型只作為一種標志來記錄 true/false 情況；
- 默認值是 false；
- 例子：boolean one = true。
char：
- char類型是一個單一的 16 位 Unicode 字符；
- 最小值是 \u0000（即為0）；
- 最大值是 \uffff（即為65,535）；
- char 數據類型可以儲存任何字符；
淺拷貝
我們看如下這段代碼：
轉存失敗重新上傳取消
| package com.ys.test;
? public class Person implements Cloneable{ ??? public String pname; ??? public int page; ??? public Address address; ??? public Person() {} ??? ????public Person(String pname,int page){ ??????? this.pname = pname; ??????? this.page = page; ??????? this.address = new Address(); ??? } ??? ????@Override ??? protected Object clone() throws CloneNotSupportedException { ??????? return super.clone(); ??? } ??? ????public void setAddress(String provices,String city ){ ??????? address.setAddress(provices, city); ??? } ??? public void display(String name){ ??????? System.out.println(name+":"+"pname=" + pname + ", page=" + page +","+ address); ? ??}
? ??? public String getPname() { ??????? return pname; ??? }
? ??? public void setPname(String pname) { ??????? this.pname = pname; ??? }
? ??? public int getPage() { ??????? return page; ??? }
? ??? public void setPage(int page) { ??????? this.page = page; ??? } ??? } 轉存失敗重新上傳取消 轉存失敗重新上傳取消 package com.ys.test; ? public class Address { ??? private String provices; ??? private String city; ??? public void setAddress(String provices,String city){ ??????? this.provices = provices; ??????? this.city = city; ??? } ??? @Override ??? public String toString() { ??????? return "Address [provices=" + provices + ", city=" + city + "]"; ??? } ??? }轉存失敗重新上傳取消 ? |
這是一個我們要進行賦值的原始類 Person。下面我們產生一個 Person 對象，并調用其 clone 方法復制一個新的對象。
注意：調用對象的 clone 方法，必須要讓類實現?Cloneable 接口，并且覆寫 clone 方法。
測試：
View Code
打印結果為：
首先看原始類 Person 實現?Cloneable 接口，并且覆寫 clone 方法,它還有三個屬性，一個引用類型 String定義的 pname，一個基本類型 int定義的 page，還有一個引用類型 Address ，這是一個自定義類，這個類也包含兩個屬性 pprovices 和 city 。
接著看測試內容，首先我們創建一個Person 類的對象 p1，其pname 為zhangsan,page為21，地址類 Address 兩個屬性為 湖北省和武漢市。接著我們調用 clone() 方法復制另一個對象 p2，接著打印這兩個對象的內容。
從第 1 行和第 3 行打印結果:
p1:com.ys.test.Person@349319f9
p2:com.ys.test.Person@258e4566
可以看出這是兩個不同的對象。
從第 5 行和第 6 行打印的對象內容看，原對象 p1 和克隆出來的對象 p2 內容完全相同。
代碼中我們只是更改了克隆對象 p2 的屬性 Address 為湖北省荊州市（原對象 p1 是湖北省武漢市） ，但是從第 7 行和第 8 行打印結果來看，原對象 p1 和克隆對象 p2 的 Address 屬性都被修改了。
也就是說對象 Person 的屬性 Address，經過 clone 之后，其實只是復制了其引用，他們指向的還是同一塊堆內存空間，當修改其中一個對象的屬性 Address，另一個也會跟著變化。
?
淺拷貝：創建一個新對象，然后將當前對象的非靜態字段復制到該新對象，如果字段是值類型的，那么對該字段執行復制；如果該字段是引用類型的話，則復制引用但不復制引用的對象。因此，原始對象及其副本引用同一個對象。
回到頂部
6、深拷貝
弄清楚了淺拷貝，那么深拷貝就很容易理解了。
深拷貝：創建一個新對象，然后將當前對象的非靜態字段復制到該新對象，無論該字段是值類型的還是引用類型，都復制獨立的一份。當你修改其中一個對象的任何內容時，都不會影響另一個對象的內容。
那么該如何實現深拷貝呢？Object 類提供的 clone 是只能實現 淺拷貝的。
回到頂部
7、如何實現深拷貝？
深拷貝的原理我們知道了，就是要讓原始對象和克隆之后的對象所具有的引用類型屬性不是指向同一塊堆內存，這里有三種實現思路。
①、讓每個引用類型屬性內部都重寫clone() 方法
既然引用類型不能實現深拷貝，那么我們將每個引用類型都拆分為基本類型，分別進行淺拷貝。比如上面的例子，Person 類有一個引用類型 Address(其實String 也是引用類型，但是String類型有點特殊，后面會詳細講解)，我們在 Address 類內部也重寫 clone 方法。如下：
Address.class:
| 轉存失敗重新上傳取消 ?1 package com.ys.test; 2 ?3 public class Address implements Cloneable{ 4???? private String provices; 5???? private String city; 6???? public void setAddress(String provices,String city){ 7???????? this.provices = provices; 8???????? this.city = city; 9 ????} 10 ????@Override 11???? public String toString() { 12???????? return "Address [provices=" + provices + ", city=" + city + "]"; 13 ????} 14 ????@Override 15???? protected Object clone() throws CloneNotSupportedException { 16???????? return super.clone(); 17 ????} 18???? 19 }轉存失敗重新上傳取消 Person.class 的 clone() 方法： 轉存失敗重新上傳取消 1 ????@Override 2???? protected Object clone() throws CloneNotSupportedException { 3???????? Person p = (Person) super.clone(); 4???????? p.address = (Address) address.clone(); 5???????? return p; 6???? }? |
轉存失敗重新上傳取消
測試還是和上面一樣，我們會發現更改了p2對象的Address屬性，p1 對象的 Address 屬性并沒有變化。
但是這種做法有個弊端，這里我們Person 類只有一個 Address 引用類型，而 Address 類沒有，所以我們只用重寫 Address 類的clone 方法，但是如果 Address 類也存在一個引用類型，那么我們也要重寫其clone 方法，這樣下去，有多少個引用類型，我們就要重寫多少次，如果存在很多引用類型，那么代碼量顯然會很大，所以這種方法不太合適。
②、利用序列化
| public class Student implements Serializable { ??? private transient String name; ??? private int age; ??? public Student() { ??? } ? ??? public Student(String name, int age) { ??????? this.name = name; ??????? this.age = age; ??? } ? ??? public String getName() { ??????? return name; ??? } ? ??? public void setName(String name) { ??????? this.name = name; ??? } ? ??? public int getAge() { ??????? return age; ??? } ? ??? public void setAge(int age) { ??????? this.age = age; ??? } } |
?
可以將其聲明為?transient，即將其排除在克隆屬性之外。
轉存失敗重新上傳取消
| //深度拷貝 public Object deepClone() throws Exception{ ??? // 序列化 ??? ByteArrayOutputStream bos = new ByteArrayOutputStream(); ??? ObjectOutputStream oos = new ObjectOutputStream(bos);
? ??? oos.writeObject(this);
? ??? // 反序列化 ??? ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ??? ObjectInputStream ois = new ObjectInputStream(bis);
? ??? return ois.readObject(); } ? |
轉存失敗重新上傳取消
? 因為序列化產生的是兩個完全獨立的對象，所有無論嵌套多少個引用類型，序列化都是能實現深拷貝的。
?
抽象類與接口的區別
區別一：抽象類中可以存在非抽象的方法??????? VS?????? 接口中的方法被默認的變成抽象方法,只要是定義了接口,接口中的方法 就全部變成了抽象類即使你不寫 abstract? 它也是抽象的方法??? (jdk1.8 之后接口增加default 類型的方法可以定義方法體 )
區別二:實現抽象類的方法時, 如果方法是抽象的,子類必須重寫抽象的方法. 如果方法不是抽象的, 子類可以選擇繼承???????? VS?????? 實現了接口 就必須實現接口中的所有方法, 因為接口中的方法默認的全部都是抽象的方法（除非類是抽象類）?
區別三: 抽象類允許非static和非final字段，允許方法是public、private或protected，而接口的字段類型本質上是public的、static的和final的，所有接口方法本質上都是公共的。
區別四:一個類只能繼承一個抽象類???????????????? VS???????? 一個類可以實現多個接口? ,接口可以實現多繼承?? 舉例:interface display extends aa ,bb,cc ...等等??? 然后讓類去實現 display的接口 就可以實現 display aa bb? cc接口
對面向對象的理解
?
在我理解,面向對象是向現實世界模型的自然延伸，這是一種“萬物皆對象”的編程思想。在現實生活中的任何物體都可以歸為一類事物，而每一個個體都是一類事物的實例。面向對象的編程是以對象為中心，以消息為驅動，所以程序=對象+消息。
面向對象有三大特性，封裝、繼承和多態。
封裝就是將一類事物的屬性和行為抽象成一個類，使其屬性私有化，行為公開化，提高了數據的隱秘性的同時，使代碼模塊化。這樣做使得代碼的復用性更高。
是進一步將一類事物共有的屬性和行為抽象成一個父類，而每一個子類是一個特殊的父類--有父類的行為和屬性，也有自己特有的行為和屬性。這樣做擴展了已存在的代碼塊，進一步提高了代碼的復用性。
不同類的對象對同一消息作出不同的響應以及一個類實例（對象）的相同方法在不同情形有不同表現形式 叫做多態 。編譯時多態，方法的重載 --運行時多態，方法的重寫。多態的作用----簡單來說：解藕。詳細點就是，多態是設計模式的基礎(既然是基礎，那么一些設計模式中肯定有多態的下面三個條件)
多態存在的三個條件-----有繼承關系，子類重寫了父類方法，父類引用指向子類對象 Father son = new Son();
如果說封裝和繼承是為了使代碼重用，那么多態則是為了實現接口重用。多態的一大作用就是為了解耦--為了解除父子類繼承的耦合度。
總結一下，如果說封裝和繼承是面向對象的基礎，那么多態則是面向對象最精髓的理論。掌握多態必先了解接口，只有充分理解接口才能更好的應用多態。
?
?
反射
一、什么是JAVA的反射
1、在運行狀態中，對于任意一個類，都能夠知道這個類的屬性和方法。
2、對于任意一個對象，都能夠調用它的任何方法和屬性。
這種動態獲取信息以及動態調用對象的方法的功能稱為JAVA的反射。
二、反射的作用
在JAVA中，只有給定類的名字，就可以通過反射機制來獲取類的所有信息，可以動態的創建對象和編譯。
三、反射的原理
JAVA語言編譯之后會生成一個.class文件，反射就是通過字節碼文件找到某一個類、類中的方法以及屬性等。
反射的實現主要借助以下四個類：
Class：類的對象
Constructor：類的構造方法
Field：類中的屬性對象
Method：類中的方法對象
??? java一個接口可以繼承另外一個接口嗎
一個接口可以繼承多個接口. interface C extends A, B {}是可以的. ? 一個類可以實現多個接口: class D implements A,B,C{} ? 但是一個類只能繼承一個類,不能繼承多個類 class B extends A{} ? 在繼承類的同時,也可以繼承接口: class E extends D implements A,B,C{} 這也正是選擇用接口而不是抽象類的原因static關鍵字
static關鍵字的基本作用，簡而言之，一句話來描述就是：
方便在沒有創建對象的情況下來進行調用（方法/變量）。
類中static部分是發生在類加載時期的，并且只初始化一次。
?
1）static方法
static方法一般稱作靜態方法，由于靜態方法不依賴于任何對象就可以進行訪問，因此對于靜態方法來說，是沒有this的，因為它不依附于任何對象，既然都沒有對象，就談不上this了。并且由于這個特性，在靜態方法中不能訪問類的非靜態成員變量和非靜態成員方法，因為非靜態成員方法/變量都是必須依賴具體的對象才能夠被調用。
2）static變量
static變量也稱作靜態變量，靜態變量和非靜態變量的區別是：靜態變量被所有的對象所共享，在內存中只有一個副本，它當且僅當在類初次加載時會被初始化。而非靜態變量是對象所擁有的，在創建對象的時候被初始化，存在多個副本，各個對象擁有的副本互不影響。
static成員變量的初始化順序按照定義的順序進行初始化。
3）static代碼塊
static關鍵字還有一個比較關鍵的作用就是 用來形成靜態代碼塊以優化程序性能。static塊可以置于類中的任何地方，類中可以有多個static塊。在類初次被加載的時候，會按照static塊的順序來執行每個static塊，并且只會執行一次。
為什么說static塊可以用來優化程序性能，是因為它的特性:只會在類加載的時候執行一次。下面看個例子:
4）static class 靜態類（Java）
一般情況下是不可以用static修飾類的。如果一定要用static修飾類的話，通常static修飾的是匿名內部類。
只有將某個內部類修飾為靜態類，然后才能夠在這個類中定義靜態的成員變量與成員方法。這是靜態內部類都有的一個特性
?
equals()方法與 “=="號 的區別：
1、超類Object的equals()底層原理： ? 在超類Object中有一個equals()的基本方法，源碼如下： ? public boolean equals(Object obj) {?? return (this == obj);???? } ? 實際上我們知道所有的對象都擁有標識（內存地址）和狀態（數據），同時“==”比較的是兩個對象的內存地址，在Object的equals方法底層調用的是==號，所以說Object的equals()方法是比較兩個對象的內存地址是否相等，如果為true，則表示的引用的是同一個對象。 2、equals()與"==" 的區別： ? （1）== 號在比較基本數據類型時比較的是數據的值，而用 == 號比較兩個對象時比較的是兩個對象的地址值； ? （2）equals()不能用于基本的數據類型，對于基本的數據類型要用其包裝類。 ? （3）默認情況下，也就是從Object繼承而來的 equals 方法與 “==” 是完全等價的，比較的都是對象的內存地址，因為底層調用的是 “==” 號，但我們可以重寫equals方法，使其按照我們的需求方式進行比較，如String類重寫equala()方法，使其比較的是字符的內容，而不再是內存地址。 3、equals()的重寫規則： ? 我們在重寫equals方法時，還是需要注意如下幾點規則的。 ? ??? 自反性。對于任何非null的引用值x，x.equals(x)應返回true。 ? ??? 對稱性。對于任何非null的引用值x與y，當且僅當：y.equals(x)返回true時，x.equals(y)才返回true。 ? ??? 傳遞性。對于任何非null的引用值x、y與z，如果y.equals(x)返回true，y.equals(z)返回true，那么x.equals(z)也應返回true。 ? ??? 一致性。對于任何非null的引用值x與y，假設對象上equals比較中的信息沒有被修改，則多次調用x.equals(y)始終返回true或者始終返回false。 ? ??? 對于任何非空引用值x，x.equal(null)應返回false。equals()與hashCode()方法：
1、認識HashCode()方法：
?
hashCode的意思就是散列碼，也就是哈希碼，是由對象導出的一個整型值，散列碼是沒有規律的，如果x與y是兩個不同的對象，那么x.hashCode()與y.hashCode()基本是不會相同的，下面通過String類的hashCode()計算一組散列碼：
?
??? package com.zejian.test;
??? public class HashCodeTest {
??? public static void main(String[] args) {
??? ???? int hash=0;
??? ???? String s="ok";
??? ???? StringBuilder sb =new StringBuilder(s);
??? ????
??? ???? System.out.println(s.hashCode()+"? "+sb.hashCode());
??? ????
??? ???? String t = new String("ok");
??? ???? StringBuilder tb =new StringBuilder(s);
??? ???? System.out.println(t.hashCode()+"? "+tb.hashCode());
??? }
??? }
?
??? 運行結果：
??? 3548? 1829164700
??? 3548? 2018699554
?
我們可以看出，字符串s與t擁有相同的散列碼，這是因為字符串的散列碼是由內容導出的。而字符串緩沖sb與tb卻有著不同的散列碼，這是因為StringBuilder沒有重寫hashCode方法，它的散列碼是由Object類默認的hashCode方法計算出來的對象存儲地址，所以散列碼自然也就不同了。那么我們該如何重寫出一個較好的hashCode方法呢，其實并不難，我們只要合理地組織對象的散列碼，就能夠讓不同的對象產生比較均勻的散列碼。例如下面的例子：
?
??
| package com.zejian.test; ??? public class Model { ??? private String name; ??? private double salary; ??? private int sex; ??? ??? @Override ??? public int hashCode() { ??? ???? return name.hashCode()+new Double(salary).hashCode() ??? ?????????????? + new Integer(sex).hashCode(); ??? } ??? } ? |
?
?
上面的代碼我們通過合理的利用各個屬性對象的散列碼進行組合，最終便能產生一個相對比較好的或者說更加均勻的散列碼，當然上面僅僅是個參考例子而已，我們也可以通過其他方式去實現，只要能使散列碼更加均勻（所謂的均勻就是每個對象產生的散列碼最好都不沖突）就行了。不過這里有點要注意的就是java 7中對hashCode方法做了兩個改進，首先java發布者希望我們使用更加安全的調用方式來返回散列碼，也就是使用null安全的方法Objects.hashCode（注意不是Object而是java.util.Objects）方法，這個方法的優點是如果參數為null，就只返回0，否則返回對象參數調用的hashCode的結果。Objects.hashCode 源碼如下：
?
??? public static int hashCode(Object o) {
??????????? return o != null ? o.hashCode() : 0;
??????? }
?
因此我們修改后的代碼如下：
?
?
| ?? package com.zejian.test; ??? import java.util.Objects; ??? public? class Model { ??? private?? String name; ??? private double salary; ??? private int sex; ??? @Override ??? public int hashCode() { ??? ???? return Objects.hashCode(name)+new Double(salary).hashCode() ??? ?????????????? + new Integer(sex).hashCode(); ??? } ??? } ? |
?
?
java 7還提供了另外一個方法java.util.Objects.hash(Object... objects),當我們需要組合多個散列值時可以調用該方法。進一步簡化上述的代碼：
?
?
| ? package com.zejian.test; ??? import java.util.Objects; ??? public? class Model { ??? private?? String name; ??? private double salary; ??? private int sex; ??? //?? @Override ??? //?? public int hashCode() { ??? //??????? return Objects.hashCode(name)+new Double(salary).hashCode() ??? //???????????????? + new Integer(sex).hashCode(); ??? //?? } ??? ??? @Override ??? public int hashCode() { ??? ???? return Objects.hash(name,salary,sex); ??? } ??? } ? |
?
?
?好了，到此hashCode()該介紹的我們都說了，還有一點要說的，如果我們提供的是一個數組類型的變量的話，那么我們可以調用Arrays.hashCode()來計算它的散列碼，這個散列碼是由數組元素的散列碼組成的。
2、equals()與hashCode()的聯系：
?
Java中的equals()方法和hashCode()方法是Object超類中的，所以每個對象都有這兩個方法的，有時候我們實現特定的需求，可能要重寫這兩個方法，下面介紹一下這兩個方法的作用。
?
equals()和hashCode()方法是用來在同一類中做比較用的，尤其是在容器里如set存放同一類對象時用來判斷放入的對象是否重復。
?
如果兩個對象根據equals()方法比較是相等的，那么調用這兩個對象中任意一個對象的hashCode方法都必須產生同樣的整數結果。
如果兩個對象根據equals()方法比較是不相等的，那么調用這兩個對象中任意一個對象的hashCode方法，則不一定要產生相同的整數結果。
3、hashCode()方法的作用：
?
想要明白Java中hashCode()方法的作用，就必須先知道Java中的集合。下面先通過一個問題逐步說明：
?
如果想查找一個集合中是否包含有某個對象，大概的程序代碼怎樣寫呢？
?
你通常是逐一取出每個元素與要查找的對象進行比較，當發現某個元素與要查找的對象進行equals方法比較的結果相等時，則停止繼續查找并返回肯定的信息，否則，返回否定的信息。如果一個集合中有很多個元素，比如有一萬個元素，并且沒有包含要查找的對象時，則意味著你的程序需要從集合中取出一萬個元素進行逐一比較才能得到結論。
?
這時，有人發明了一種哈希算法來提高從集合中查找元素的效率，這種方式將集合分成若干個存儲區域，每個對象可以計算出一個哈希碼，可以將哈希碼分組(使用不同的hash函數來計算的)，每組分別對應某個存儲區域，根據一個對象的哈希碼就可以確定該對象應該存儲在哪個區域，HashSet就是采用哈希算法存取對象的集合，它內部采用對某個數字n進行取余的方式對哈希碼進行分組和劃分對象的存儲區域；Object類中定義了一個hashCode()方法來返回每個Java對象的哈希碼，當從HashSet集合中查找某個對象時，Java系統首先調用對象的hashCode()方法獲得該對象的哈希碼，然后根據哈希嗎找到相應的存儲區域，最后取得該存儲區域內的每個元素與該對象進行equals方法比較；這樣就不用遍歷集合中的所有元素就可以得到結論，可見，HashSet集合具有很好的對象檢索性能。
?
所以，總結一下，hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap，HashSet等，hashCode是用來在散列存儲結構中確定對象的存儲地址的；
4、為什么重寫equals()的同時要重寫hashCode()方法：
?
在將這個問題的答案之前，我們先了解一下將元素放入集合的流程，如下圖：
?
將對象放入到集合中時，首先判斷要放入對象的hashcode值與集合中的任意一個元素的hashcode值是否相等，如果不相等直接將該對象放入集合中。如果hashcode值相等，然后再通過equals方法判斷要放入對象與集合中的任意一個對象是否相等，如果equals判斷不相等，直接將該元素放入到集合中，否則不放入。回過來說，在get的時候，集合類也先調key.hashCode()算出數組下標，然后看equals()的結果，如果是true就是找到了，否則就是沒找到。
?
以上面的第2節的HashSet為例可知，HashSet集合具有很好的對象檢索性能，但是，HashSet集合存儲對象的效率相對要低些，因為向HashSet集合中添加一個對象時，要先計算出對象的哈希碼和根據這個哈希碼確定對象在集合中的存放位置，為了保證一個類的實例對象能在HashSet正常存儲，要求這個類的兩個實例對象用equals()方法比較的結果相等時，他們的哈希碼也必須相等；也就是說，如果 obj1.equals(obj2) 的結果為true,那么obj1.hashCode() == obj2.hashCode() 表達式的結果也要為true；
?
換句話說：當我們重寫一個對象的equals方法，就必須重寫他的hashCode方法，如果不重寫他的hashCode方法的話，Object對象中的hashCode方法始終返回的是一個對象的hash地址，而不同對象的這個地址是永遠不相等的。所以這時候即使是重寫了equals方法，也不會有特定的效果的，因為hashCode方法如果都不想等的話，就不會調用equals方法進行比較了，所以重寫equals()就沒有意義了。
?
如果一個類的hashCode()方法沒有遵循上述要求，那么，當這個類的兩個實例對象用equals()方法比較的結果相等時，他們本來應該無法被同時存儲進set集合中，但是，如果將他們存儲進HashSet集合中時，由于他們的hashCode()方法的返回值不同(Object中的hashCode方法返回值是永遠不同的)，第二個對象首先按照哈希碼計算可能被放進與第一個對象不同的區域中，這樣，它就不可能與第一個對象進行equals方法比較了，也就可能被存儲進HashSet集合中了；所以，Object類中的hashCode()方法不能滿足對象被存入到HashSet中的要求，因為它的返回值是通過對象的內存地址推算出來的，同一個對象在程序運行期間的任何時候返回的哈希值都是始終不變的，所以，只要是兩個不同的實例對象，即使他們的equals方法比較結果相等，他們默認的hashCode方法的返回值是不同的。
?
接下來，我們就舉幾個小例子測試一下：
?
測試一：覆蓋equals（Object obj）但不覆蓋hashCode（）,導致數據不唯一性。
?
?
| ? public class HashCodeTest {? ??????? public static void main(String[] args) {? ??????????? Collection set = new HashSet();? ??????????? Point p1 = new Point(1, 1);? ??????????? Point p2 = new Point(1, 1);? ????? ??????????? System.out.println(p1.equals(p2));? ??????????? set.add(p1);?? //(1)? ??????????? set.add(p2);?? //(2)? ??????????? set.add(p1);?? //(3)? ????? ??????????? Iterator iterator = set.iterator();? ??????????? while (iterator.hasNext()) {? ??????????????? Object object = iterator.next();? ??????????????? System.out.println(object);? ??????????? }? ??????? }? ??? }? ????? ??? class Point {? ??????? private int x;? ??????? private int y;? ????? ??????? public Point(int x, int y) {? ??????????? super();? ??????????? this.x = x;? ??????????? this.y = y;? ??????? }? ????? ??????? @Override? ??????? public boolean equals(Object obj) {? ??????????? if (this == obj)? ??????????????? return true;? ??????????? if (obj == null)? ??????????????? return false;? ??????????? if (getClass() != obj.getClass())? ??????????????? return false;? ??????????? Point other = (Point) obj;? ??????????? if (x != other.x)? ??????????????? return false;? ??????????? if (y != other.y)? ??????????????? return false;? ??????????? return true;? ??????? }? ????? ??????? @Override? ??????? public String toString() {? ??????????? return "x:" + x + ",y:" + y;? ??????? }? ??? }? ? ??? 輸出結果： ??? true ??? x:1,y:1? ??? x:1,y:1 |
?
?
?
原因分析：
?
（1）當執行set.add(p1)時（1），集合為空，直接存入集合；
?
（2）當執行set.add(p2)時（2），首先判斷該對象（p2）的hashCode值所在的存儲區域是否有相同的hashCode，因為沒有覆蓋hashCode方法，所以jdk使用默認Object的hashCode方法，返回內存地址轉換后的整數，因為不同對象的地址值不同，所以這里不存在與p2相同hashCode值的對象，因此jdk默認不同hashCode值，equals一定返回false，所以直接存入集合。
?
?（3）當執行set.add(p1)時（3），時，因為p1已經存入集合，同一對象返回的hashCode值是一樣的，繼續判斷equals是否返回true，因為是同一對象所以返回true。此時jdk認為該對象已經存在于集合中，所以舍棄。
?
測試二：覆蓋hashCode方法，但不覆蓋equals方法，仍然會導致數據的不唯一性。
?
修改Point類：
| ? ??? class Point {? ??????? private int x;? ??????? private int y;? ????? ??????? public Point(int x, int y) {? ???????? ???super();? ??????????? this.x = x;? ??????????? this.y = y;? ??????? }? ????? ??????? @Override? ??????? public int hashCode() {? ??????????? final int prime = 31;? ??????????? int result = 1;? ??????????? result = prime * result + x;? ??????? ????result = prime * result + y;? ??????????? return result;? ??????? }? ????? ??????? @Override? ??????? public String toString() {? ??????????? return "x:" + x + ",y:" + y;? ??????? }? ????? ??? }? ? ??? 輸出結果： ??? false ??? x:1,y:1? ??? x:1,y:1 ? ? |
?
原因分析：
?
（1）當執行set.add(p1)時（1），集合為空，直接存入集合；
?
（2）當執行set.add(p2)時（2），首先判斷該對象（p2）的hashCode值所在的存儲區域是否有相同的hashCode，這里覆蓋了hashCode方法，p1和p2的hashCode相等，所以繼續判斷equals是否相等，因為這里沒有覆蓋equals，默認使用'=='來判斷，所以這里equals返回false，jdk認為是不同的對象，所以將p2存入集合。
?
?（3）當執行set.add(p1)時（3），時，因為p1已經存入集合，同一對象返回的hashCode值是一樣的，并且equals返回true。此時jdk認為該對象已經存在于集合中，所以舍棄。
?
綜合上述兩個測試，要想保證元素的唯一性，必須同時覆蓋hashCode和equals才行。
?
（注意：在HashSet中插入同一個元素（hashCode和equals均相等）時，會被舍棄，而在HashMap中插入同一個Key（Value 不同）時，原來的元素會被覆蓋。）
5、重寫equals()中 getClass 與 instaceof 的區別：
?
在重寫equals() 方法時，一般都是推薦使用 getClass 來進行類型判斷（除非所有的子類有統一的語義才使用instanceof），不是使用 instanceof。我們都知道 instanceof 的作用是判斷其左邊對象是否為其右邊類的實例，返回 boolean 類型的數據。可以用來判斷繼承中的子類的實例是否為父類的實現。
?
下來我們來看一個例子：父類Person
| ? ??? public class Person { ??????????? protected String name; ??????????? public String getName() { ??????????????? return name; ??????????? } ??????????? public void setName(String name) { ??????????????? this.name = name; ??????????? } ??????????? public Person(String name){ ??????????????? this.name = name; ??????????? } ????? ??????public boolean equals(Object object){ ??????????????? if(object instanceof Person){ ??????????????????? Person p = (Person) object; ??????????????????? if(p.getName() == null || name == null){ ??????????????????????? return false; ?????????????????? ?} ??????????????????? else{ ??????????????????????? return name.equalsIgnoreCase(p.getName ()); ??????????????????? } ??????????????? } ??????????????? return false; ?????????? } ??????? } ? 子類 Employee： ? ??? public class Employee extends Person{ ???????? ???private int id; ??????????? public int getId() { ??????????????? return id; ??????????? } ??????????? public void setId(int id) { ??????????????? this.id = id; ??????????? } ??????????? public Employee(String name,int id){ ??????????????? super(name); ??????????????? this.id = id; ??????????? } ??????????? /** ???????????? * 重寫equals()方法 ???????????? */ ??????????? public boolean equals(Object object){ ??????????????? if(object instanceof Employee){ ??????????????????? Employee e = (Employee) object; ?? ?????????????????return super.equals(object) && e.getId() == id; ??????????????? } ??????????????? return false; ??????????? } ??????? } ? ? |
?
上面父類 Person 和子類 Employee 都重寫了 equals(),不過 Employee 比父類多了一個id屬性,而且這里我們并沒有統一語義。測試代碼如下：
?
??
| public class Test { ??????? ????public static void main(String[] args) { ??????????????? Employee e1 = new Employee("chenssy", 23); ??????????????? Employee e2 = new Employee("chenssy", 24); ??????????????? Person p1 = new Person("chenssy"); ??????????????? System.out.println(p1.equals(e1));//true ??????????????? System.out.println(p1.equals(e2));//true ??????????????? System.out.println(e1.equals(e2));//false ??????????? } ??????? } ? |
?
?
上面代碼我們定義了兩個員工和一個普通人，雖然他們同名，但是他們肯定不是同一人，所以按理來說結果應該全部是 false，但是事與愿違，結果是：true、true、false。對于那 e1!=e2 我們非常容易理解，因為他們不僅需要比較 name,還需要比較 ID。但是 p1 即等于 e1 也等于 e2，這是非常奇怪的，因為 e1、e2 明明是兩個不同的類，但為什么會出現這個情況？首先 p1.equals(e1)，是調用 p1 的 equals 方法，該方法使用 instanceof 關鍵字來檢查 e1 是否為 Person 類，這里我們再看看 instanceof：判斷其左邊對象是否為其右邊類的實例，也可以用來判斷繼承中的子類的實例是否為父類的實現。他們兩者存在繼承關系，肯定會返回 true 了，而兩者 name 又相同，所以結果肯定是 true。所以出現上面的情況就是使用了關鍵字 instanceof，這是非常容易導致我們“鉆牛角尖”。故在覆寫 equals 時推薦使用 getClass 進行類型判斷。而不是使用 instanceof（除非子類擁有統一的語義）。
6、由hashCode()造成的內存泄露問題：
?
???
| package com.weijia.demo; ???? ??? public class RectObject { ??? public int x; ??? public int y; ??? public RectObject(int x,int y){ ??? ???? this.x = x; ??? ???? this.y = y; ??? } ??? @Override ??? public int hashCode(){ ??? ???? final int prime = 31; ??? ???? int result = 1; ??? ???? result = prime * result + x; ??? ???? result = prime * result + y; ??? ???? return result; ??? } ??? @Override ??? public boolean equals(Object obj){ ??? ???? if(this == obj) ??? ????????? return true; ??? ???? if(obj == null) ??? ????????? return false; ??? ???? if(getClass() != obj.getClass()) ??? ????????? return false; ??? ???? final RectObject other = (RectObject)obj; ??? ???? if(x != other.x){ ??? ????????? return false; ??? ???? } ??? ???? if(y != other.y){ ??? ????????? return false; ??? ???? } ??? ???? return true; ??? } ??? } ? ? |
?
?我們重寫了父類Object中的hashCode和equals方法，看到hashCode和equals方法中，如果兩個RectObject對象的x,y值相等的話他們的hashCode值是相等的，同時equals返回的是true;
?
??
| package com.weijia.demo; ??? import java.util.HashSet; ??? public class Demo { ??? public static void main(String[] args){ ??? ???? HashSet<RectObject> set = new HashSet<RectObject>(); ??? ???? RectObject r1 = new RectObject(3,3); ??? ???? RectObject r2 = new RectObject(5,5); ??? ???? RectObject r3 = new RectObject(3,3); ??? ???? set.add(r1); ??? ???? set.add(r2); ??? ???? set.add(r3); ??? ???? r3.y = 7; ??? ???? System.out.println("刪除前的大小size:"+set.size());//3 ??? ???? set.remove(r3); ??? ???? System.out.println("刪除后的大小size:"+set.size());//3 ??? } ??? } ? ??? 運行結果： ??? 刪除前的大小size:3 ??? 刪除后的大小size:3 ? |
?
在這里，我們發現了一個問題，當我們調用了remove刪除r3對象，以為刪除了r3,但事實上并沒有刪除，這就叫做內存泄露，就是不用的對象但是他還在內存中。所以我們多次這樣操作之后，內存就爆了。看一下remove的源碼：??
| ?? public boolean remove(Object o) { ??????????? return map.remove(o)==PRESENT; ??????? } |
?
然后再看一下map的remove方法的源碼：
| ?? public V remove(Object key) { ??????????? Entry<K,V> e = removeEntryForKey(key); ??????????? return (e == null ? null : e.value); ??????? } |
?
再看一下removeEntryForKey方法源碼：
| /** ???????? * Removes and returns the entry associated with the specified key ???????? * in the HashMap.? Returns null if the HashMap contains no mapping ???????? * for this key. ???????? */ ??????? final Entry<K,V> removeEntryForKey(Object key) { ??????????? int hash = (key == null) ? 0 : hash(key); ??????????? int i = indexFor(hash, table.length); ??????????? Entry<K,V> prev = table[i]; ??????????? Entry<K,V> e = prev; ???? ??????????? while (e != null) { ??????????????? Entry<K,V> next = e.next; ??????????????? Object k; ??????????????? if (e.hash == hash && ??????????????????? ((k = e.key) == key || (key != null && key.equals(k)))) { ??????????????????? modCount++; ??????????????????? size--; ??????????????????? if (prev == e) ??????????????????????? table[i] = next; ??????????????????? else ??????????????????????? prev.next = next; ??????????????????? e.recordRemoval(this); ??????????????????? return e; ??????????????? } ??????????????? prev = e; ??????????????? e = next; ??????????? } ???? ??????????? return e; ??? ????} ? |
?
?
我們看到，在調用remove方法的時候，會先使用對象的hashCode值去找到這個對象，然后進行刪除，這種問題就是因為我們在修改了 r3 對象的 y 屬性的值，又因為RectObject對象的hashCode()方法中有y值參與運算,所以r3對象的hashCode就發生改變了，所以remove方法中并沒有找到 r3，所以刪除失敗。即 r3的hashCode變了，但是他存儲的位置沒有更新，仍然在原來的位置上，所以當我們用他的新的hashCode去找肯定是找不到了.
?
上面的這個內存泄露告訴我一個信息：如果我們將對象的屬性值參與了hashCode的運算中，在進行刪除的時候，就不能對其屬性值進行修改，否則會導致內存泄露問題。
7、基本數據類型和String類型的hashCode()方法和equals()方法：
?
其中8中基本類型的hashCode很簡單就是直接返回他們的數值大小，String對象是通過一個復雜的計算方式，但是這種計算方式能夠保證，如果這個字符串的值相等的話，他們的hashCode就是相等的。8種基本類型的equals方法就是直接比較數值，String類型的equals方法是比較字符串的值的。
?
?final?
在java中，final可以用來修飾類，方法和變量（成員變量或局部變量）。下面將對其詳細介紹。
1.1 修飾類
當用final修飾類的時，表明該類不能被其他類所繼承。當我們需要讓一個類永遠不被繼承，此時就可以用final修飾，但要注意：
final類中所有的成員方法都會隱式的定義為final方法。
1.2 修飾方法
使用final方法的原因主要有兩個：
(1) 把方法鎖定，以防止繼承類對其進行更改。
(2) 效率，在早期的java版本中，會將final方法轉為內嵌調用。但若方法過于龐大，可能在性能上不會有多大提升。因此在最近版本中，不需要final方法進行這些優化了。
final方法意味著“最后的、最終的”含義，即此方法不能被重寫。
注意：若父類中final方法的訪問權限為private，將導致子類中不能直接繼承該方法，因此，此時可以在子類中定義相同方法名的函數，此時不會與重寫final的矛盾，而是在子類中重新地定義了新方法。
轉存失敗重新上傳取消
| class A{ ??? private final void getName(){ ? ??? } } ? public class B extends A{ ??? public void getName(){ ? ??? } ? ??? public static void main(String[]args){ ??????? System.out.println("OK"); ??? } } ? |
轉存失敗重新上傳取消
1.3 修飾變量
? final成員變量表示常量，只能被賦值一次，賦值后其值不再改變。類似于C++中的const。
當final修飾一個基本數據類型時，表示該基本數據類型的值一旦在初始化后便不能發生變化；如果final修飾一個引用類型時，則在對其初始化之后便不能再讓其指向其他對象了，但該引用所指向的對象的內容是可以發生變化的。本質上是一回事，因為引用的值是一個地址，final要求值，即地址的值不發生變化。
final修飾一個成員變量（屬性），必須要顯示初始化。這里有兩種初始化方式，一種是在變量聲明的時候初始化；第二種方法是在聲明變量的時候不賦初值，但是要在這個變量所在的類的所有的構造函數中對這個變量賦初值。
?
當函數的參數類型聲明為final時，說明該參數是只讀型的。即你可以讀取使用該參數，但是無法改變該參數的值。
?
?
在java中，String被設計成final類，那為什么平時使用時，String的值可以被改變呢？
字符串常量池是java堆內存中一個特殊的存儲區域，當我們建立一個String對象時，假設常量池不存在該字符串，則創建一個，若存在則直接引用已經存在的字符串。當我們對String對象值改變的時候，例如 String a="A"; a="B" 。a是String對象的一個引用（我們這里所說的String對象其實是指字符串常量），當a=“B”執行時，并不是原本String對象("A")發生改變，而是創建一個新的對象("B")，令a引用它。
2. finally
? finally作為異常處理的一部分，它只能用在try/catch語句中，并且附帶一個語句塊，表示這段語句最終一定會被執行（不管有沒有拋出異常），經常被用在需要釋放資源的情況下。（×）（這句話其實存在一定的問題）
很多人都認為finally語句塊一定會執行，但真的是這樣么？答案是否定的，例如下面這個例子：
?
當我們去掉注釋的三行語句，執行結果為：
? 為什么在以上兩種情況下都沒有執行finally語句呢，說明什么問題？
只有與finally對應的try語句塊得到執行的情況下，finally語句塊才會執行。以上兩種情況在執行try語句塊之前已經返回或拋出異常，所以try對應的finally語句并沒有執行。
但是，在某些情況下，即使try語句執行了，finally語句也不一定執行。例如以下情況：
finally 語句塊還是沒有執行，為什么呢？因為我們在 try 語句塊中執行了 System.exit (0) 語句，終止了 Java 虛擬機的運行。那有人說了，在一般的 Java 應用中基本上是不會調用這個 System.exit(0) 方法的。OK ！沒有問題，我們不調用 System.exit(0) 這個方法，那么 finally 語句塊就一定會執行嗎？
再一次讓大家失望了，答案還是否定的。當一個線程在執行 try 語句塊或者 catch 語句塊時被打斷（interrupted）或者被終止（killed），與其相對應的 finally 語句塊可能不會執行。還有更極端的情況，就是在線程運行 try 語句塊或者 catch 語句塊時，突然死機或者斷電，finally 語句塊肯定不會執行了。可能有人認為死機、斷電這些理由有些強詞奪理，沒有關系，我們只是為了說明這個問題。
?
易錯點
在try-catch-finally語句中執行return語句。我們看如下代碼：
答案：4,4,4? 。? ??為什么呢？
首先finally語句在改代碼中一定會執行，從運行結果來看，每次return的結果都是4（即finally語句），仿佛其他return語句被屏蔽掉了。
事實也確實如此，因為finally用法特殊，所以會撤銷之前的return語句，繼續執行最后的finally塊中的代碼。?
3. finalize
finalize()是在java.lang.Object里定義的，也就是說每一個對象都有這么個方法。這個方法在gc啟動，該對象被回收的時候被調用。其實gc可以回收大部分的對象（凡是new出來的對象，gc都能搞定，一般情況下我們又不會用new以外的方式去創建對象），所以一般是不需要程序員去實現finalize的。?
特殊情況下，需要程序員實現finalize，當對象被回收的時候釋放一些資源，比如：一個socket鏈接，在對象初始化時創建，整個生命周期內有效，那么就需要實現finalize，關閉這個鏈接。?
使用finalize還需要注意一個事，調用super.finalize();
一個對象的finalize()方法只會被調用一次，而且finalize()被調用不意味著gc會立即回收該對象，所以有可能調用finalize()后，該對象又不需要被回收了，然后到了真正要被回收的時候，因為前面調用過一次，所以不會調用finalize()，產生問題。?所以，推薦不要使用finalize()方法，它跟析構函數不一樣。
?
?
?
總結
以上是生活随笔為你收集整理的九阳真经-java基础面试的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 给详细的WIN7设置wifi热点的方法
- 下一篇： l4d2自建服务器加入第三方图,求教大佬