摘要：使用創(chuàng)建的字符串對象是運(yùn)行時(shí)創(chuàng)建出來的，它被保存在運(yùn)行時(shí)內(nèi)存區(qū)，即堆內(nèi)存，不會放入常量池中。類成員創(chuàng)建的對象實(shí)例中根本不會擁有對應(yīng)類的類變量。抽象類的構(gòu)造器不能用于創(chuàng)建實(shí)例，主要是用于被其子類調(diào)用。

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

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

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

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

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

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

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

系統(tǒng)會把一個(gè)-128到127之間的整數(shù)自動裝箱成Integer實(shí)例，并放入了一個(gè)名為cache的數(shù)組中緩存起來，如果以后把一個(gè)-128到127之間的整數(shù)自動裝箱成一個(gè)Integer實(shí)例的時(shí)候，實(shí)際上是直接指向?qū)?yīng)的數(shù)組元素，因此-128到127之間的同一個(gè)整數(shù)自動裝箱成Integer實(shí)例時(shí)，永遠(yuǎn)都是引用此cache數(shù)組的同一個(gè)數(shù)組元素，所以他們?nèi)肯嗟?，但每次把一個(gè)不在-128到127范圍內(nèi)的整數(shù)自動裝箱成Integer實(shí)例時(shí)，系統(tǒng)總是重新創(chuàng)建一個(gè)Integer實(shí)例，所以比較為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

當(dāng)使用==來判斷兩個(gè)變量是否相等時(shí)，如果兩個(gè)變量是基本類型，且都是數(shù)值類型，則只要兩個(gè)變量的值相等就會返回true。

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

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

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

使用new String()創(chuàng)建的字符串對象是運(yùn)行時(shí)創(chuàng)建出來的，它被保存在運(yùn)行時(shí)內(nèi)存區(qū)，即堆內(nèi)存，不會放入常量池中。

創(chuàng)建的對象實(shí)例中根本不會擁有對應(yīng)類的類變量。

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

類成員不能訪問實(shí)例成員，包括成員變量，方法，初始化塊，內(nèi)部類和枚舉類。因?yàn)轭惓蓡T是屬于類的，類成員的作用域比實(shí)例成員的作用域更大，完全可能出現(xiàn)類成員已將初始化完成，但實(shí)例成員還不曾初始化的情況，如果允許類成員訪問實(shí)例成員將會引起大量錯(cuò)誤。

如果一個(gè)類始終只能創(chuàng)建一個(gè)實(shí)例，那就被成為單例類。

為了避免其他類自由創(chuàng)建該類的實(shí)例，應(yīng)該把構(gòu)造器private修飾，從而把該類的所有構(gòu)造器隱藏起來。

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

代碼實(shí)例

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

當(dāng)類初始化時(shí)，系統(tǒng)會為該類的類變量分配內(nèi)存，并分配默認(rèn)值，當(dāng)創(chuàng)建對象時(shí)，系統(tǒng)會為該對象的實(shí)例變量分配內(nèi)存，并分配默認(rèn)值，也就是說：當(dāng)執(zhí)行靜態(tài)初始化快時(shí)可以對類變量附初始值，當(dāng)執(zhí)行初始化代碼塊，構(gòu)造器時(shí)可以對實(shí)例變量附初始值。

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

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

類變量：必須在靜態(tài)初始化塊中指定初始值或聲明該類變量時(shí)指定初始值。

實(shí)例變量：非靜態(tài)初始化塊，聲明變量時(shí)和構(gòu)造器中。

實(shí)例變量不能在靜態(tài)初始化塊中指定初始值，因?yàn)殪o態(tài)初始化塊是靜態(tài)成員，不可訪問實(shí)例變量-非靜態(tài)成員。類變量不能在普通初始化塊中指定初始值，因?yàn)轭愖兞吭陬惓跏蓟A段已經(jīng)被初始化了。

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

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

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

宏變量的確定條件

使用final修飾。

在定義該final變量時(shí)就指定了初始值。

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

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

宏變量與非宏變量不相等

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

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

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

創(chuàng)建自定義的不可變類規(guī)則如下

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

提供帶參數(shù)的構(gòu)造器，用于傳入?yún)?shù)以便初始化成員變量。

僅為該類的成員變量提供getter方法，不要為該類提供setter方法，因?yàn)槠胀ǚ椒o法修改final修飾的成員變量。

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

與可變類相比，不可變類的實(shí)例在整個(gè)生命周期中要永遠(yuǎn)處于初始化狀態(tài)，他的實(shí)例變量不可以改變，因此對不可變類的實(shí)例的控制更加簡單。

public class NoChangeClass {
    private final ClassNames names;
    public NoChangeClass() {
        this.names = new ClassNames("1","2");//默認(rèn)值
    }
    public NoChangeClass(ClassNames names) {
        //如果利用有參構(gòu)造，那么直接new一個(gè)新實(shí)例，這樣避免了舊實(shí)例的更改造成當(dāng)前類的變化。
        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
?

某個(gè)父類只是知道其子類應(yīng)該包含怎么樣的方法，但是無法準(zhǔn)確的知道這些子類是如何實(shí)現(xiàn)這些方法的。

抽象方法只有方法簽名，沒有方法實(shí)現(xiàn)的方法。

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

抽象方法和抽象類的規(guī)則

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

抽象類不能被實(shí)例化，無法使用new調(diào)用抽象類的構(gòu)造器創(chuàng)建抽象類的實(shí)例，即使抽象類里不包含抽象方法。

抽象類可以包含成員變量，方法，構(gòu)造器，初始化塊，內(nèi)部類。抽象類的構(gòu)造器不能用于創(chuàng)建實(shí)例，主要是用于被其子類調(diào)用。

含有抽象方法的類，包括直接定義了一個(gè)抽象方法；或者集成了一個(gè)抽象父類，但沒有完全實(shí)現(xiàn)父類包含的抽象方法；或?qū)崿F(xiàn)了一個(gè)借口，但沒有完全實(shí)現(xiàn)接口包含的抽象方法，只能被定義為抽象類.

在創(chuàng)建其子類實(shí)例的時(shí)候調(diào)用抽象父類的構(gòu)造器，初始化塊。

抽象類不能用于創(chuàng)建實(shí)例，只能當(dāng)做父類被其他子類繼承。

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

Static與abstract不能同時(shí)修飾某個(gè)方法，即沒有所謂的類抽象方法。但是可以同時(shí)修飾內(nèi)部類。

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

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

抽象類模板模式的簡單規(guī)則：

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

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

Java9對接口進(jìn)行了改進(jìn)，允許在接口中定義默認(rèn)方法和類方法。

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

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

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

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

由于接口定義的是一種規(guī)范，因此接口里不能包含構(gòu)造器和初始化塊定義，可以包含常量(靜態(tài)常量)，方法(只能是抽象實(shí)例方法，類方法，默認(rèn)和私有方法)，內(nèi)部類定義。

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

接口中的靜態(tài)常量是接口相關(guān)的。因此默認(rèn)增加static和final修飾符。所以在接口中的成員變量總是使用public static final修飾，并且只能在定義時(shí)指定初始值。

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

接口中定義的內(nèi)部類，內(nèi)部接口，內(nèi)部枚舉默認(rèn)都采用public static兩個(gè)修飾符，不管定義時(shí)是否指定，系統(tǒng)會為其自動修飾。

默認(rèn)方法都是采用default修飾，不能使用static修飾，并且總是public修飾。需要使用接口的實(shí)現(xiàn)類實(shí)例來調(diào)用這些方法。

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

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

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

接口不能用于創(chuàng)建實(shí)例，但是可以用于聲明引用型變量。

接口的主要用途就是被實(shí)現(xiàn)類實(shí)現(xiàn)：

定義變量，也可以用于強(qiáng)制類型轉(zhuǎn)換。

調(diào)用接口中定義的常量、

被其他類實(shí)現(xiàn)。

實(shí)現(xiàn)接口與繼承父類相似，一樣可以獲得所實(shí)現(xiàn)接口里定義的常量，方法，

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

一個(gè)類實(shí)現(xiàn)某個(gè)接口時(shí)，該類將會獲得接口中定義的常量，方法等。因此可以把實(shí)現(xiàn)接口理解為一種特殊的繼承。相當(dāng)于實(shí)現(xiàn)類繼承了一個(gè)徹底抽象的類。

為什么實(shí)現(xiàn)類實(shí)現(xiàn)接口里的方法只能使用public？

因?yàn)榻涌诶锏姆椒ǘ际莗ublic的，而子類重寫父類方法時(shí)訪問權(quán)限只能更高或者相等。

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

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

接口里只能包含抽象方法，靜態(tài)方法，默認(rèn)方法和私有方法。不能為普通方法提供實(shí)現(xiàn)，抽象類完全可以。

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

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

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

一個(gè)類最多只能有一個(gè)直接父類，包括抽象類。但一個(gè)類可以實(shí)現(xiàn)多個(gè)接口，通過實(shí)現(xiàn)多個(gè)接口可以彌補(bǔ)java單繼承的不足。