16. Java面向物件的三個特徵與含義

1 . 封裝性

　　將物件的狀態資訊儘可能的隱藏在物件內部，只保留有限的介面和方法與外界進行互動，從而避免了外界對物件內部屬性的破壞。

２. 繼承

３．多型

17. Override和Overload的含義和區別

方法的重寫(Overriding)和過載(Overloading)是Java多型性的不同表現。   
重寫(Overriding)是父類與子類之間多型性的一種表現，而過載(Overloading)是一個類中多型性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和引數，我們說該方法被重寫 (Overriding) 。子類的物件使用這個方法時，將呼叫子類中的定義，對它而言，父類中的定義如同被"遮蔽"了。如果在一個類中定義了多個同名的方法，它們或有不同的引數個數或有不同的引數型別或有不同的引數次序，則稱為方法的過載(Overloading)。不能通過訪問許可權、返回型別、丟擲的異常進行過載。 

1. Override 特點   
1、覆蓋的方法的標誌必須要和被覆蓋的方法的標誌完全匹配，才能達到覆蓋的效果；   
2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；   
3、覆蓋的方法所丟擲的異常必須和被覆蓋方法的所丟擲的異常一致，或者是其子類； 
4、方法被定義為final不能被重寫。  
5、對於繼承來說，如果某一方法在父類中是訪問許可權是private，那麼就不能在子類對其進行重寫覆蓋，如果定義的話，也只是定義了一個新方法，而不會達到重寫覆蓋的效果。（通常存在於父類和子類之間。） 

2.Overload 特點   
1、在使用過載時只能通過不同的引數樣式。例如，不同的引數型別，不同的引數個數，不同的引數順序（當然，同一方法內的幾個引數型別必須不一樣，例如可以是fun(int, float)， 但是不能為fun(int, int)）；   
2、不能通過訪問許可權、返回型別、丟擲的異常進行過載；   
3、方法的異常型別和數目不會對過載造成影響；   
4、過載事件通常發生在同一個類中，不同方法之間的現象。 
5、存在於同一類中，但是隻有虛方法和抽象方法才能被覆寫。 

其具體實現機制： 

overload是過載，過載是一種引數多型機制，即程式碼通過引數的型別或個數不同而實現的多型機制。 是一種靜態的繫結機制（在編譯時已經知道具體執行的是哪個程式碼段）。   
    
override是覆蓋。覆蓋是一種動態繫結的多型機制。即在父類和子類中同名元素（如成員函式）有不同 的實現程式碼。執行的是哪個程式碼是根據執行時實際情況而定的。

18. Interface與abstract類的區別

抽象類和介面都不能夠例項化，但可以定義抽象類和介面型別的引用。一個類如果繼承了某個抽象類或者實現了某個介面都需要對其中的抽象方法全部進行實現，否則該類仍然需要被宣告為抽象類。介面比抽象類更加抽象，因為抽象類中可以定義構造器，可以有抽象方法和具體方法，而介面中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、預設、protected、public的，而介面中的成員全都是public的。抽象類中可以定義成員變數，而介面中定義的成員變數實際上都是常量。有抽象方法的類必須被宣告為抽象類，而抽象類未必要有抽象方法。

19. Static class 與non static class的區別

內部靜態類不需要有指向外部類的引用。但非靜態內部類需要持有對外部類的引用。非靜態內部類能夠訪問外部類的靜態和非靜態成員。靜態類不能訪問外部類的非靜態成員。他只能訪問外部類的靜態成員。一個非靜態內部類不能脫離外部類實體被建立，一個非靜態內部類可以訪問外部類的資料和方法，因為他就在外部類裡面。

1.首先是類中的資料，static的
class A {
static int a;
}
class B {
int b;
}
無論新建幾個A物件，這幾個物件公用一個int a，一個物件的a改變，另一個也會改變。
而B物件，不同物件之間的int b獨立存在，互不影響，可以有多個值。

2.類中的方法
靜態的方法，不需要建立物件就可以訪問
如Math.abs()這個方法，我們沒有建立Math的物件，就可以通過類名直接使用abs這個方法。
而非靜態的方法，必須先建立物件，然後通過物件名，呼叫這個方法。
如JButton jb = new JButton();
jb.addActionListener(l);

ps:在靜態方法的定義中，不能直接引用本類的其他非靜態方法。例如。我們不能在main中直接引用，本類的其他方法。所以我們經常可以看見，在main方法中，先建立本類的一個物件，然後才通過物件呼叫本類的其他方法。

3.在初始化過程中，靜態的總是先初始化

20. java多型的實現原理。

21. 實現多執行緒的兩種方法：Thread與Runable

Thread 和 Runnable 的相同點：都是“多執行緒的實現方式”。
Thread 和 Runnable 的不同點：
Thread 是類，而Runnable是介面；Thread本身是實現了Runnable介面的類。我們知道“一個類只能有一個父類，但是卻能實現多個介面”，因此Runnable具有更好的擴充套件性。
此外，Runnable還可以用於“資源的共享”。即，多個執行緒都是基於某一個Runnable物件建立的，它們會共享Runnable物件上的資源。
通常，建議通過“Runnable”實現多執行緒

22. 執行緒同步的方法：sychronized、lock、reentrantLock等

一.什麼是sychronized

sychronized是Java中最基本同步互斥的手段,可以修飾程式碼塊,方法,類.

在修飾程式碼塊的時候需要一個reference物件作為鎖的物件.

在修飾方法的時候預設是當前物件作為鎖的物件.

在修飾類時候預設是當前類的Class物件作為鎖的物件.

synchronized會在進入同步塊的前後分別形成monitorenter和monitorexit位元組碼指令.在執行monitorenter指令時會嘗試獲取物件的鎖,如果此沒物件沒有被鎖,或者此物件已經被當前執行緒鎖住,那麼鎖的計數器加一,每當monitorexit被鎖的物件的計數器減一.直到為0就釋放該物件的鎖.由此synchronized是可重入的,不會出現自己把自己鎖死.

二.什麼ReentrantLock

以物件的方式來操作物件鎖.相對於sychronized需要在finally中去釋放鎖 

三.synchronized和ReentrantLock的區別

除了synchronized的功能,多了三個高階功能.

等待可中斷,公平鎖,繫結多個Condition.

1.等待可中斷

在持有鎖的執行緒長時間不釋放鎖的時候,等待的執行緒可以選擇放棄等待.   tryLock(long timeout, TimeUnit unit)

2.公平鎖

按照申請鎖的順序來一次獲得鎖稱為公平鎖.synchronized的是非公平鎖,ReentrantLock可以通過建構函式實現公平鎖.    new RenentrantLock(boolean fair)

3.繫結多個Condition

通過多次newCondition可以獲得多個Condition物件,可以簡單的實現比較複雜的執行緒同步的功能.通過await(),signal();

1、ReentrantLock 擁有Synchronized相同的併發性和記憶體語義，此外還多了 鎖投票，定時鎖等候和中斷鎖等候

     執行緒A和B都要獲取物件O的鎖定，假設A獲取了物件O鎖，B將等待A釋放對O的鎖定，

     如果使用 synchronized ，如果A不釋放，B將一直等下去，不能被中斷

     如果 使用ReentrantLock，如果A不釋放，可以使B在等待了足夠長的時間以後，中斷等待，而幹別的事情

    ReentrantLock獲取鎖定與三種方式：
    a)  lock(), 如果獲取了鎖立即返回，如果別的執行緒持有鎖，當前執行緒則一直處於休眠狀態，直到獲取鎖

    b) tryLock(), 如果獲取了鎖立即返回true，如果別的執行緒正持有鎖，立即返回false；

    c)tryLock(long timeout,TimeUnit unit)，   如果獲取了鎖定立即返回true，如果別的執行緒正持有鎖，會等待引數給定的時間，在等待的過程中，如果獲取了鎖定，就返回true，如果等待超時，返回false；

    d) lockInterruptibly:如果獲取了鎖定立即返回，如果沒有獲取鎖定，當前執行緒處於休眠狀態，直到或者鎖定，或者當前執行緒被別的執行緒中斷

2、synchronized是在JVM層面上實現的，不但可以通過一些監控工具監控synchronized的鎖定，而且在程式碼執行時出現異常，JVM會自動釋放鎖定，但是使用Lock則不行，lock是通過程式碼實現的，要保證鎖定一定會被釋放，就必須將unLock()放到finally{}中

3、在資源競爭不是很激烈的情況下，Synchronized的效能要優於ReetrantLock，但是在資源競爭很激烈的情況下，Synchronized的效能會下降幾十倍，但是ReetrantLock的效能能維持常態；

JDK5.0的多執行緒任務包對於同步的效能方面有了很大的改進，在原有synchronized關鍵字的基礎上，又增加了ReentrantLock，以及各種Atomic類。瞭解其效能的優劣程度，有助與我們在特定的情形下做出正確的選擇。 

總體的結論先擺出來：  

synchronized： 
在資源競爭不是很激烈的情況下，偶爾會有同步的情形下，synchronized是很合適的。原因在於，編譯程式通常會盡可能的進行優化synchronize，另外可讀性非常好，不管用沒用過5.0多執行緒包的程式設計師都能理解。 

ReentrantLock: 
ReentrantLock提供了多樣化的同步，比如有時間限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在資源競爭不激烈的情形下，效能稍微比synchronized差點點。但是當同步非常激烈的時候，synchronized的效能一下子能下降好幾十倍。而ReentrantLock確還能維持常態。 

Atomic: 
和上面的類似，不激烈情況下，效能比synchronized略遜，而激烈的時候，也能維持常態。激烈的時候，Atomic的效能會優於ReentrantLock一倍左右。但是其有一個缺點，就是隻能同步一個值，一段程式碼中只能出現一個Atomic的變數，多於一個同步無效。因為他不能在多個Atomic之間同步。 


所以，我們寫同步的時候，優先考慮synchronized，如果有特殊需要，再進一步優化。ReentrantLock和Atomic如果用的不好，不僅不能提高效能，還可能帶來災難。

23. 鎖的等級：方法鎖、物件鎖、類鎖

通過在方法宣告中加入 synchronized關鍵字來宣告 synchronized 方法。

synchronized 方法控制對類成員變數的訪問：
每個類例項對應一把鎖，每個 synchronized 方法都必須獲得呼叫該方法的類例項的鎖方能執行，否則所屬執行緒阻塞，方法一旦執行，就獨佔該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的執行緒方能獲得該鎖，重新進入可執行狀態。這種機制確保了同一時刻對於每一個類例項，其所有宣告為 synchronized 的成員函式中至多隻有一個處於可執行狀態，從而有效避免了類成員變數的訪問衝突。

物件鎖（synchronized修飾方法或程式碼塊）

　　當一個物件中有synchronized method或synchronized block的時候呼叫此物件的同步方法或進入其同步區域時，就必須先獲得物件鎖。如果此物件的物件鎖已被其他呼叫者佔用，則需要等待此鎖被釋放。（方法鎖也是物件鎖） 　　 　　　

類鎖(synchronized 修飾靜態的方法或程式碼塊)

　　由於一個class不論被例項化多少次，其中的靜態方法和靜態變數在記憶體中都只有一份。所以，一旦一個靜態的方法被申明為synchronized。此類所有的例項化物件在呼叫此方法，共用同一把鎖，我們稱之為類鎖。 　

物件鎖是用來控制例項方法之間的同步，類鎖是用來控制靜態方法（或靜態變數互斥體）之間的同步。　

24. 寫出生產者消費者模式。

生產者-消費者（producer-consumer）問題，也稱作有界緩衝區（bounded-buffer）問題，兩個程序共享一個公共的固定大小的緩衝區。其中一個是生產者，用於將訊息放入緩衝區；另外一個是消費者，用於從緩衝區中取出訊息。問題出現在當緩衝區已經滿了，而此時生產者還想向其中放入一個新的資料項的情形，其解決方法是讓生產者此時進行休眠，等待消費者從緩衝區中取走了一個或者多個數據後再去喚醒它。同樣地，當緩衝區已經空了，而消費者還想去取訊息，此時也可以讓消費者進行休眠，等待生產者放入一個或者多個數據時再喚醒它。

一，首先定義公共資源類，其中的變數number是儲存的公共資料。並且定義兩個方法，增加number的值和減少number的值。由於多執行緒的原因，必須加上synchronized關鍵字，注意while判斷的條件。

    /** 
     * 公共資源類 
     */  
    public class PublicResource {  
        private int number = 0;  
      
        /** 
         * 增加公共資源 
         */  
        public synchronized void increace() {  
            while (number != 0) {  
                try {  
                    wait();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            number++;  
            System.out.println(number);  
            notify();  
        }  
      
        /** 
         * 減少公共資源 
         */  
        public synchronized void decreace() {  
            while (number == 0) {  
                try {  
                    wait();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            number--;  
            System.out.println(number);  
            notify();  
        }  
    }  

    /** 
     * 生產者執行緒，負責生產公共資源 
     */  
    public class ProducerThread implements Runnable {  
        private PublicResource resource;  
      
        public ProducerThread(PublicResource resource) {  
            this.resource = resource;  
        }  
      
        @Override  
        public void run() {  
            for (int i = 0; i < 10; i++) {  
                try {  
                    Thread.sleep((long) (Math.random() * 1000));  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                resource.increace();  
            }  
        }  
    }  
    /** 
     * 消費者執行緒，負責消費公共資源 
     */  
    public class ConsumerThread implements Runnable {  
        private PublicResource resource;  
      
        public ConsumerThread(PublicResource resource) {  
            this.resource = resource;  
        }  
      
        @Override  
        public void run() {  
            for (int i = 0; i < 10; i++) {  
                try {  
                    Thread.sleep((long) (Math.random() * 1000));  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                resource.decreace();  
            }  
        }  
    }  

public class ProducerConsumerTest {  
    public static void main(String[] args) {  
        PublicResource resource = new PublicResource();  
        new Thread(new ProducerThread(resource)).start();  
        new Thread(new ConsumerThread(resource)).start();  
        new Thread(new ProducerThread(resource)).start();  
        new Thread(new ConsumerThread(resource)).start();  
        new Thread(new ProducerThread(resource)).start();  
        new Thread(new ConsumerThread(resource)).start();  
    }  
}

ThreadLocal類的大致結構和進行ThreadLocalMap的操作.我們可以從中得出以下的結論:1. ThreadLocalMap變數屬於執行緒（Thread）的內部屬性,不同的執行緒（Thread）擁有完全不同的ThreadLocalMap變數.2. 執行緒（Thread）中的ThreadLocalMap變數的值是在ThreadLocal物件進行set或者get操作時建立的.3. 在建立ThreadLocalMap之前,會首先檢查當前執行緒（Thread）中的ThreadLocalMap變數是否已經存在,如果不存在則建立一個；如果已經存在,則使用當前執行緒（Thread）已建立的ThreadLocalMap.4. 使用當前執行緒（Thread）的ThreadLocalMap的關鍵在於使用當前的ThreadLocal的例項作為key進行儲存ThreadLocal模式,至少從兩個方面完成了資料訪問隔離,有了橫向和縱向的兩種不同的隔離方式,ThreadLocal模式就能真正地做到執行緒安全：縱向隔離 —— 執行緒（Thread）與執行緒（Thread）之間的資料訪問隔離.這一點由執行緒（Thread）的資料結構保證.因為每個執行緒（Thread）在進行物件訪問時,訪問的都是各自執行緒自己的ThreadLocalMap.橫向隔離 —— 同一個執行緒中,不同的ThreadLocal例項操作的物件之間的相互隔離.這一點由ThreadLocalMap在儲存時,採用當前ThreadLocal的例項作為key來保證.

26. ThreadPool用法與優勢。

先定義一個執行緒池ThreadPoolExecutor，使用的時候用executor來呼叫runnable

優勢：合理利用執行緒池能夠帶來三個好處。第一：降低資源消耗。通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。第二：提高響應速度。當任務到達時，任務可以不需要等到執行緒建立就能立即執行。第三：提高執行緒的可管理性。執行緒是稀缺資源，如果無限制的建立，不僅會消耗系統資源，還會降低系統的穩定性，使用執行緒池可以進行統一的分配，調優和監控。

27. Concurrent包裡的其他東西：ArrayBlockingQueue、CountDownLatch等等。

ArrayBlockingQueue

一個建立在陣列之上被BlockingQueue繫結的阻塞佇列。這個佇列元素順序是先進先出。佇列的頭部是在佇列中待的時間最長的元素。佇列的尾部是再佇列中待的時間最短的元素。新的元素會被插入到佇列尾部，並且佇列從佇列頭部獲取元素。

    這是一個典型的繫結緩衝，在這個緩衝區中，有一個固定大小的陣列持有生產者插入的資料，並且消費者會提取這些資料。一旦這個類被建立，那麼這個陣列的容量將不能再被改變。嘗試使用put操作給一個滿佇列插入元素將導致這個操作被阻塞；嘗試從空佇列中取元素也會被阻塞。

concurrent包是jdk1.5引入的重要的包，主要程式碼由大牛Doug Lea完成，其實是在jdk1.4時代，由於java語言內建對多執行緒程式設計的支援比較基礎和有限，所以他寫了這個，因為實在太過於優秀，所以被加入到jdk之中； 

通常所說的concurrent包基本有3個package組成 
java.util.concurrent：提供大部分關於併發的介面和類，如BlockingQueue,Callable,ConcurrentHashMap,ExecutorService, Semaphore等 
java.util.concurrent.atomic：提供所有原子操作的類， 如AtomicInteger, AtomicLong等； 
java.util.concurrent.locks:提供鎖相關的類, 如Lock, ReentrantLock, ReadWriteLock, Condition等；

ountDownLatch， 可以用來在一個執行緒中等待多個執行緒完成任務的類； 
通常的使用場景是，某個主執行緒接到一個任務，起了n個子執行緒去完成，但是主執行緒需要等待這n個子執行緒都完成任務了以後才開始執行某個操作； 

掩飾程式碼：

@Test  
public void demoCountDown()  
{  
    int count = 10;  
  
    final CountDownLatch l = new CountDownLatch(count);  
    for(int i = 0; i < count; ++i)  
    {  
        final int index = i;  
        new Thread(new Runnable() {  
  
            @Override  
            public void run() {  
  
                try {  
                    Thread.currentThread().sleep(20 * 1000);  
                } catch (InterruptedException e) {  
  
                    e.printStackTrace();  
                }  
  
                System.out.println("thread " + index + " has finished...");  
  
                l.countDown();  
  
            }  
        }).start();  
    }  
  
    try {  
        l.await();  
    } catch (InterruptedException e) {  
  
        e.printStackTrace();  
    }  
  
    System.out.println("now all threads have finished");  
  
}

① 這兩個方法來自不同的類分別是，sleep來自Thread類，和wait來自Object類。

sleep是Thread的靜態類方法，誰呼叫的誰去睡覺，即使在a執行緒裡呼叫b的sleep方法，實際上還是a去睡覺，要讓b執行緒睡覺要在b的程式碼中呼叫sleep。

② 鎖: 最主要是sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他執行緒可以使用同步控制塊或者方法。

sleep不出讓系統資源；wait是進入執行緒等待池等待，出讓系統資源，其他執行緒可以佔用CPU。一般wait不會加時間限制，因為如果wait執行緒的執行資源不夠，再出來也沒用，要等待其他執行緒呼叫notify/notifyAll喚醒等待池中的所有執行緒，才會進入就緒佇列等待OS分配系統資源。sleep(milliseconds)可以用時間指定使它自動喚醒過來，如果時間不到只能呼叫interrupt()強行打斷。

Thread.sleep(0)的作用是“觸發作業系統立刻重新進行一次CPU競爭”。

③ 使用範圍：wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用。

29. foreach與正常for迴圈效率對比

不是絕對的，在選擇for， foreach的時候，應該考慮以下幾點：

1. 如果只是讀資料，優先選擇foreach，因為效率高，而且程式碼簡單，方便；

2. 如果要寫資料，就只能選擇for了

30. Java IO與NIO

區別對比

IO                NIO
面向流            面向緩衝
阻塞IO            非阻塞IO
無                選擇器

Java NIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩衝區的。 Java IO面向流意味著每次從流中讀一個或多個位元組，直至讀取所有位元組，它們沒有被快取在任何地方。此外，它不能前後移動流中的資料。如果需要前後移動從流中讀取的資料，需要先將它快取到一個緩衝區。 Java NIO的緩衝導向方法略有不同。資料讀取到一個它稍後處理的緩衝區，需要時可在緩衝區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩衝區中包含所有您需要處理的資料。而且，需確保當更多的資料讀入緩衝區時，不要覆蓋緩衝區裡尚未處理的資料。

2、阻塞與非阻塞IO

Java IO的各種流是阻塞的。這意味著，當一個執行緒呼叫read() 或 write()時，該執行緒被阻塞，直到有一些資料被讀取，或資料完全寫入。該執行緒在此期間不能再幹任何事情了。 Java NIO的非阻塞模式，使一個執行緒從某通道傳送請求讀取資料，但是它僅能得到目前可用的資料，如果目前沒有資料可用時，就什麼都不會獲取。而不是保持執行緒阻塞，所以直至資料變的可以讀取之前，該執行緒可以繼續做其他的事情。 非阻塞寫也是如此。一個執行緒請求寫入一些資料到某通道，但不需要等待它完全寫入，這個執行緒同時可以去做別的事情。 執行緒通常將非阻塞IO的空閒時間用於在其它通道上執行IO操作，所以一個單獨的執行緒現在可以管理多個輸入和輸出通道（channel）。

3、選擇器（Selector）

ava NIO的選擇器允許一個單獨的執行緒來監視多個輸入通道，你可以註冊多個通道使用一個選擇器，然後使用一個單獨的執行緒來“選擇”通道：這些通道里已經有可以處理的輸入，或者選擇已準備寫入的通道。這種選擇機制，使得一個單獨的執行緒很容易來管理多個通道。

31. 反射的作用與原理。

JAVA反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這種動態獲取的資訊以及動態呼叫物件的方法的功能稱為java語言的反射機制。

32. 泛型常用特點，List<String>能否轉為List<Object>。

1、型別安全。型別錯誤現在在編譯期間就被捕獲到了，而不是在執行時當作java.lang.ClassCastException展示出來，將型別檢查從執行時挪到編譯時有助於開發者更容易找到錯誤，並提高程式的可靠性

2、消除了程式碼中許多的強制型別轉換，增強了程式碼的可讀性

3、為較大的優化帶來了可能

List<String>向上轉換至List<Object>會丟失String類的身份（String型別的特有介面）,這種轉換是不完美的。
當需要由List向下轉型時，你的程式必須明確的知道將物件轉換成何種具體型別，不然這將是不不‘安全的操作！

• SAX是基於事件流的解析
  當解析器發現元素開始、元素結束、文字、文件的開始或結束等時，傳送事件，程式設計師編寫響應這些事件的程式碼，儲存資料
• DOM是基於XML文件樹結構的解析
  解析器讀入整個文件，然後構建一個駐留記憶體的樹結構，然後程式碼就可以使用 DOM 介面來操作這個樹結構

Sax定義

         SAX是一個解析速度快並且佔用記憶體少的xml解析器，非常適合用於android等移動裝置

         SAX全稱是Simple API for Xml，既是指一種介面，也是一個軟體包

         作為介面，sax是事件驅動型xml解析的一個標準介面

Sax工作原理

         Sax的工作原理簡單的說，就是對文件進行順序掃描，掃描到文件（document）開始與結束，掃描到元素（element）開始、結束等地方時呼叫事件處理

         處理函式做相應動作，然後繼續掃描，直到文件結束。

Sax特點

        1. 解析效率高，佔用記憶體少

        2.可以隨時停止解析

        3.不能載入整個文件到記憶體

        4.不能寫入xml

        5.SAX解析xml檔案採用的是事件驅動

        ---sax並不需要解析完 整個文件，在按內容順序解析文件的過程中，sax會判斷當前讀到的字元是否合法xml語法中的某部分，如果符合就會觸發事件

dom全稱Document Object Model ,為xml文件的已解析版本定義了一組介面。解析器讀入整個文件，然後構建一個主流記憶體的樹結構，

         然後程式碼就可以使用dom介面來操作這個樹結構

         >優點

                  1.整個文件樹在記憶體中，便於操作；支援刪除、修改、重新排列等多種功能

                  2.通過樹形結構存取xml文件

                  3.可以在樹的某個節點上向前或向後移動

           >缺點

                  1.將整個文件調入記憶體（包括無用的節點），浪費時間和空間

            >適用場合

                  一旦解析了文件還需多次訪問這些資料；硬體資源充足（記憶體，cpu）

        1.pull解析器是android內建的解析器，解析原理與sax類似

        2.pull它提供了類似的事件。

              如：開始元素和結束元素事件，使用parse.next()可以進入下一個元素並觸發相應的事件，事件將作為數值程式碼被髮送

                      因此可以使用一個switch對感興趣的事件進行處理。當元素開始解析時，呼叫parser.nextText()方法獲取下一個Text型別節點的值

          1.pull讀取xml檔案後觸發相應的事件呼叫方法返回的是數字。

          2.pull可以在程式中控制，想解析到哪裡就可以停止到哪裡

          3.Android中更推薦使用pull解析

1. Java沒有顯式指標，而在C++中卻可以用。
2. Java是主動多型的，不用關心具有繼承關係的多個類之間的同名成員函式會呼叫哪個，Java會主動地從祖父類、祖祖父類……，追溯至最高一級父類，然後從上至下開始尋找並呼叫；C++卻不會主動使用多型，要使用多型，就要用虛擬函式。
3. Java是隱式繼承的；C++是被動多型的，C++把話說明白了，你繼承誰就繼承誰，繼承多個都可以，你什麼都不說那麼就不繼承。
4. Java有介面，C++中卻沒有。C++中是定義了一個抽象類，把成員函式設為常量，並改成純虛擬函式，在C++中這樣的抽象類就是介面。
5. Java是單根繼承的，但是允許一個類實現多個介面；C++雖然支援多繼承，儘管很少有人去用它。
6. Java中所有的函式都與類相關，沒有全域性變數和非成員函式，而C++卻支援這些。
7. C++中使用的動態記憶體怎麼用就怎麼還，Java中由於包含一個垃圾收集系統。
8. Java有很緊湊的異常處理機制，而C++稍微顯得草率了一些。但是，這不代表C++異常處理機制不強大，因為Java只能丟擲Throwable之類的異常，而C++卻什麼都可以。
9. Java標準庫是Java龐大的體現，涵蓋了國際化、網路化、數學、聲音、Web應用和服務以及資料庫等。

JDK 1.7 新特性

1，switch中可以使用字串了

2，"<>"這個玩意兒的運用List<String> tempList = new ArrayList<>(); 即泛型例項化型別自動推斷

3. 自定義自動關閉類

4. 新增一些取環境資訊的工具方法

5. Boolean型別反轉，空指標安全,參與位運算

6. 兩個char間的equals

7，安全的加減乘除

8、對Java集合（Collections）的增強支援

9、數值可加下劃線

10、支援二進位制文字

11、簡化了可變引數方法的呼叫

12、在try catch異常撲捉中，一個catch可以寫多個異常型別，用"|"隔開，

13、jdk7之前，你必須用try{}finally{}在try內使用資源，在finally中關閉資源，不管try中的程式碼是否正常退出或者異常退出。jdk7之後，你可以不必要寫finally語句來關閉資源，只要你在try()的括號內部定義要使用的資源

JDK 1.8 新特性

二、Lambda 表示式

三、函式式介面

四、方法與建構函式引用

五、Lambda 作用域

六、訪問區域性變數

八、訪問介面的預設方法

九、Date API

十、Annotation 註解

36. 設計模式：單例、工廠、介面卡、責任鏈、觀察者等等。

JNI是Java Native Interface的縮寫，它提供了若干的API實現了Java和其他語言的通訊（主要是C&C++）。從Java1.1開始，JNI標準成為java平臺的一部分，它允許Java程式碼和其他語言寫的程式碼進行互動。JNI一開始是為了本地已編譯語言，尤其是C和C++而設計的，但是它並不妨礙你使用其他程式語言，只要呼叫約定受支援就可以了。使用java與本地已編譯的程式碼互動，通常會喪失平臺可移植性。但是，有些情況下這樣做是可以接受的，甚至是必須的。例如，使用一些舊的庫，與硬體、作業系統進行互動，或者為了提高程式的效能。JNI標準至少要保證原生代碼能工作在任何Java 虛擬機器環境。

j2se的部分 可算整理完了，希望各位讀者能夠喜歡，不足的地方希望各位大神多多批評指正，過幾天給大家整理JVM 的部分