摘要：使用創建的字符串對象是運行時創建出來的，它被保存在運行時內存區，即堆內存，不會放入常量池中。類成員創建的對象實例中根本不會擁有對應類的類變量。抽象類的構造器不能用于創建實例，主要是用于被其子類調用。

Java提供了final關鍵字來修飾變量，方法和類，系統不允許為final變量重新賦值，子類不允許覆蓋父類的final方法，final類不能派生子類。

Abstract 和 interface兩個關鍵字分別用于定義抽象類和接口，抽象類和接口都是從多個子類中抽象出來的共同特征，但抽象類主要作為多個類的模板，而接口則定義了多類應該遵守的規則。

自動裝箱，就是把一個基本類型變量直接賦值給對應的包裝類變量，或者OBJECT。

自動拆箱，允許直接把包裝類對象直接賦值給一個對應的基本類型變量。

包裝類型的變量是引用數據類型，但包裝類的實例可以與數值類型的值作比較，這種比較是直接取出包裝類實例所包裝的數值來進行比較的。

兩個包裝類實例比較，只有兩個包裝類引用指向同一個對象才會返回true。

對于Integer包裝類型的數值超過了（-128 --- 127）比較為false的解釋如下：

系統會把一個-128到127之間的整數自動裝箱成Integer實例，并放入了一個名為cache的數組中緩存起來，如果以后把一個-128到127之間的整數自動裝箱成一個Integer實例的時候，實際上是直接指向對應的數組元素，因此-128到127之間的同一個整數自動裝箱成Integer實例時，永遠都是引用此cache數組的同一個數組元素，所以他們全部相等，但每次把一個不在-128到127范圍內的整數自動裝箱成Integer實例時，系統總是重新創建一個Integer實例，所以比較為false。

public static void main(String[] args) {

    Integer valueOf = 112;
    Integer valueOf1 = 112;
    //dsds :  true
    System.out.println("dsds :  "+(valueOf == valueOf1));
    Integer valueOf2 = 128;
    Integer valueOf3 = 128;
    //dsds :  false
    System.out.println("dsds :  "+(valueOf2 == valueOf3));

}

Boolean值的比較：true > false

當使用==來判斷兩個變量是否相等時，如果兩個變量是基本類型，且都是數值類型，則只要兩個變量的值相等就會返回true。

對于兩個引用變量必須引用一個對象的時候==才會返回true，==不可用于比較類型上沒有父子關系的兩個對象。

常量池：constant pool，專門用于管理在編譯時被確定并且被保存在以編譯的.class文件中的一些數據。包括了關于類，方法，接口中的常量，還包括字符串常量。

JVM常量池保證相同的字符串直接量只有一個，不會產生多余副本。

使用new String()創建的字符串對象是運行時創建出來的，它被保存在運行時內存區，即堆內存，不會放入常量池中。

創建的對象實例中根本不會擁有對應類的類變量。

Null對象可以訪問他所屬類的類成員。

類成員不能訪問實例成員，包括成員變量，方法，初始化塊，內部類和枚舉類。因為類成員是屬于類的，類成員的作用域比實例成員的作用域更大，完全可能出現類成員已將初始化完成，但實例成員還不曾初始化的情況，如果允許類成員訪問實例成員將會引起大量錯誤。

如果一個類始終只能創建一個實例，那就被成為單例類。

為了避免其他類自由創建該類的實例，應該把構造器private修飾，從而把該類的所有構造器隱藏起來。

一旦把該類的構造器隱藏起來，就需要提供一個public方法作為該類的訪問點，用于創建該類的對象，且該方法必須使用static修飾。除此之外，該類還必須緩存已經創建的對象，否則該類無法知道是否曾經創建過對象。

代碼實例

    public class Singleton {
             //單例類
            public static Singleton singleton;//用于保存創建好的對象。
            private Singleton() {}//private修飾，對外隱藏構造器
            
            public static Singleton getInstance() {
                if (singleton == null) {//如果為空那么就是未曾創建對象
                    singleton = new Singleton();//創建對象
                }
                return singleton;//返回
            }
            public static void main(String[] args) {
                Singleton instance = Singleton.getInstance();
                Singleton instance1 = Singleton.getInstance();
                System.out.println(instance == instance1);//true
            }
        }

當類初始化時，系統會為該類的類變量分配內存，并分配默認值，當創建對象時，系統會為該對象的實例變量分配內存，并分配默認值，也就是說：當執行靜態初始化快時可以對類變量附初始值，當執行初始化代碼塊，構造器時可以對實例變量附初始值。

Final修飾的成員變量而言，一旦有了初始值，就不能二次賦值，如果既沒有初始值，也沒有在構造器，初始化塊中指定初始值，那么就為系統默認的初始值，也就失去了意義，因此final修飾的成員變量必須由程序員顯示的指定初始值。

Final修飾的類變量，實例變量能指定初始值的地方

類變量：必須在靜態初始化塊中指定初始值或聲明該類變量時指定初始值。

實例變量：非靜態初始化塊，聲明變量時和構造器中。

實例變量不能在靜態初始化塊中指定初始值，因為靜態初始化塊是靜態成員，不可訪問實例變量-非靜態成員。類變量不能在普通初始化塊中指定初始值，因為類變量在類初始化階段已經被初始化了。

Final成員變量在顯示初始化之前不能直接訪問，但可以通過方法來訪問，基本可以算是java的一個設計缺陷。

系統不會對局部變量初始化，局部變量必須由程序員顯示初始化，因此使用final修飾局部變量時。既可以在定義時指定默認值，也可以不指定默認值。

當使用final修飾基本類型變量時，不能對基本類型變量重新賦值，因此基本類型變量不能被改變。但對于引用變量而言，他僅僅保存的是一個引用，final只保證這個引用類型變量所引用的地址不會改變，即一直引用同一個對象，但是在堆內存中的這個對象完全可以發生改變。

宏變量的確定條件

使用final修飾。

在定義該final變量時就指定了初始值。

該初始值可以在編譯時被確定下來。

宏變量一旦確定下來，編譯器會把程序中所有用到該變量的地方直接替換成該變量的值。

宏變量與非宏變量不相等

不希望子類沖重寫父類的某個方法，則可以使用final修飾該方法。

為了保證某個類不被繼承，則可以使用final修飾這個類。

不可變類:創建實例后，實例的實例變量是不可改變的。如Integer in = new Integer(8);

創建自定義的不可變類規則如下

使用private和final修飾符來修飾該類中的成員。

提供帶參數的構造器，用于傳入參數以便初始化成員變量。

僅為該類的成員變量提供getter方法，不要為該類提供setter方法，因為普通方法無法修改final修飾的成員變量。

如果有必要重寫Object中的equals 和 hashCode方法

與可變類相比，不可變類的實例在整個生命周期中要永遠處于初始化狀態，他的實例變量不可以改變，因此對不可變類的實例的控制更加簡單。

public class NoChangeClass {
    private final ClassNames names;
    public NoChangeClass() {
        this.names = new ClassNames("1","2");//默認值
    }
    public NoChangeClass(ClassNames names) {
        //如果利用有參構造，那么直接new一個新實例，這樣避免了舊實例的更改造成當前類的變化。
        this.names = new ClassNames(names.getName(),names.getTime());
    }
    public ClassNames getNames() {
        return new ClassNames(names.getName(),names.getTime());
    } 
    public static void main(String[] args) {
        ClassNames classNames = new ClassNames("?","??");
        NoChangeClass noChangeClass = new NoChangeClass(classNames);
        System.out.println(classNames.getName());
        classNames.setName("21e1231");
        System.out.println(classNames.getName());
        System.out.println(noChangeClass.names.getName());
    }
}
Output：
?
21e1231
?

某個父類只是知道其子類應該包含怎么樣的方法，但是無法準確的知道這些子類是如何實現這些方法的。

抽象方法只有方法簽名，沒有方法實現的方法。

有抽象方法的類只能被定義為抽象類，抽象類可以沒有抽象方法。

抽象方法和抽象類的規則

抽象類抽象方法必須使用abstract修飾符修飾，抽象方法不能有方法體。

抽象類不能被實例化，無法使用new調用抽象類的構造器創建抽象類的實例，即使抽象類里不包含抽象方法。

抽象類可以包含成員變量，方法，構造器，初始化塊，內部類。抽象類的構造器不能用于創建實例，主要是用于被其子類調用。

含有抽象方法的類，包括直接定義了一個抽象方法；或者集成了一個抽象父類，但沒有完全實現父類包含的抽象方法；或實現了一個借口，但沒有完全實現接口包含的抽象方法，只能被定義為抽象類.

在創建其子類實例的時候調用抽象父類的構造器，初始化塊。

抽象類不能用于創建實例，只能當做父類被其他子類繼承。

Abstract修飾類，表示只能被繼承，修飾方法，表明必須由子類實現重寫。而final修飾的類不能被繼承，final修飾的方法不能被重寫，所以final和abstract不能同時修飾類和方法。

Static與abstract不能同時修飾某個方法，即沒有所謂的類抽象方法。但是可以同時修飾內部類。

Abstract關鍵字修飾的方法必須被其子類重寫才有意義，否則就永遠不會擁有方法體，所以abstract方法不能是private修飾。Private與abstract不能同時修飾方法。

抽象類是從多個具體類中抽象出來的父類，它具有更高層次的抽象。

抽象類模板模式的簡單規則：

抽象父類可以只定義需要使用的某些方法，把不能實現的部分抽象成抽象方法，留給其子類去實現。

父類中可能包含需要調用其他系列方法的方法，這些被調用方法即可以由父類實現，也可以由其子類實現。父類里提供的方法只是定義了一個通用算法，其實現也許并不完全由自身實現，而必須依賴于其子類的輔助。

Java9對接口進行了改進，允許在接口中定義默認方法和類方法。

接口定義的是多個類共同的公共行為規范，這些行為是與外部交流的通道，這就意味著接口里通常是定義一組公共方法。

接口定義的基本語法說明：

修飾符可以是public或者省略，如果省略了public，則默認采用包權限訪問控制符。

一個接口可以有多個直接父接口，但接口只能繼承接口，不能繼承類。

由于接口定義的是一種規范，因此接口里不能包含構造器和初始化塊定義，可以包含常量(靜態常量)，方法(只能是抽象實例方法，類方法，默認和私有方法)，內部類定義。

接口中的私有方法可以擁有方法體，但私有方法不能使用default修飾。私有方法可以使用static修飾，所以就是說私有方法可以是類方法也可以是實例方法。

接口中的靜態常量是接口相關的。因此默認增加static和final修飾符。所以在接口中的成員變量總是使用public static final修飾，并且只能在定義時指定初始值。

接口中如果不是定義默認方法類方法或私有方法，系統自動為普通方法增加abstract修飾符。接口中的普通方法總是使用public abstract修飾。

接口中定義的內部類，內部接口，內部枚舉默認都采用public static兩個修飾符，不管定義時是否指定，系統會為其自動修飾。

默認方法都是采用default修飾，不能使用static修飾，并且總是public修飾。需要使用接口的實現類實例來調用這些方法。

類方法總是public修飾，可以直接使用接口名來調用。

接口中的默認方法：當兩個默認方法中包含一段相同的實現邏輯時，就有必要把這段代碼抽取成工具方法，而且工具方法一般是被隱藏的，所以這就是java9中增加私有方法的原因。

一個接口可以由多個直接父接口，和類繼承相似，子接口擴展某個父接口時，將會獲得父接口里定義的所有抽象方法，常量。

接口不能用于創建實例，但是可以用于聲明引用型變量。

接口的主要用途就是被實現類實現：

定義變量，也可以用于強制類型轉換。

調用接口中定義的常量、

被其他類實現。

實現接口與繼承父類相似，一樣可以獲得所實現接口里定義的常量，方法，

一個類實現了一個或者多個接口之后，必須完全實現接口中定義的全部抽象方法，否則該類就將保留從父接口集成得到的抽象方法，該類也必須定義成抽象類。

一個類實現某個接口時，該類將會獲得接口中定義的常量，方法等。因此可以把實現接口理解為一種特殊的繼承。相當于實現類繼承了一個徹底抽象的類。

為什么實現類實現接口里的方法只能使用public？

因為接口里的方法都是public的，而子類重寫父類方法時訪問權限只能更高或者相等。

抽象類即只對事物本身的抽象，接口則是對事物本身擁有的行為的抽象。

接口與抽象類的在用法上的差別。：

接口里只能包含抽象方法，靜態方法，默認方法和私有方法。不能為普通方法提供實現，抽象類完全可以。

接口里只能定義靜態常量，不能定義普通成員變量，抽象類都可以。

接口里不包含構造器；抽象類里可以包含構造器，抽象類里的構造器并不是用于創建對象。而是讓其子類調用這些構造器來完成屬于抽象類的初始化操作。

接口里不能包含初始化塊，但抽象類則完全可以包含。

一個類最多只能有一個直接父類，包括抽象類。但一個類可以實現多個接口，通過實現多個接口可以彌補java單繼承的不足。