摘要：有兩個重要的子類異常和錯誤，二者都是異常處理的重要子類，各自都包含大量子類。錯誤是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。異常由虛擬機拋出。迭代器通常被稱為輕量級對象，因為創建它的代價小。

面向過程
優點： 性能比面向對象高，因為類調用時需要實例化，開銷比較大，比較消耗資源;比如單片機、嵌入式開發、Linux/Unix等一般采用面向過程開發，性能是最重要的因素。
缺點： 沒有面向對象易維護、易復用、易擴展

面向對象
優點： 易維護、易復用、易擴展，由于面向對象有封裝、繼承、多態性的特性，可以設計出低耦合的系統，使系統更加靈活、更加易于維護
缺點： 性能比面向過程低

通過 Scanner

Scanner input = new Scanner(System.in);
String s  = input.nextLine();
input.close();

通過 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine(); 

封裝
把一個對象的屬性私有化，同時提供一些可以被外界訪問的屬性的方法，如果屬性不想被外界訪問，我們大可不必提供方法給外界訪問。但是如果一個類沒有提供給外界訪問的方法，那么這個類也沒有什么意義了。

繼承
繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。通過使用繼承我們能夠非常方便地復用以前的代碼。

子類擁有父類非 private 的屬性和方法。

子類可以擁有自己屬性和方法，即子類可以對父類進行擴展。

子類可以用自己的方式實現父類的方法。

多態
指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量到底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。
在Java中有兩種形式可以實現多態：繼承（多個子類對同一方法的重寫）和接口（實現接口并覆蓋接口中同一方法）。

方法重載是指同一個類中的多個方法具有相同的名字,但這些方法具有不同的參數列表,即參數的數量或參數類型不能完全相同
（相同名字，不同參數）

方法重寫是存在子父類之間的,子類定義的方法與父類中的方法具有相同的方法名字,相同的參數表和相同的返回類型
（相同名字，相同類型）（繼承）

因為調用時不能指定類型信息
如：

float max(int a,int b)
int max(int a,int b)

當調用max(1,2)時，無法確定

選擇使用接口和抽象類的依據：抽象類是對最本質的抽象，接口是對動作的抽象
如：男人、女人是兩個類，那可以抽象出一個類，人；人可以吃東西，學習等等，這些行為就是一個個接口

都不能。抽象方法需要子類重寫，而靜態的方法是無法被重寫的；本地方式是由本地代碼實現的方法，而抽象方法是沒有實現的；synchronized和方法的實現細節有關，抽象方法不涉及實現細節，因此都不能。

靜態變量：被static修飾的變量，也稱為類的變量，屬于類，不屬于類的任何一個對象，一個類不管創建多少對象，靜態變量在內存只有一個拷貝，可以實現讓多個對象共享內存
實例變量：必須依存某一實例，需要創建對象才能通過對象去訪問它。

String是引用類型，底層由char數組實現

String：字符串常量，在修改時布改變自身，修改等于重新生成新的自符串對象；

StringBuffer：在修改時會改變對象自身，每次操作都是對StringBuffer對象本身進行修改，不是生成新的對象，使用場景是：對字符串經常改變情況下，主要方法：append()

線程安全：

String：定義對象后不可變，線程安全
StringBuffer：線程安全，對調用的方法加入同步鎖，執行效率較慢，適用于多線程下操作字符串緩沖區大量數據
StringBuilderer：線程不安全，適用于單線程下操作字符串緩沖區大量數據

當我們使用"+"時，編譯器轉換成了StringBuilder，所以不要在for語句內使用；同時盡量不要"+"和StringBuilder一起使用

對于三者使用的總結：
操作少量的數據 String
單線程操作字符串緩沖區下操作大量數據 StringBuilder
多線程操作字符串緩沖區下操作大量數據 StringBuffer

主要作用是完成對類對象的初始化工作。可以執行。因為一個類即使沒有聲明構造方法也會有默認的不帶參數的構造方法。

== : 它的作用是判斷兩個對象的地址是不是相等。即，判斷兩個對象是不是同一個對象。。(基本數據類型比較的是值，引用數據類型比較的是內存地址)
equals() : 它的作用也是判斷兩個對象是否相等。但它一般有兩種使用情況：
情況1：類沒有覆蓋 equals() 方法。則通過 equals() 比較該類的兩個對象時，等價于通過“==”比較這兩個對象。
情況2：類覆蓋了 equals() 方法。一般，我們都覆蓋 equals() 方法來兩個對象的內容相等；若它們的內容相等，則返回 true (即，認為這兩個對象相等)。

public class test1 {

    public static void main(String[] args) {

        String a = new String("ab"); // a 為一個引用

        String b = new String("ab"); // b為另一個引用,對象的內容一樣

        String aa = "ab"; // 放在常量池中

        String bb = "ab"; // 從常量池中查找

        if (aa == bb) // true

            System.out.println("aa==bb");

        if (a == b) // false，非同一對象

            System.out.println("a==b");

        if (a.equals(b)) // true

            System.out.println("a.equals(b)");

        if (42 == 42.0) { // true

            System.out.println("true");

        }

    }

}

說明：

String 中的 equals 方法是被重寫過的，因為 object 的 equals 方法是比較的對象的內存地址，而 String 的 equals 方法比較的是對象的值。

當創建 String 類型的對象時，虛擬機會在常量池中查找有沒有已經存在的值和要創建的值相同的對象，如果有就把它賦給當前引用。如果沒有就在常量池中重新創建一個 String 對象。

如果兩個對象相等，則hashcode一定也是相同的

兩個對象相等,對兩個對象分別調用equals方法都返回true

兩個對象有相同的hashcode值，它們也不一定是相等的

因此，equals 方法被覆蓋過，則 hashCode 方法也必須被覆蓋

hashCode() 的默認行為是對堆上的對象產生獨特值。如果沒有重寫 hashCode()，則該 class 的兩個對象無論如何都不會相等（即使這兩個對象指向相同的數據）

length屬性:用于獲取數組長度

int ar[] = new int{1,2,3}
/**
* 數組用length屬性取得長度
*/
int lenAr = ar.length;//此處lenAr=3
System.out.println("Arr length:"+lenAr);

length()方法：用于獲取字符串長度

String str = "Hello World Java";

/**
* 字符串用length()方法取得長度
*/

int lenStr = str.length();//此處lenStr=16
System.out.println("Str length():"+lenStr);

size()方法：用于獲取泛型集合有多少個元素

/**
* Collection是整個類集之中單值保存的最大父接口，所以使用時需要用具體子類實例化
*/
Collection col = new ArrayList();
col.add("Hello");
col.add("World");
col.add("Java");
/**
* 類集框架用size()方法取元素個數
*/
int sizeCol = col.size();//此處sizeCol=3
System.out.println("Col size:"+sizeCol);

ArrayList 底層是數組，查詢快，增刪慢

LinkedList 底層是鏈表，增刪快，查詢慢

voctor 底層是數組，線程安全，增刪慢，查詢慢

List轉換成為數組：調用ArrayList的toArray方法。
數組轉換成為List：調用Arrays的asList方法。

思路：隊列a和b

  入棧：a隊列為空，b為空，將“a,b,c,d,e”先放入a中，a進棧為“a,b,c,d,e”  
  出棧：將a隊列依次加入ArrayList集合c中，以倒序的方法，將c中的集合取出，放入b中，再將b隊列出列
  

 public static void main(String[] args) {
        Queue a = new LinkedList<>();
        Queue b = new LinkedList<>();
        List c = new ArrayList<>();

        a.offer("a");
        a.offer("b");
        a.offer("c");
        a.offer("d");
        a.offer("e");
        System.out.print("進棧：");
        for(String s:a){
            c.add(s);
            System.out.print(s);
        }

        for(int i=c.size()-1;i>=0;i--){
            b.offer(c.get(i));
        }

        System.out.println();
        System.out.print("出棧：");
        for(String s:b){
            System.out.print(s);
        }
    }

一些隊列有大小限制，因此如果想在一個滿的隊列中加入一個新項，多出的項就會被拒絕。
這時新的 offer 方法就可以起作用了。它不是對調用 add() 方法拋出一個 unchecked 異常，而只是得到由 offer() 返回的 false。

remove() 和 poll() 方法都是從隊列中刪除第一個元素。remove() 的行為與 Collection 接口的版本相似， 但是新的 poll() 方法在用空集合調用時不是拋出異常，只是返回 null。因此新的方法更適合容易出現異常條件的情況。

element() 和 peek() 用于在隊列的頭部查詢元素。與 remove() 方法類似，在隊列為空時， element() 拋出一個異常，而 peek() 返回 null。

HashMap是線程不安全的，是Map的一個子接口，是將鍵映射到值的對象，不允許鍵值重復，允許空鍵和空值，由于非線程安全，HashMap的效率要較HashTable高

HashTable是線程安全的一個集合，不允許null作為一個key或者value值，是線程安全的

在 Java 中，所有的異常都有一個共同的祖先java.lang包中的 Throwable類。
Throwable： 有兩個重要的子類：Exception（異常） 和 Error（錯誤） ，二者都是 Java 異常處理的重要子類，各自都包含大量子類。
Error（錯誤）:是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題
Exception（異常）:是程序本身可以處理的異常

RuntimeException。RuntimeException 異常由Java虛擬機拋出。

NullPointerException（要訪問的變量沒有引用任何對象時，拋出該異常）

ArithmeticException（算術運算異常，一個整數除以0時，拋出該異常）

ArrayIndexOutOfBoundsException （下標越界異常）。

SQLException，SQL異常，一般都是SQL語句錯誤

==異常和錯誤的區別：異常能被程序本身可以處理，錯誤是無法處理==

throw：
throw在方法體內，表示拋出異常，執行throw一定是拋出了某種異常

throws ：
throws跟在方法聲明的后面，表示可能出現某種異常

如果try有返回值，就把返回值保存到局部變量中；

執行jsr指令跳到finally語句里執行；

執行完finally語句后，返回之前保存在局部變量表里的值。

如果try，finally語句里均有return，忽略try的return，而使用finally的return

迭代器是一種設計模式，它是一個對象，它可以遍歷并選擇序列中的對象，而開發人員不需要了解該序列的底層結構。迭代器通常被稱為“輕量級”對象，因為創建它的代價小。
使用：

使用方法iterator()要求容器返回一個Iterator。第一次調用Iterator的next()方法時，它返回序列的第一個元素。注意：iterator()方法是java.lang.Iterable接口,被Collection繼承。

使用next()獲得序列中的下一個元素。

使用hasNext()檢查序列中是否還有元素。

使用remove()將迭代器新返回的元素刪除。