一、基礎知識：

1、JVM、JRE和JDK的區別：

    JVM(Java Virtual Machine):java虛擬機，用于保證java的跨平臺的特性。
                  java語言是跨平臺，jvm不是跨平臺的。
    
    JRE(Java Runtime Environment):java的運行環境,包括jvm+java的核心類庫。    
    
    JDK(Java Development Kit):java的開發工具,包括jre+開發工具

2、環境變量path和classpath的作用是什么？

(1)path是配置Windows可執行文件的搜索路徑，即擴展名為.exe的程序文件所在的目錄，
   用于指定DOS窗口命令的路徑。
(2)Classpath是配置class文件所在的目錄，用于指定類搜索路徑，JVM就是通過它來尋找該類的class類文件的。      

3、變量有什么用？為什么要定義變量？什么時候用？

答：變量的作用：用來存儲數據。
    
為什么要定義變量：用來不斷的存放同一類型的常量，并可以重復使用

4、&和&&的區別?

答：（1）&&會出現短路，如果可以通過第一個表達式判斷出整個表達式的結果，則不繼續后面表達式的運算；
         只能操作boolean類型數據；
    （2）&不會出現短路，將整個表達式都運算。既可以操作boolean數據還可以操作數。

5、標示符命名規則：

由數字(0-9)，大小寫英文字母，以及_和$組成。
    不能以數字開頭。
    不能使用關鍵字來自定義命名。

6、數據類型：

    (1)基本數據類型(4類8種)：
        整數類型：byte、short、int、long
        浮點數類型：float、double
        字符類型：char
        布爾類型：boolean(ture false)
    (2)引用數據類型：
        類
        接口
        數組

7、類型轉換

    精度從高到低  double  float  long  int  short(char)  byte 
    (1)自動類型轉換  將一個低精度---?高精度 
    (2)強制類型轉換  將一個高精度---?低精度(精度會下降)

8、java語言的三種技術架構

    J2EE：企業版
    是為開發企業環境下的應用程序提供的一套解決方案。
    該技術體系中包含的技術如 Servlet、Jsp等，主要針對于Web應用程序開發。
    J2SE：標準版
    是為開發普通桌面和商務應用程序提供的解決方案。
    該技術體系是其他兩者的基礎，可以完成一些桌面應用程序的開發。
    比如Java版的掃雷。
    J2ME：小型版
    是為開發電子消費產品和嵌入式設備提供的解決方案。
    該技術體系主要應用于小型電子消費類產品，如手機中的應用程序等。

9、java的跨平臺性：

    通過Java語言編寫的應用程序在不同的系統平臺上都可以運行。
    跨平臺的原因：
    只要在需要運行java應用程序的操作系統上，先安裝一個Java虛擬機(JVM Java Virtual Machine)即可。
    由JVM來負責Java程序在該系統中的運行。

10、有符號數據的表示法(次重點)

    原碼，反碼(原碼取反)，補碼(反碼+1)。

11、函數

定義：函數就是定義在類中的具有特定功能的一段獨立小程序。        
    特點：
        定義函數可以將功能代碼進行封裝
        便于對該功能進行復用
        函數只有被調用才會被執行
        函數的出現提高了代碼的復用性
        對于函數沒有具體返回值的情況，返回值類型用關鍵字void表示，
        那么該函數中的return語句如果在最后一行可以省略不寫。
    函數的應用兩個明確：
        明確要定義的功能最后的結果是什么？
        明確在定義該功能的過程中，是否需要未知內容參與運算

12、重載：

概念：在同一個類中，允許存在一個以上的同名函數，只要它們的參數個數或者參數類型不同即可。    
    特點：與返回值類型無關，只看參數列表(參數類型以及參數個數)。 
    好處：方便于閱讀，優化了程序設計。

13、數組：

    概念：同一種數據類型的集合。  
    好處：可以自動給數組中的元素從0開始編號，方便操作這些元素。

14、內存結構：

    棧內存：用于存儲局部變量，當數據使用完，所占空間會自動釋放。
    堆內存：數組和對象，通過new建立的實例都存放在堆內存中。
    方法區：靜態成員、構造函數、常量池、線程池
    本地方法區：window系統占用
    寄存器：

二、面向對象

1、面向對象思想：

    (1)概述：面向對象是相對于面向過程而言的，面向過程強調的是功能，面向對象強調的是將功能封裝進對象，
         強調具備功能的對象；
    (2)思想特點：
         A:是符合人們思考習慣的一種思想；
         B:將復雜的事情簡單化了；
         C:將程序員從執行者變成了指揮者；

         比如我要達到某種結果，我就尋找能幫我達到該結果的功能的對象，如我要洗衣服我就買洗衣機，
         至于怎么洗我不管。
    (3)特征：
        封裝：隱藏對象的屬性和實現細節，僅對外提供公共訪問方式
        繼承: 多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那么多個類無需再定義
          這些屬性和行為，只要繼承那個類即可。
        多態: 一個對象在程序不同運行時刻代表的多種狀態，父類或者接口的引用指向子類對象

2、類和對象：

    類：對現實世界中某類事物的描述,是抽象的，概念上的定義。
    對象：事物具體存在的個體。

3：成員變量和局部變量的區別(重點)

    (1)作用域
        成員變量：針對整個類有效。
        局部變量：只在某個范圍內有效。(一般指的就是方法,語句體內)
    (2)存儲位置
        成員變量：隨著對象的創建而存在，隨著對象的消失而消失，存儲在堆內存中。
        局部變量：在方法被調用，或者語句被執行的時候存在，存儲在棧內存中。
              當方法調用完，或者語句結束后，就自動釋放。
    (3)初始值
        成員變量：有默認初始值。
        局部變量：沒有默認初始值，使用前必須賦值。

4、匿名對象

    (1)匿名對象就是沒有名字的對象。是對象的一種簡寫形式。
    (2)應用場景
        A:只調用一次類中的方法。
        B:可以作為實際參數在方法傳遞中使用

5、封裝：

    指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式；比如電腦機箱、筆記本等
    好處：
        將變化隔離；
        方便使用；
        提高復用性；
        提高安全性

6、關鍵字private：封裝在代碼中的體現

    (1)私有的意思，權限修飾符
    (2)用來修飾成員變量和成員函數
    (3)用private修飾的成員只在本類中有效
    (4)私有是封裝的一種體現

7、構造方法：

    (1)特點：
        方法名與類名相同
        沒有返回類型
        沒有返回值
    (2)作用：構造函數是用于創建對象，并對其進行初始化賦值，對象一建立就自動調用相對應的構造函數，
    (3)構造方法的注意事項:
        A:如果一個自定義類沒有構造方法，系統會默認給出一個無參構造方法。
        B:如果一個自定義類提供了構造方法，那么，系統將不再給出無參構造方法。
          這個時候，你可以不使用無參構造方法。
          如果你想使用，那么，就必須手動給出無參構造方法。

        建議：一般情況下，我們的自定義類都要手動給出無參構造方法。
    (4)構造方法和成員方法的區別
        A:格式區別
            構造方法和類名相同，并且沒有返回類型，也沒有返回值。
            普通成員方法可以任意起名，必須有返回類型，可以沒有返回值。
        B:作用區別
            構造方法用于創建對象，并進行初始化值。
            普通成員方法是用于完成特定功能的。
        C:調用區別
            構造方法是在創建對象時被調用的，一個對象建立，只調用一次相應構造函數
            普通成員方法是由創建好的對象調用，可以調用多次

8、構造代碼塊：

    (1)作用：給對象進行初始化，對象一建立就執行，而且優先于構造函數執行
    (2)構造代碼塊和構造函數的區別：
        構造代碼塊是給所有不同對象的共性進行統一初始化
        構造函數是給對應的對象進行初始化

9、this關鍵字

    (1)this關鍵字代表本類對象的一個引用，誰調用this所在的方法，this就代表誰  
    (2)this的使用場景
        A:用于區分同名成員變量和局部變量；
        B:在定義函數時，該函數內部要用到調用該函數的對象時，因為此時對象還沒建立，故this代表此對象
        B:構造函數間調用
            **這個時候，this(參數)必須作為第一條語句存在。

10、Person p = new Person();在內存中做了哪些事情。

    (1)將Person.class文件加載進內存中。
    (2)如果p定義在主方法中，那么，就會在?？臻g開辟一個變量空間p。
    (3)在堆內存給對象分配空間。
    (4)對對象中的成員進行默認初始化。
    (5)對對象中的成員進行顯示初始化。
    (6)調用構造代碼塊對對象進行初始化。(如果沒有就不執行)
    (7)調用構造方法對對象進行初始化。對象初始化完畢。
    (8)將對象的內存地址賦值給p變量，讓p變量指向該對象。

11、static關鍵字：

    (1)靜態的意思，用來修飾成員變量和成員函數
    (2)靜態的特點:
        隨著類的加載而加載
        優先于對象存在
        對所有對象共享
        可以被類名直接調用
    (3)靜態的注意事項
        A:靜態方法只能訪問靜態成員
            為什么：因為靜態的內容是隨著類的加載而加載，它是先進內存的。
        B:靜態方法中不能使用this,super關鍵字
        C:主方法是靜態的
            public static void main(String[] args)
            public:公共的意思，是最大權限修飾符。
            static:由于jvm調用main方法的時候，沒有創建對象。
               只能通過類名調用。所以，main必須用static修飾。
            void:由于main方法是被jvm調用，不需要返回值。用void修飾。
            main:main是主要的意思，所以jvm采用了這個名字。是程序的入口。

            String[]:字符串數組
            args:數組名

            在運行的時候，通過java命令給args數組賦值。
            格式：java MainTest hello world itcast
    (4)靜態變量和成員變量的區別
        A：調用方式
            靜態變量也稱為類變量，可以直接通過類名調用。也可以通過對象名調用。
            這個變量屬于類。
            成員變量也稱為實例變量，只能通過對象名調用。這個變量屬于對象。
        B：存儲位置
            靜態變量存儲在方法區長中的靜態區。
            成員變量存儲在堆內存。
        C：生命周期
            靜態變量隨著類的加載而存在，隨著類的消失而消失。生命周期長。
            成員變量隨著對象的創建而存在，隨著對象的消失而消失。
        D：與對象的相關性
            靜態變量是所有對象共享的數據。
            成員變量是每個對象所特有的數據。
    (5)靜態的優點和弊端
        優點：
        對對象的共享數據進行單獨空間的存儲，節省內存，沒有必要每個對象都存儲一份
        可直接被類名調用
        弊端：
        生命周期過長，隨著類的消失而消失
        訪問出現權限，即靜態雖好但只能訪問靜態
    (6)什么使用使用靜態呢？
        A:當所有對象共享某個數據的時候，就把這個成員變量定義為靜態修飾的。
        B:當某個方法沒有訪問該類中的非靜態成員，就可以把這個方法定義為靜態修飾。

        靜態的生命周期比較長，所以一般不推薦使用。
    (7)靜態代碼塊
        A:它只執行一次，它比main還先執行。
        B:執行順序
            靜態代碼塊--構造代碼塊--構造方法

12、制作API(次重點)

    API(全拼):Application Program Interface 應用程序編程接口。
    (1)類中的內容需要用文檔注釋。
    (2)使用JDK\bin目錄下的javadoc工具。
        格式:javadoc -d 目錄 -author -version ArrayTool.java

13、單例設計模式：

    (1)設計模式：
        解決某類問題行之有效的方法，是一種思想，是規律的總結
    (2)用來保證某個類在內存中只有一個對象
    (3)保證唯一性的思想及步驟
        **為了避免其他程序建立該類對象，先禁止其他程序建立該類對象，即將構造函數私有化
        **為了其他程序訪問到該類對象，須在本類中創建一個該類私有對象
        **為了方便其他程序訪問到該類對象，可對外提供一個公共訪問方式

    比如API中的Runtime類就是單例設計模式。

    (4)單例設計模式的兩種方式
        A:餓漢式 當類加載的時候，就創建對象。    
        class Student
        {
            private Student(){}
            
            private static final Student s = new Student();
            
            public static Student getInstance()
            {
                return s;
            }
        }
        B:懶漢式 當使用的使用，才去創建對象。
        class Student
        {
            private Student(){}

            private static final Student s = null;
            
            public static Student getInstance()
            {
                if(s==null) 
                {
                    //線程1就進來了，線程2就進來了。
                    s = new Student();
                }
                return s;
            }
        }
    餓漢式和懶漢式的區別：
        **
        餓漢式是類一加載進內存就創建好了對象；
        懶漢式則是類才加載進內存的時候，對象還沒有存在，只有調用了getInstance()方法時，
        對象才開始創建。
        **
        懶漢式是延遲加載，如果多個線程同時操作懶漢式時就有可能出現線程安全問題，解決線程安全問題
        可以加同步來解決。但是加了同步之后，每一次都要比較鎖，效率就變慢了，
        所以可以加雙重判斷來提高程序效率。
        注：開發常用餓漢式，因為餓漢式簡單安全。懶漢式多線程的時候容易發生問題

14、Math類的使用(重點)

    (1)數學操作類:該類沒有構造函數，方法均為靜態的   
    (2)掌握內容
        A:成員變量
            **E：比任何其他值都更接近e（即自然對數的底數）的double值。
            **PI：比任何其他值都更接近pi（即圓的周長與直徑之比）的double值。
        B:成員方法
            **static double abs(double a) 
                返回 double 值的絕對值。返回絕對值
            **static double ceil(double a) 
                返回最小的（最接近負無窮大）double 值，該值大于等于參數，并等于某個整數。 
            **static double floor(double a) 
                返回最大的（最接近正無窮大）double 值，該值小于等于參數，并等于某個整數。 
            **max：返回兩個值中較大的那個
            **min：返回兩個值中較小的那個
            **static long round(double a) 返回最接近參數的 long。
              static int round(float a) 返回最接近參數的 int。 
            **static double random() 
                返回帶正號的 double 值，該值大于等于 0.0 且小于 1.0。 
            **static double pow(double a, double b) 
                返回第一個參數的第二個參數次冪的值。 
            **static double sqrt(double a) 
                 返回正確舍入的 double 值的正平方根。

15、Random類的使用(重點)

(1)產生隨機數的類
(2)掌握內容
    A:構造方法
        **Random() 創建一個新的隨機數生成器。 
        **Random(long seed) 使用單個 long 種子創建一個新的隨機數生成器。
    B:成員方法
        **int nextInt() 返回下一個偽隨機數，它是此隨機數生成器的序列中均勻分布的 int 值。 
        **int nextInt(int n) 返回一個偽隨機數，它是取自此隨機數生成器序列的、
        在 0（包括）和指定值（不包括）之間均勻分布的 int 值。

16、Scanner類的使用

    (1)可以獲取從鍵盤的輸入數據
    (2)掌握內容
        構造方法：
            Scanner(InputStream source) 構造一個新的 Scanner，它生成的值是從指定的輸入流掃描的。
            如：Scanner sc = new Scanner(System.in);
        方法摘要
            sc.nextInt();獲取整型數據
            sc.nextLine();獲取字符串數據

17、繼承(重點)

    (1)把很多類的相同特征和行為進行抽取，用一個類來描述。讓多個類和這個類產生一個關系。
       這樣的話，多個類就可以省略很多代碼。這個關系就是繼承。java中用extends關鍵字表示。
    (2)繼承的體系結構
        A:多個具體的對象，不斷的向上抽取共享的內容，最終形成了一個體系。這個體系叫做繼承體系。
        B:繼承體系的學習和使用原則
            **學習頂層的內容。因為他是整個體系的共性內容。
            **創建子類使用。也就是使用底層的具體對象。
    (3)繼承的特點:
        A:java中只能單繼承，沒有多繼承。
        B:java可以有多重(層)繼承。
    (4)繼承的好處：
        繼承的出現提高了代碼的復用性。
        繼承的出現讓類與類之間產生了關系，提供了多態的前提。
    (5)子父類中的成員關系
        A:成員變量
            在子類方法中使用一個變量時：
            首先，在方法的局部變量中找這個變量，有則使用。
            否則，在本類中找成員變量，有則使用。
            否則，在父類中找成員變量，有則使用。
            否則，報錯。
        B:成員方法
            用子類對象使用一個方法時。
            首先，在子類中找這個方法，有則使用。
            否則，在父類中找這個方法，有則使用。
            否則，報錯。

        重寫和重載的區別？
            重載：在同一類中。方法名相同，參數列表不同。重載可以改變返回類型。
            重寫：在不同類中(子父類中)。
              方法聲明相同(返回類型，方法名，參數列表均相同)。
        重寫需要注意：
            **子類方法的訪問權限要大于等于父類方法的訪問權限。
            **靜態只能重寫靜態。但是這種情況一般不會出現。

        構造方法
            **子類的實例化過程
                ***子類創建對象時，會先去創建父類的對象。
                默認是去調用父類的無參構造方法。
                ***子類構造方法中，第一行默認是super()
                ***為什么子類中第一行會默認有super()
                    因為他繼承父類的成員使用，使用前這些成員必須初始化，
                    而他們是父類的成員，所以，必須通過父類進行初始化。
                    所以，會先創建一個父類的對象。
            **當父類沒有無參構造方法時
                必須使用this或者super調用其他的構造方法。
    (6)this和super的區別
        this:代表本類對象的引用。
        super:代表父類的存儲空間。

18、final關鍵字(重點)

    (1)最終的意思，可以用于修飾類，方法，變量。
    (2)final修飾的類不能被繼承。
       final修飾的方法不能被重寫。
       final修飾的變量是一個常量。只能被賦值一次。
       內部類只能訪問被final修飾的局部變量。

19、抽象類(重點)

    (1)多個類有相同的方法聲明，但是方法體不一樣。這個時候，我們考慮把方法聲明進行抽取。
       讓子類繼承后，自己去實現方法體。沒有方法體的方法，我們需要用抽象標志下。
       抽象的關鍵字是：abstract。
    (2)抽象類：
        該方法稱為抽象方法，包含抽象方法的類就是抽象類。
    (3)抽象類的特點：
        A:抽象類和抽象方法都要用abstract進行修飾
        B:抽象類不能被實例化
        C:抽象類中不一定有抽象方法，但是，有抽象方法的類一定是抽象類。
    (4)抽象類中數據的特點
        A:成員變量
            抽象類中可以有變量，也可以有常量。
        B:成員方法
            抽象類中可以有抽象方法，也可以有非抽象方法。
        C:構造方法
            抽象類是一個類，所以，它有構造方法。
            雖然本身不能實例化。但是可以給子類實例化使用。
    (5)抽象類中的問題
        A:抽象類中是否有構造方法？能不能被實例化？如果不能，為什么有構造方法？
          抽象類有構造方法。
      抽象類不能被實例化。
          抽象類中的構造方法供子類實例化調用。
        B:抽象關鍵字abstract不可以和哪些關鍵字共存？
          **private:
            私有內容子類繼承不到，所以，不能重寫。
            但是abstract修飾的方法，要求被重寫。兩者沖突。
      **final
            final修飾的方法不能被重寫。
            而abstract修飾的方法，要求被重寫。兩者沖突。          
          **static
            假如一個抽象方法能通過static修飾，那么這個方法，就可以直接通過類名調用。
            而抽象方法是沒有方法體的，這樣的調用無意義。所以，不能用static修飾。
        C:抽象類中可不可以沒有抽象方法？如果可以，這樣的類有什么用嗎？
          抽象類可以沒有抽象方法。
          抽象類中沒有抽象方法的作用，只是為了不讓別的類建立該抽象類對象。這個在awt中有體現。

20、接口interface

    (1)當一個類中的方法都是抽象的時候，java提供了另一種表示方式，叫接口。
       用interface關鍵字表示。類與接口關系用implements表示。
    (2)接口的成員特點
        A:成員變量
            是常量，默認修飾 public static final    
        B:成員方法
            都是抽象的，默認修飾 public abstract  
    (3)關系
        A:類與類的關系
            是繼承關系。類與類只能單繼承，可以多重繼承。
        B:類和接口的關系
            是實現關系。類可以多實現接口。
            類在繼承一個類的同時，可以實現多個接口。
        C:接口和接口的關系
            是繼承關系。接口可以多繼承接口。
    (4)接口的特點
        A:是對外暴露的規則
        B:是功能的擴展
        C:接口的出現降低耦合性。
            耦合(類與類之間的關系)
            內聚(類完成功能的能力)
            編程規范：低耦合，高內聚。
        D:接口可以多實現。如：CPU和主板、筆記本的USB插口、插座
    (5)接口和抽象類的區別
        A：抽象類只能被單繼承
           接口可以多實現,接口的出現避免了多繼承的局限性。
        B：抽象類中的數據特點：
                成員變量：可以是變量，也可以是常量
                成員方法：可以是抽象方法，也可以是非抽象方法
                構造方法：有構造方法
           接口中的數據特點：
                成員變量：是常量。默認修飾 public static final
                成員方法：都是抽象方法。都有默認修飾 public abstract
                構造方法：沒有構造方法
        C：抽象類中定義的是繼承體系中的共性功能。
           接口中定義的是繼承體系中的擴展功能。
        D：抽象類被繼承是"is a"關系:xx是yy的一種
           接口被實現是"like a"關系:xx像yy的一種

21、多態：

    (1)同一個對象，在程序不同時刻的多種運行狀態。舉例：動物，狗是狗，狗是動物。水(氣態，液態，固態)
    (2)多態前提
        A:存在著繼承或者實現關系
        B:有方法的重寫
        C:父類(接口)引用指向子類(實現)對象
    (3)多態的好處和弊端：
        好處：多態的存在提高了程序的擴展性和后期可維護性
        弊端：雖然可以預先使用，但是只能訪問父類中已有的功能，運行的是后期子類的功能內容。
          不能預先使用子類中定義的特有功能。
    (4)多態中對象調用成員的特點
        Fu f = new Zi();
        
        A:成員變量
            編譯看左邊，運行看左邊
        B:成員方法 
            編譯看左邊，運行看右邊
        C:靜態方法
            編譯看左邊，運行看左邊
    (5)多態的思想
        指揮同一批對象做事情。舉例：帶兵打仗，下課等。

22、instanceof關鍵字

        A:用于判斷某個對象是否是某種類型。
        B:格式
            對象名 instanceof 子類(實現)名

23、Object類：

    (1)是所有類的根類，超類。
       java中提供的類以及我們自定義的類都直接或者間接的繼承自Object類。
    (2)Object類中的方法
        A:void finalize() 
          當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。
        B:Class getClass()
          獲取對象的字節碼文件的描述類，后面再講反射的時候還會在說這個類。
          String name = s.getClass().getName();
        C:int hashCode()
          獲取對象的哈希值。其實就是對象的內存地址值十進制表示
        D:String toString()
          返回對象的字符串表示。
          表示格式：
          getClass().getName()+"@"+Integer.toHexString(hashCode());

          一般我們輸出對象名的時候，其實底層調用的就是該對象的toString()方法。
          這種返回沒有意義，所以，我們會重寫這個方法，顯示類的成員變量信息。
        E:boolean equals(Object obj)
          用于比較兩個對象的地址值是否相同。
          我們獲取對象后，比較它的地址值意義不大。所以也會對這個方法進行重寫。
          重寫要完成什么功能，是根據需求定的。
    (3)==和equals的用法：
        A:==怎么用？
            **可以用于比較基本數據類型，比較的就是基本數據類型的值是否相等。
            **可以用于比較引用數據類型，比較的是對象的地址值是否相等。
        B:equals怎么用？
            equals只能用于比較引用數據類型的。
            **Object提供的equals是用于比較對象地址值是否相同。
            **自定義類中，如果重寫了equals方法，那么就是按照你自己的需求來比較的。

24、package關鍵字

(1)包：其實就是文件夾。用于區分不同包下相同的類名。
(2)好處：
    A：對類文件進行分類管理。
    B：給類提供了多層命名空間
        aaa.Demo
        bbb.Demo
    C：寫在程序文件的第一行。
    D：包也是一種封裝形式。

25、import關鍵字

    (1)導入包的關鍵字
    (2)格式：
        import 包名;
    (3)注意：
        A:一個程序文件中只有一個package，可以有多個import。
        B:用來導包中的類，不導入包中的包。
        C:通常寫import  mypack.Demo，明確自己使用的類。  
    (4)關鍵字的順序
        類，包，導包這些關鍵的順序。
        包 -- >  到包 -- > 類

26、不同修飾符可以修飾哪些內容

            本類中 同一個包中 不同包中的子類中 不同包中
    private     OK  
    默認      OK  Ok      
    protected   OK  Ok  OK
    public      OK  Ok  OK      Ok

            類   構造方法    成員變量    成員方法        
    private         OK      OK      OK
    默認      Ok  Ok      Ok          OK
    protected       OK      OK      Ok
    public  Ok  Ok      OK          OK
    static                  OK      Ok
    final       Ok          OK      OK
    abstract    Ok                  OK

    一般格式：
        成員變量：
        權限修飾符+static/final+數據類型+成員變量名
        public static final int NUM = 10;
        
        成員方法：
        權限修飾符+static/final/abstract+返回類型+方法名

27、內部類(次重點)

    (1)把一個類定義在某個類中的，這個類就被稱為內部類，內置類，嵌套類。
    (2)訪問特點：
        A:內部類可以直接訪問外部類中的成員，因為內部類持有外部類的引用，
          格式為：外部類名.this
        B:外部類要想訪問內部類的成員，必須創建對象訪問。
    (3)內部類的訪問格式：
        A:當內部類定義在外部類的成員位置，而且非私有，則可以在其他外部類中直接建立內部類對象
          格式：外部類名.內部類名  變量名 = new 外部類對象.內部類對象
            如：Outer.Inner in = new Outer().new Inner()
        B:當內部類在外部類成員位置，且被static修飾時
            **外部其他類可直接訪問靜態內部類的非靜態成員
              格式：new 外部類名.內部類名().內部類成員
              如：new Outer.Inner().function();
            **外部其他類可直接訪問靜態內部類的靜態成員
              格式：new 外部類名.內部類名.內部類成員
              如：new Outer.Inner.function();
    (4)什么使用時候內部類呢？
        假如有A類和B類，A類想直接訪問B類的成員，B類訪問A類成員的時候，
        需要創建A類對象進行訪問，這個時候，就可以把A類定義為B類的內部類。
    (5)內部類的位置
        A:成員位置
            **可以被private修飾(Body，Heart)
            **可以被static修飾。(它訪問的外部類的成員必須是靜態的)    
        B:局部位置
            **可以直接訪問外部類中的成員，因為還持有外部類的持用
            也可以直接訪問局部成員，但是局部成員要用final修飾。      
        注意：局部內部類不能用private和static修飾     
    (6)通過class文件我們就可以區分是否帶有內部類，以及內部類的位置
        Outer$Inner:成員內部類
        Outer$1Inner:局部內部類

28、匿名內部類(局部內部類的簡寫) (重點)

        (1)前提：繼承一個類或者實現一個接口
        (注意不要弄混匿名內部類的前提和多態的前提)
        (2)格式：
            new 父類名或者接口名()
            {
                重寫父類方法或者實現接口中的方法。
                也可以自定義其他方法。
            };
        (3)什么時候定義匿名內部類？
            匿名內部類只是為了簡化書寫，匿名內部類有局限，通常定義匿名內部類時，該類方法不超過3個
        (4)匿名內部類的好處和弊端：
            好處：簡化代碼書寫
            弊端：
                不能直接調用自己的特有方法
                不能執行強轉換動作
                如果該類里面方法較多，不允許使用匿名內部類

29、模板設計模式：

    在定義功能時，功能的一部分是確定的，有一部分是不確定的，而且確定的部分在使用不確定的部分，
    可將不確定的部分暴露出去，由該類的子類去完成。
    如：求一段程序的運行時間例子。

30、異常

    (1)程序運行過程中的不正?，F象就叫異常。
    (2)導致程序運行不正常的現象有很多，所以，就有很多的異常對象。
       而這些異常對象存在著共性的內容，所以，可以不斷的進行抽取。最終形成了異常的體系結構。
       異常體系的根類是:Throwable
       Throwable：
        |--Error:重大的問題，我們處理不了。也不需要編寫代碼處理。比如說內存溢出。
        |--Exception:一般性的錯誤，是需要我們編寫代碼進行處理的。
            |--RuntimeException:運行時異常，這個我們也不需要處理。
            其實就是為了讓他在運行時出問題，然后我們回來修改代碼。
    (3)異常的分類        
        異常有兩種：
        編譯時被檢測異常：
            該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。
            該異常被標識，代表這可以被處理。
        運行時異常(編譯時不檢測)
            在編譯時，不需要處理，編譯器不檢查。
            該異常的發生，建議不處理，讓程序停止。需要對代碼進行修正。
    (4)異常體系的特點：
        異常體系中的所有類及其子類對象都具備可拋性。也就是說可以被throw和throws關鍵字所操作。
    (5)main方法是如何處理異常的。
        A:在main里面編寫代碼進行處理
        B:交給jvm自己進行處理。采用的是jvm的默認處理方式。
          其實就是相當于調用了異常對象的printStackTrace()方法。
    (6)Throwable類的學習
        getMessage():獲取異常信息，返回字符串。
        toString():獲取異常類名和異常信息，返回字符串。
        printStackTrace():獲取異常類名和異常信息，以及異常出現在程序中的位置。返回值void。
    (7)異常的處理·
        A:try...catch...finally
        基本格式：
            try
            {
                可能出現異常的代碼
            }
            catch(異常對象)
            {   
                異常處理代碼
            }
            finally
            {
                釋放資源
            }
        
        變形格式：
            try...catch
            try...catch...catch...
            try...catch...catch...finally
        **多個異常同時被捕獲的時候，記住一個原則：
            先逮小的，再逮大的。
        **finally:永遠被執行，除非退出jvm。System.exit(0);
            面試題2個。
            ***：final,finally,finalize區別。
               final是最終的意思。它可以用于修飾類，成員變量，成員方法。
               它修飾的類不能被繼承，它修飾的變量時常量，它修飾的方法不能被重寫。

               finally:是異常處理里面的關鍵字。
               它其中的代碼永遠被執行。特殊情況：在執行它之前jvm退出。System.exit(0);

               finalize:是Object類中的一個方法。
               它是于垃圾回收器調用的方式。

            ***：假如catch中有return語句， finally里中的代碼會執行嗎？
               是在return前，還是在return后呢？
               會，在return前執行finally里面的代碼。
    (8)Exception和RuntimeException的區別
        A:Exception:一般性的錯誤，是需要我們編寫代碼進行處理的。  
        B:RuntimeException:運行時異常，這個我們也不需要處理。
               其實就是為了讓他在運行時出問題，然后我們回來修改代碼。
            在用throws拋出一個的時候，如果這個異常是屬于RuntimeException的體系的時候，
            我們在調用的地方可以不用處理。(RuntimeException和RuntimeException的子類)
            
            在用throws拋出一個的時候，如果這個異常是屬于Exception的體系的時候，
            我們在調用的地方必須進行處理或者繼續拋出。
    (9)自定義異常
        定義類繼承Exception或者RuntimeException
        1,為了讓該自定義類具備可拋性。
        2，讓該類具備操作異常的共性方法。
        class MyExcepiton extends Exception
        {
            MyExcepiton(){}

            MyExcepiton(String message)
            {
                super(message);
            }
        }

        class MyException extends RuntimeException
        {
            MyExcepiton(){}

            MyExcepiton(String message)
            {
                super(message);
            }
        }
    (10)throws和throw的區別
        A：有throws的時候可以沒有throw。
           有throw的時候，如果throw拋的異常是Exception體系，那么必須有throws在方法上聲明。
        B：throws用于方法的聲明上，其后跟的是異常類名，后面可以跟多個異常類，之間用逗號隔開
           throw用于方法體中，其后跟的是一個異常對象名

三、多線程：

1、進程和線程：

    進程：正在進行的程序。每一個進程執行都有一個執行順序，該順序是一個執行路徑，或者叫一個控制單元。
    線程：進程內部的一條執行路徑或者一個控制單元。
    兩者的區別：
        一個進程至少有一個線程
        進程在執行過程中擁有獨立的內存單元，而多個線程共享內存；

2、jvm多線程的啟動是多線程嗎？

    java的虛擬機jvm啟動的是單線程，就有發生內存泄露的可能，而我們使用java程序沒出現這樣的問題，
    也就是jvm啟動至少有兩個線程，一個執行java程序，一個執行垃圾回收。所以是多線程。

2、多線程的優勢：

`解決了多部分同時運行的問題，提高效率`

3、線程的弊端：

`線程太多會導致效率的降低，因為線程的執行依靠的是CPU的來回切換。`

4、什么叫多線程：

    一個進程中有多個線程，稱為多線程。

5、實現多線程的方法：

    實現多線程可以通過繼承Thread類和實現Runnable接口。
    (1)繼承Thread
    定義一個類繼承Thread類
    復寫Thread類中的public void run()方法，將線程的任務代碼封裝到run方法中
    直接創建Thread的子類對象，創建線程
    調用start()方法，開啟線程(調用線程的任務run方法)
    //另外可以通過Thread的getName()獲取線程的名稱。

    (2)實現Runnable接口；
        定義一個類，實現Runnable接口；
        覆蓋接口的public void run()的方法，將線程的任務代碼封裝到run方法中；
        創建Runnable接口的子類對象
        將Runnabl接口的子類對象作為參數傳遞給Thread類的構造函數，創建Thread類對象
   （原因：線程的任務都封裝在Runnable接口子類對象的run方法中。
         所以要在線程對象創建時就必須明確要運行的任務）。
        調用start()方法，啟動線程。
    
    兩種方法區別：
        (1)實現Runnable接口避免了單繼承的局限性
        (2)繼承Thread類線程代碼存放在Thread子類的run方法中
           實現Runnable接口線程代碼存放在接口的子類的run方法中；
           在定義線程時，建議使用實現Runnable接口，因為幾乎所有多線程都可以使用這種方式實現

6、創建線程是為什么要復寫run方法？

    Thread類用于描述線程。Thread類定義了一個功能，用于存儲線程要運行的代碼，該存儲功能就是run方法。

7、start()和run方法有什么區別？

    調用start方法方可啟動線程，而run方法只是thread的一個普通方法，調用run方法不能實現多線程；
    Start()方法:
        start方法用來啟動線程,實現了多線程運行,這時無需等待run方法體代碼執行完畢而直接繼續執行下面的
        代碼。通過調用Thread類的start()方法來啟動一個線程,這時此線程處于就緒(可運行)狀態，并沒有運行，
        一旦得到cpu時間片(執行權),就開始執行run()方法,這里方法run()稱為線程體，
        它包含了要執行的這個線程的內容，Run方法運行結束,此線程隨即終止。  
    Run()方法:
        run()方法只是Thread類的一個普通方法,如果直接調用Run方法,程序中依然只有主線程這一個線程,
        其程序執行路徑還是只有一條，還是要等待run方法體執行完畢后才可繼續執行下面的代碼，
        這樣就沒有達到多線程的目的。

8、線程的幾種狀態：

    新建：new一個Thread對象或者其子類對象就是創建一個線程，當一個線程對象被創建，但是沒有開啟，這個時候，
      只是對象線程對象開辟了內存空間和初始化數據。    
    就緒：新建的對象調用start方法，就開啟了線程，線程就到了就緒狀態。
      在這個狀態的線程對象，具有執行資格，沒有執行權。
    運行：當線程對象獲取到了CPU的資源。
      在這個狀態的線程對象，既有執行資格，也有執行權。
    凍結：運行過程中的線程由于某些原因(比如wait,sleep)，釋放了執行資格和執行權。
  當然，他們可以回到運行狀態。只不過，不是直接回到。
      而是先回到就緒狀態。
    死亡：當線程對象調用的run方法結束，或者直接調用stop方法，就讓線程對象死亡，在內存中變成了垃圾。

9、sleep()和wait()的區別：

     (1)這兩個方法來自不同的類，sleep()來自Thread類，和wait()來自Object類。
     (2)sleep是Thread的靜態類方法，誰調用的誰去睡覺，即使在a線程里調用了b的sleep方法，實際上還是a去睡覺，
    要讓b線程睡覺要在b的代碼中調用sleep。而wait()是Object類的非靜態方法
     (3)sleep()釋放資源不釋放鎖，而wait()釋放資源釋放鎖；
     (4)使用范圍：wait,notify和notifyAll只能在同步控制方法或者同步控制塊里面使用,而sleep可以在任何地方使用

10、多線程安全問題：

    (1)原因:當程序的多條語句在操作線程共享數據時(如買票例子中的票就是共享資源)，由于線程的隨機性導致
    一個線程對多條語句，執行了一部分還沒執行完，另一個線程搶奪到cpu執行權參與進來執行，
    此時就導致共享數據發生錯誤。比如買票例子中打印重票和錯票的情況。    
    (2)解決方法:對多條操作共享數據的語句進行同步，一個線程在執行過程中其他線程不可以參與進來

11、Java中多線程同步是什么？

     同步是用來解決多線程的安全問題的，在多線程中，同步能控制對共享數據的訪問。如果沒有同步，當一個線程在
     修改一個共享數據時，而另外一個線程正在使用或者更新同一個共享數據，這樣容易導致程序出現錯誤的結果。 

12、什么是鎖?鎖的作用是什么?

    鎖就是對象
    鎖的作用是保證線程同步，解決線程安全問題。
    持有鎖的線程可以在同步中執行，沒有鎖的線程即使獲得cpu執行權，也進不去。

13、同步的前提:

    (1)必須保證有兩個以上線程
    (2)必須是多個線程使用同一個鎖，即多條語句在操作線程共享數據
    (3)必須保證同步中只有一個線程在運行

14、同步的好處和弊端

    好處：同步解決了多線程的安全問題
    弊端：多線程都需要判斷鎖，比較消耗資源

15、同步的兩種表現形式：

    (1)同步代碼塊:
        可以指定需要獲取哪個對象的同步鎖,使用synchronized的代碼塊同樣需要鎖,但他的鎖可以是任意對象
        考慮到安全問題，一般還是使用同一個對象，相對來說效率較高。

        注意：
        **雖然同步代碼快的鎖可以使任何對象，但是在進行多線程通信使用同步代碼快時，
          必須保證同步代碼快的鎖的對象和，否則會報錯。
        **同步函數的鎖是this，也要保證同步函數的鎖的對象和調用wait、notify和notifyAll的對象是
          同一個對象，也就是都是this鎖代表的對象。
        格式：
        synchronized(對象)
        {
            需同步的代碼;
        }
    (2)同步函數
        同步方法是指進入該方法時需要獲取this對象的同步鎖，在方法上使用synchronized關鍵字，
        使用this對象作為鎖，也就是使用了當前對象，因為鎖住了方法，所以相對于代碼塊來說效率相對較低。
        注:靜態同步函數的鎖是該方法所在的類的字節碼文件對象，即類名.class文件
        格式：
        修飾詞 synchronized 返回值類型 函數名(參數列表)
        {
            需同步的代碼;
        }

    在jdk1.5后，用lock鎖取代了synchronized，個人理解也就是對同步代碼塊做了修改，
    并沒有提供對同步方法的修改，主要還是效率問題吧。

16、多線程的單例設計模式：保證某個類中內存中只有一個對象

(1)餓漢式:
        class Single
        {
            private Single(){}//將構造函數私有化，不讓別的類建立該類對象
            private static final Single s=new Single();//自己建立一個對象
            public static Single getInstance()//提供一個公共訪問方式
            {
                return s;
            }
        }
    (2)懶漢式：
        class Single
        {
            private Single(){} 
            private static Single s;
            public static Single getInstance()
            {
                if(s==null)
                    s=new Single();
                return s;
            }
        }
    餓漢式和懶漢式的區別：
        **
        餓漢式是類一加載進內存就創建好了對象；
        懶漢式則是類加載進內存的時候，對象還沒有存在，只有調用了getInstance()方法時，對象才開始創建。   
        **
        懶漢式是延遲加載，如果多個線程同時操作懶漢式時就有可能出現線程安全問題，解決線程安全問題
        可以加同步來解決。但是加了同步之后，每一次都要比較鎖，效率就變慢了，
        所以可以加雙重判斷來提高程序效率。
        如將上述懶漢式的Instance函數改成同步：
        public static Single getInstance()
        {
            if(s==null)
            {
                synchronized(Single.class)
                {
                    if(s==null) 
                        s=new Single();
                }
            }
            return s;
        }

17、死鎖

`兩個線程對兩個同步對象具有循環依賴時，就會發生死鎖。即同步嵌套同步，而鎖卻不同。`

18、wait()、sleep()、notify()、notifyAll()

    wait():使一個線程處于等待狀態，并且釋放所持有的對象的lock。 
    sleep():使一個正在運行的線程處于睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException異常。 
    notify():喚醒一個處于等待狀態的線程，注意的是在調用此方法的時候，并不能確切的喚醒某一個等待狀態的線程，
         而是由JVM確定喚醒哪個線程(一般是最先開始等待的線程)，而且不是按優先級。 
    Allnotity():喚醒所有處入等待狀態的線程，注意并不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。

18、為什么wait()、notify()、notifyAll()這些用來操作線程的方法定義在Object類中？

    (1)這些方法只存在于同步中；
    (2)使用這些方法時必須要指定所屬的鎖，即被哪個鎖調用這些方法；
    (3)而鎖可以是任意對象，所以任意對象調用的方法就定義在Object中。

19、多線程間通訊：

    多線程間通訊就是多個線程在操作同一資源,但是操作的動作不同.
(1)為什么要通信
        多線程并發執行的時候, 如果需要指定線程等待或者喚醒指定線程, 那么就需要通信.比如生產者消費者的問題，
        生產一個消費一個,生產的時候需要負責消費的進程等待,生產一個后完成后需要喚醒負責消費的線程,
        同時讓自己處于等待，消費的時候負責消費的線程被喚醒，消費完生產的產品后又將等待的生產線程喚醒，
        然后使自己線程處于等待。這樣來回通信，以達到生產一個消費一個的目的。      
(2)怎么通信
        在同步代碼塊中, 使用鎖對象的wait()方法可以讓當前線程等待, 直到有其他線程喚醒為止.
        使用鎖對象的notify()方法可以喚醒一個等待的線程，或者notifyAll喚醒所有等待的線程.
        多線程間通信用sleep很難實現，睡眠時間很難把握。

20、Lock和Condition

    實現提供比synchronized方法和語句可獲得的更廣泛的鎖的操作，可支持多個相關的Condition對象
    Lock是個接口
    鎖是控制多個線程對共享數據進行訪問的工具。

    JDK1.5中提供了多線程升級的解決方案：
    將同步synchonized替換成了顯示的Lock操作，將Object中的wait、notify、notifyAll替換成了Condition對象。
    該對象可以Lock鎖進行獲取

    Lock的方法摘要：
        void lock()  獲取鎖。 
        Condition newCondition() 返回綁定到此 Lock 實例的新 Condition 實例。 
        void unlock() 釋放鎖。
    Condition方法摘要：
        void await() 造成當前線程在接到信號或被中斷之前一直處于等待狀態。
        void signal() 喚醒一個等待線程。  
        void signalAll() 喚醒所有等待線程。

21、停止線程：

    stop方法已經過時，如何停止線程？
        停止線程的方法只有一種，就是run方法結束。如何讓run方法結束呢？
        開啟多線程運行，運行代碼通常是循環體，只要控制住循環，就可以讓run方法結束，也就是結束線程。

        特殊情況：當線程屬于凍結狀態，就不會讀取循環控制標記，則線程就不會結束。
        為解決該特殊情況，可引入Thread類中的Interrupt方法結束線程的凍結狀態；
        當沒有指定的方式讓凍結線程恢復到運行狀態時，需要對凍結進行清除，強制讓線程恢復到運行狀態

22、interrupt:

    void interrupt() 中斷線程: 
        中斷狀態將被清除，它還將收到一個 InterruptedException

22、守護線程(后臺線程)

    setDaemon(boolean on):將該線程標記為守護線程或者用戶線程。
                當主線程結束，守護線程自動結束，比如圣斗士星矢里面的守護雅典娜，
                在多線程里面主線程就是雅典娜，守護線程就是圣斗士，主線程結束了，
                守護線程則自動結束。
    當正在運行的線程都是守護線程時，java虛擬機jvm退出；所以該方法必須在啟動線程前調用；

    守護線程的特點：
        守護線程開啟后和前臺線程共同搶奪cpu的執行權，開啟、運行兩者都沒區別，
        但結束時有區別，當所有前臺線程都結束后，守護線程會自動結束。

23、多線程join方法：

    void join() 等待該線程終止。
    void join(long millis)  等待該線程終止的時間最長為 millis 毫秒。
        throws InterruptedException 
    特點：當A線程執行到B線程的join方法時，A就會等待B線程都執行完，A才會執行
    作用: join可以用來臨時加入線程執行；

24、多線程優先級：yield()方法

    yield():暫停當前正在執行的線程對象，并執行其他線程
    setPriority(int newPriority):更改線程優先級
    int getPriority() 返回線程的優先級。
    String toString() 返回該線程的字符串表示形式，包括線程名稱、優先級和線程組
   
    (1)MAX_PRIORITY:最高優先級(10級)
    (1)Min_PRIORITY:最低優先級(1級)
    (1)Morm_PRIORITY:默認優先級(5級)

25、什么是ThreadLocal類,怎么使用它？

    ThreadLocal類提供了線程局部 (thread-local) 變量。是一個線程級別的局部變量，并非“本地線程”。
    ThreadLocal 為每個使用該變量的線程,提供了一個獨立的變量副本，每個線程修改副本時不影響其它線程對象的副本

    下面是線程局部變量(ThreadLocal variables)的關鍵點：
        一個線程局部變量(ThreadLocal variables)為每個線程方便地提供了一個單獨的變量。
        ThreadLocal 實例通常作為靜態的私有的(private static)字段出現在一個類中，這個類用來關聯一個線程。 
        當多個線程訪問 ThreadLocal 實例時，每個線程維護 ThreadLocal 提供的獨立的變量副本。
        常用的使用可在 DAO 模式中見到，當 DAO 類作為一個單例類時，
        數據庫鏈接(connection)被每一個線程獨立的維護，互不影響。(基于線程的單例)

26、什么時候拋出InvalidMonitorStateException異常?為什么？

    調用 wait ()/notify ()/notifyAll ()中的任何一個方法時，如果當前線程沒有獲得該對象的鎖，
    那么就會拋出 IllegalMonitorStateException 的異常
    也就是說程序在沒有執行對象的任何同步塊或者同步方法時，
    仍然嘗試調用 wait ()/notify ()/notifyAll ()時。由于該異常是 RuntimeExcpetion 的子類，
    所以該異常不一定要捕獲(盡管你可以捕獲只要你愿意
    作為 RuntimeException，此類異常不會在 wait (),notify (),notifyAll ()的方法簽名提及。 

27、在靜態方法上使用同步時會發生什么事？

    同步靜態方法時會獲取該類的“Class”對象，所以當一個線程進入同步的靜態方法中時，
    線程監視器獲取類本身的對象鎖，其它線程不能進入這個類的任何靜態同步方法。
    它不像實例方法，因為多個線程可以同時訪問不同實例同步實例方法。

28、當一個同步方法已經執行，線程能夠調用對象上的非同步實例方法嗎？

可以，一個非同步方法總是可以被調用而不會有任何問題。
實際上，Java 沒有為非同步方法做任何檢查，鎖對象僅僅在同步方法或者同步代碼塊中檢查。
如果一個方法沒有聲明為同步，即使你在使用共享數據Java照樣會調用，而不會做檢查是否安全，
所以在這種情況下要特別小心。一個方法是否聲明為同步取決于臨界區訪問(critial section access)，
如果方法不訪問臨界區(共享資源或者數據結構)就沒必要聲明為同步的。

29、在一個對象上兩個線程可以調用兩個不同的同步實例方法嗎？

    不能，因為一個對象已經同步了實例方法，線程獲取了對象的對象鎖。
    所以只有執行完該方法釋放對象鎖后才能執行其它同步方法。

30、什么是線程餓死，什么是活鎖？

    線程餓死和活鎖雖然不像死鎖一樣是常見的問題，但是對于并發編程的設計者來說就像一次邂逅一樣。
    當所有線程阻塞，或者由于需要的資源無效而不能處理，不存在非阻塞線程使資源可用。
    JavaAPI 中線程活鎖可能發生在以下情形：
    當所有線程在程序中執行 Object.wait (0)，參數為 0 的 wait 方法。
    程序將發生活鎖直到在相應的對象上有線程調用 Object.notify ()或者 Object.notifyAll ()。
當所有線程卡在無限循環中。