java基礎（號稱經典）

本人學習java時，作的java基礎知識總結：

因內容較多，提供原文連接下載。

無百度財富值的，能夠發郵件給我索取，個人郵箱：shixiaoquan520@163.com

 

寫代碼：

1，明確需求。我要作什麼？

2，分析思路。我要怎麼作？1,2,3。

3，肯定步驟。每個思路部分用到哪些語句，方法，和對象。

4，代碼實現。用具體的java語言代碼把思路體現出來。

 

學習新技術的四點：

1，該技術是什麼？

2，該技術有什麼特色(使用注意)：

3，該技術怎麼使用。demo

4，該技術何時用？test。

-----------------------------------------------------------------------------------------------

一：java概述：

1991 年Sun公司的James Gosling（詹姆斯·高斯林）等人開始開發名稱爲 Oak 的語言，但願用於控制嵌入在有線電視交換盒、PDA等的微處理器；

1994年將Oak語言改名爲Java；

 

Java的三種技術架構:

JAVAEE：Java Platform Enterprise Edition，開發企業環境下的應用程序，主要針對web程序開發；

JAVASE：Java Platform Standard Edition，完成桌面應用程序的開發，是其它二者的基礎；

JAVAME：Java Platform Micro Edition，開發電子消費產品和嵌入式設備，如手機中的程序；

 

1，JDK：Java Development Kit，java的開發和運行環境，java的開發工具和jre。

2，JRE：Java Runtime Environment，java程序的運行環境，java運行的所需的類庫+JVM(java虛擬機)。

3，配置環境變量：讓java jdk\bin目錄下的工具，能夠在任意目錄下運行，緣由是，將該工具所在目錄告訴了系統，當使用該工具時，由系統幫咱們去找指定的目錄。

環境變量的配置：

    1）：永久配置方式：JAVA_HOME=%安裝路徑%\Java\jdk

                      path=%JAVA_HOME%\bin

    2）：臨時配置方式：set path=%path%;C:\Program Files\Java\jdk\bin

特色：系統默認先去當前路徑下找要執行的程序，若是沒有，再去path中設置的路徑下找。

classpath的配置:

    1）：永久配置方式：classpath=.;c:\;e:\

    2）：臨時配置方式：set classpath=.;c:\;e:\

 

注意：在定義classpath環境變量時，須要注意的狀況

若是沒有定義環境變量classpath，java啓動jvm後，會在當前目錄下查找要運行的類文件；

若是指定了classpath，那麼會在指定的目錄下查找要運行的類文件。

還會在當前目錄找嗎？兩種狀況：

    1）：若是classpath的值結尾處有分號，在具體路徑中沒有找到運行的類，會默認在當前目錄再找一次。

    2）：若是classpath的值結果出沒有分號，在具體的路徑中沒有找到運行的類，不會再當前目錄找。

    通常不指定分號，若是沒有在指定目錄下找到要運行的類文件，就報錯，這樣能夠調試程序。

 

4，javac命令和java命令作什麼事情呢？

    要知道java是分兩部分的：一個是編譯，一個是運行。

    javac：負責的是編譯的部分，當執行javac時，會啓動java的編譯器程序。對指定擴展名的.java文件進行編譯。 生成了jvm能夠識別的字節碼文件。也就是class文件，也就是java的運行程序。

    java：負責運行的部分.會啓動jvm.加載運行時所需的類庫,並對class文件進行執行.

    一個文件要被執行,必需要有一個執行的起始點,這個起始點就是main函數.

----------------------------------------------------------------------------------------------

二：java語法基礎：

 

1，關鍵字：其實就是某種語言賦予了特殊含義的單詞。

    保留字：其實就是尚未賦予特殊含義，可是準備往後要使用過的單詞。

2，標示符：其實就是在程序中自定義的名詞。好比類名，變量名，函數名。包含 0-9、a-z、$、_ ；

    注意：

    1），數字不能夠開頭。

    2），不可使用關鍵字。

3，常量：是在程序中的不會變化的數據。

4，變量：其實就是內存中的一個存儲空間，用於存儲常量數據。

    做用：方便於運算。由於有些數據不肯定。因此肯定該數據的名詞和存儲空間。

    特色：變量空間能夠重複使用。

何時定義變量？只要是數據不肯定的時候，就定義變量。

 

變量空間的開闢須要什麼要素呢？

    1，這個空間要存儲什麼數據？數據類型。

    2，這個空間叫什麼名字啊？變量名稱。

    3，這個空間的第一次的數據是什麼？ 變量的初始化值。

 

變量的做用域和生存期:

變量的做用域：

    做用域從變量定義的位置開始，到該變量所在的那對大括號結束；

生命週期：

    變量從定義的位置開始就在內存中活了；

    變量到達它所在的做用域的時候就在內存中消失了；

 

數據類型：

    1）：基本數據類型：byte、short、int、long、float、double、char、boolean

    2）：引用數據類型: 數組、類、接口。

級別從低到高爲：byte,char,short(這三個平級)-->int-->float-->long-->double

自動類型轉換：從低級別到高級別，系統自動轉的；

強制類型轉換：什麼狀況下使用?把一個高級別的數賦給一個別該數的級別低的變量；

 

運算符號：

    1）、算術運算符。

        + - * / %   %:任何整數模2不是0就是1，因此只要改變被模數就能夠實現開關運算。

        +:鏈接符。

        ++,--

    2）、賦值運算符。

        =  += -= *= /= %=

    3）、比較運算符。

        特色：該運算符的特色是：運算完的結果，要麼是true，要麼是false。

    4）、邏輯運算符。

        &  |  ^  !   &&   ||

        邏輯運算符除了 !  外都是用於鏈接兩個boolean類型表達式。

        &: 只有兩邊都爲true結果是true。不然就是false。

        |:只要兩邊都爲false結果是false，不然就是true

        ^:異或：和或有點不同。

             兩邊結果同樣，就爲false。

             兩邊結果不同，就爲true.

        & 和 &&區別： & ：不管左邊結果是什麼，右邊都參與運算。

                      &&:短路與，若是左邊爲false，那麼右邊不參數與運算。

        | 和|| 區別：|：兩邊都運算。

                    ||：短路或，若是左邊爲true，那麼右邊不參與運算。

    5）、位運算符:用於操做二進制位的運算符。

        &  |  ^

        <<  >>   >>>(無符號右移)

    練習：對兩個變量的數據進行互換。不須要第三方變量。

            int a  = 3,b = 5;-->b = 3,a = 5;

            a = a + b; a = 8;

            b = a - b; b = 3;

            a = a - b; a = 5;

            a = a ^ b;//

            b = a ^ b;//b = a ^ b ^ b = a

            a = a ^ b;//a = a ^ b ^ a = b;

        練習：高效的算出 2*8 = 2<<3;

5，語句。

    If  switch  do while   while  for

    這些語句何時用？

    1）、當判斷固定個數的值的時候，可使用if，也可使用switch。

    可是建議使用switch，效率相對較高。

switch(變量){

   case 值:要執行的語句;break;

   …

   default:要執行的語句;

}

 工做原理：用小括號中的變量的值依次和case後面的值進行對比，和哪一個case後面的值相同了

           就執行哪一個case後面的語句，若是沒有相同的則執行default後面的語句；

 細節：1）：break是能夠省略的，若是省略了就一直執行到遇到break爲止；

       2）：switch 後面的小括號中的變量應該是byte,char,short,int四種類型中的一種；

       3）：default能夠寫在switch結構中的任意位置；若是將default語句放在了第一行，則無論expression與case中的value是否匹配，程序會從default開始執行直到第一個break出現。

    2）、當判斷數據範圍，獲取判斷運算結果boolean類型時，須要使用if。

    3）、當某些語句須要執行不少次時，就用循環結構。

    while和for能夠進行互換。

    區別在於：若是須要定義變量控制循環次數。建議使用for。由於for循環完畢，變量在內存中釋放。

 

break:做用於switch ，和循環語句，用於跳出，或者稱爲結束。

break語句單獨存在時，下面不要定義其餘語句，由於執行不到，編譯會失敗。當循環嵌套時，break只跳出當前所在循環。要跳出嵌套中的外部循環，只要給循環起名字便可，這個名字稱之爲標號。

 

continue:只做用於循環結構，繼續循環用的。

做用：結束本次循環，繼續下次循環。該語句單獨存在時，下面不能夠定義語句，執行不到。

 

6，函 數：爲了提升代碼的複用性，能夠將其定義成一個單獨的功能，該功能的體現就是java中的函數。函數就是體現之一。

java中的函數的定義格式：

    修飾符 返回值類型 函數名(參數類型 形式參數1，參數類型 形式參數1，…){

       執行語句；

       return 返回值；

    }

當函數沒有具體的返回值時，返回的返回值類型用void關鍵字表示。

若是函數的返回值類型是void時，return語句能夠省略不寫的，系統會幫你自動加上。

return的做用：結束函數。結束功能。

 

如何定義一個函數？

    函數其實就是一個功能，定義函數就是實現功能，經過兩個明確來完成：

    1）、明確該功能的運算完的結果，實際上是在明確這個函數的返回值類型。

    2）、在實現該功能的過程當中是否有未知內容參與了運算，其實就是在明確這個函數的參數列表(參數類型&參數個數)。

函數的做用：

1）、用於定義功能。

2）、用於封裝代碼提升代碼的複用性。

注意：函數中只能調用函數，不能定義函數。

主函數：

    1）、保證該類的獨立運行。

    2）、由於它是程序的入口。

    3）、由於它在被jvm調用。

 

函數定義名稱是爲何呢？

答：1）、爲了對該功能進行標示，方便於調用。

    2）、爲了經過名稱就能夠明確函數的功能，爲了增長代碼的閱讀性。

 

重載的定義是：在一個類中，若是出現了兩個或者兩個以上的同名函數，只要它們的參數的個數，或者參數的類型不一樣，便可稱之爲該函數重載了。

如何區分重載：當函數同名時，只看參數列表。和返回值類型不要緊。

 

7，數 組：用於存儲同一類型數據的一個容器。好處：能夠對該容器中的數據進行編號，從0開始。數組用於封裝數據，就是一個具體的實體。

如何在java中表現一個數組呢？兩種表現形式。

1）、元素類型[] 變量名 = new 元素類型[元素的個數]；

2）、元素類型[] 變量名 = {元素1，元素2...}；

元素類型[] 變量名 = new 元素類型[]{元素1，元素2...}；

---------------------------------------------------------

//二分查找法。必須有前提：數組中的元素要有序。

    public static int halfSeach_2(int[] arr,int key){

        int min,max,mid;

        min = 0;

        max = arr.length-1;

        mid = (max+min)>>1; //(max+min)/2;

        while(arr[mid]!=key){

            if(key>arr[mid]){

                min = mid + 1;

            }

            else if(key<arr[mid])

                max = mid - 1;

            if(max<min)

                return -1;

            mid = (max+min)>>1;

        }

        return mid;

    }

---------------------------------------------------------

java分了5片內存。

1：寄存器。2：本地方法區。3：方法區。4：棧。5：堆。

棧：存儲的都是局部變量 ( 函數中定義的變量，函數上的參數，語句中的變量 )；

    只要數據運算完成所在的區域結束，該數據就會被釋放。

堆：用於存儲數組和對象，也就是實體。啥是實體啊？就是用於封裝多個數據的。

1：每個實體都有內存首地址值。

2：堆內存中的變量都有默認初始化值。由於數據類型不一樣，值也不同。

3：垃圾回收機制。

----------------------------------------------------------------------------------------------

三：面向對象：★★★★★

特色：1：將複雜的事情簡單化。

2：面向對象將之前的過程當中的執行者，變成了指揮者。

3：面向對象這種思想是符合如今人們思考習慣的一種思想。

 

過程和對象在咱們的程序中是如何體現的呢？過程其實就是函數；對象是將函數等一些內容進行了封裝。

 

匿名對象使用場景：

1：當對方法只進行一次調用的時候，可使用匿名對象。

2：當對象對成員進行屢次調用時，不能使用匿名對象。必須給對象起名字。

 

在類中定義其實都稱之爲成員。成員有兩種：

1：成員變量：其實對應的就是事物的屬性。

2：成員函數：其實對應的就是事物的行爲。

 

因此，其實定義類，就是在定義成員變量和成員函數。可是在定義前，必須先要對事物進行屬性和行爲的分析，才能夠用代碼來體現。

 

private int age;//私有的訪問權限最低，只有在本類中的訪問有效。

注意：私有僅僅是封裝的一種體現形式而已。

 

私有的成員：其餘類不能直接建立對象訪問，因此只有經過本類對外提供具體的訪問方式來完成對私有的訪問，能夠經過對外提供函數的形式對其進行訪問。

好處：能夠在函數中加入邏輯判斷等操做，對數據進行判斷等操做。

 

總結：開發時，記住，屬性是用於存儲數據的，直接被訪問，容易出現安全隱患，因此，類中的屬性一般被私有化，並對外提供公共的訪問方法。

這個方法通常有兩個，規範寫法：對於屬性 xxx，可使用setXXX(),getXXX()對其進行操做。

 

類中怎麼沒有定義主函數呢？

注意：主函數的存在，僅爲該類是否須要獨立運行，若是不須要，主函數是不用定義的。

主函數的解釋：保證所在類的獨立運行，是程序的入口，被jvm調用。

 

成員變量和局部變量的區別：

1：成員變量直接定義在類中。

   局部變量定義在方法中，參數上，語句中。

2：成員變量在這個類中有效。

局部變量只在本身所屬的大括號內有效，大括號結束，局部變量失去做用域。

3：成員變量存在於堆內存中，隨着對象的產生而存在，消失而消失。

局部變量存在於棧內存中，隨着所屬區域的運行而存在，結束而釋放。

 

構造函數：用於給對象進行初始化，是給與之對應的對象進行初始化，它具備針對性，函數中的一種。

特色：

1：該函數的名稱和所在類的名稱相同。

2：不須要定義返回值類型。

3：該函數沒有具體的返回值。

記住：全部對象建立時，都須要初始化纔可使用。

 

注意事項：一個類在定義時，若是沒有定義過構造函數，那麼該類中會自動生成一個空參數的構造函數，爲了方便該類建立對象，完成初始化。若是在類中自定義了構造函數，那麼默認的構造函數就沒有了。

 

一個類中，能夠有多個構造函數，由於它們的函數名稱都相同，因此只能經過參數列表來區分。因此，一個類中若是出現多個構造函數。它們的存在是以重載體現的。

 

構造函數和通常函數有什麼區別呢？

1：兩個函數定義格式不一樣。

2：構造函數是在對象建立時，就被調用，用於初始化，並且初始化動做只執行一次。

    通常函數，是對象建立後，須要調用才執行，能夠被調用屢次。

  

何時使用構造函數呢？

分析事物時，發現具體事物一出現，就具有了一些特徵，那就將這些特徵定義到構造函數內。

 

構造代碼塊和構造函數有什麼區別？

構造代碼塊：是給全部的對象進行初始化，也就是說，全部的對象都會調用一個代碼塊，只要對象一創建，就會調用這個代碼塊。

構造函數：是給與之對應的對象進行初始化，它具備針對性。

 

「Person p = new Person();」

建立一個對象都在內存中作了什麼事情？

1：先將硬盤上指定位置的Person.class文件加載進內存。

2：執行main方法時，在棧內存中開闢了main方法的空間(壓棧-進棧)，而後在main方法的棧區分配了一個變量p。

3：在堆內存中開闢一個實體空間，分配了一個內存首地址值。new

4：在該實體空間中進行屬性的空間分配，並進行了默認初始化。

5：對空間中的屬性進行顯示初始化。

6：進行實體的構造代碼塊初始化。

7：調用該實體對應的構造函數，進行構造函數初始化。（）

8：將首地址賦值給p ，p變量就引用了該實體。(指向了該對象)

--------------------------------------------------------------------------------------------

封 裝（面向對象特徵之一）：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

好處：將變化隔離；便於使用；提升重用性；安全性。

封裝原則：將不須要對外提供的內容都隱藏起來，把屬性都隱藏，提供公共方法對其訪問。

 

This：表明對象，就是所在函數所屬對象的引用。

this到底表明什麼呢？哪一個對象調用了this所在的函數，this就表明哪一個對象，就是哪一個對象的引用。

開發時，何時使用this呢？

在定義功能時，若是該功能內部使用到了調用該功能的對象，這時就用this來表示這個對象。

 

this 還能夠用於構造函數間的調用。

調用格式：this(實際參數)；

this對象後面跟上 .  調用的是成員屬性和成員方法(通常方法)；

this對象後面跟上 () 調用的是本類中的對應參數的構造函數。

 

注意：用this調用構造函數，必須定義在構造函數的第一行。由於構造函數是用於初始化的，因此初始化動做必定要執行。不然編譯失敗。

 

static：★★★ 關鍵字，是一個修飾符，用於修飾成員(成員變量和成員函數)。

特色：

1，想要實現對象中的共性數據的對象共享，能夠將這個數據進行靜態修飾。

2，被靜態修飾的成員，能夠直接被類名所調用。也就是說，靜態的成員多了一種調用方式。類名.靜態方式。

3，靜態隨着類的加載而加載，並且優先於對象存在。

 

弊端：

1，有些數據是對象特有的數據，是不能夠被靜態修飾的。由於那樣的話，特有數據會變成對象的共享數據。這樣對事物的描述就出了問題。因此，在定義靜態時，必需要明確，這個數據是不是被對象所共享的。

2，靜態方法只能訪問靜態成員，不能夠訪問非靜態成員。

由於靜態方法加載時，優先於對象存在，因此沒有辦法訪問對象中的成員。

3，靜態方法中不能使用this，super關鍵字。

由於this表明對象，而靜態在時，有可能沒有對象，因此this沒法使用。

4，主函數是靜態的。

 

何時定義靜態成員呢？或者說：定義成員時，到底需不須要被靜態修飾呢？

成員分兩種：

1，成員變量。（數據共享時靜態化）

該成員變量的數據是不是全部對象都同樣：

若是是，那麼該變量須要被靜態修飾，由於是共享的數據。

若是不是，那麼就說這是對象的特有數據，要存儲到對象中。

2，成員函數。（方法中沒有調用特有數據時就定義成靜態）

    若是判斷成員函數是否須要被靜態修飾呢？

    只要參考，該函數內是否訪問了對象中的特有數據：

    若是有訪問特有數據，那方法不能被靜態修飾。

    若是沒有訪問過特有數據，那麼這個方法須要被靜態修飾。

 

成員變量和靜態變量的區別：

1，成員變量所屬於對象，因此也稱爲實例變量。

靜態變量所屬於類，因此也稱爲類變量。

2，成員變量存在於堆內存中。

靜態變量存在於方法區中。

3，成員變量隨着對象建立而存在，隨着對象被回收而消失。

靜態變量隨着類的加載而存在，隨着類的消失而消失。

4，成員變量只能被對象所調用。

靜態變量能夠被對象調用，也能夠被類名調用。

因此，成員變量能夠稱爲對象的特有數據，靜態變量稱爲對象的共享數據。

 

靜態的注意：靜態的生命週期很長。

靜態代碼塊：就是一個有靜態關鍵字標示的一個代碼塊區域，定義在類中。

做用：能夠完成類的初始化，靜態代碼塊隨着類的加載而執行，並且只執行一次（new 多個對象就只執行一次）。若是和主函數在同一類中，優先於主函數執行。

 

Public：訪問權限最大。

static：不須要對象，直接類名便可。

void：主函數沒有返回值。

Main：主函數特定的名稱。

(String[] args)：主函數的參數，是一個字符串數組類型的參數，jvm調用main方法時，傳遞的實際參數是 new String[0]。

 

jvm默認傳遞的是長度爲0的字符串數組，咱們在運行該類時，也能夠指定具體的參數進行傳遞。能夠在控制檯，運行該類時，在後面加入參數。參數之間經過空格隔開。jvm會自動將這些字符串參數做爲args數組中的元素，進行存儲。

 

靜態代碼塊、構造代碼塊、構造函數同時存在時的執行順序：靜態代碼塊 à 構造代碼塊 à 構造函數；

 

生成Java幫助文檔：命令格式：javadoc –d 文件夾名 –auther –version *.java

/**     //格式

*類描述

*@author  做者名

*@version  版本號

*/

/**

*方法描述

*@param   參數描述

*@return  返回值描述

*/

---------------------------------------------------------------------------------------------

設計模式：解決問題最行之有效的思想。是一套被反覆使用、多數人知曉的、通過分類編目的、代碼設計經驗的總結。使用設計模式是爲了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。

 

java中有23種設計模式：

單例設計模式：★★★★★

解決的問題：保證一個類在內存中的對象惟一性。

好比：多程序讀取一個配置文件時，建議配置文件封裝成對象。會方便操做其中數據，又要保證多個程序讀到的是同一個配置文件對象，就須要該配置文件對象在內存中是惟一的。

 

Runtime()方法就是單例設計模式進行設計的。

 

如何保證對象惟一性呢？

思想：

1，不讓其餘程序建立該類對象。

2，在本類中建立一個本類對象。

3，對外提供方法，讓其餘程序獲取這個對象。

 

步驟：

1，由於建立對象都須要構造函數初始化，只要將本類中的構造函數私有化，其餘程序就沒法再建立該類對象；

2，就在類中建立一個本類的對象；

3，定義一個方法，返回該對象，讓其餘程序能夠經過方法就獲得本類對象。（做用：可控）

 

代碼體現：

1，私有化構造函數；

2，建立私有並靜態的本類對象；

3，定義公有並靜態的方法，返回該對象。

---------------------------------------------

//餓漢式

class Single{

    private Single(){} //私有化構造函數。

private static Single s = new Single(); //建立私有並靜態的本類對象。

    public static Single getInstance(){ //定義公有並靜態的方法，返回該對象。

        return s;

    }

}

---------------------------------------------

//懶漢式:延遲加載方式。

class Single2{

    private Single2(){}

private static Single2 s = null;

    public static Single2 getInstance(){

        if(s==null)

            s = new Single2();

        return s;

    }

}

-------------------------------------------------------------------------------------------------

繼 承（面向對象特徵之一）

好處：

1：提升了代碼的複用性。

2：讓類與類之間產生了關係，提供了另外一個特徵多態的前提。

 

父類的由來：實際上是由多個類不斷向上抽取共性內容而來的。

java中對於繼承，java只支持單繼承。java雖然不直接支持多繼承，可是保留了這種多繼承機制，進行改良。

 

單繼承：一個類只能有一個父類。

多繼承：一個類能夠有多個父類。

 

爲何不支持多繼承呢？

由於當一個類同時繼承兩個父類時，兩個父類中有相同的功能，那麼子類對象調用該功能時，運行哪個呢？由於父類中的方法中存在方法體。

可是java支持多重繼承。A繼承B  B繼承C  C繼承D。

多重繼承的出現，就有了繼承體系。體系中的頂層父類是經過不斷向上抽取而來的。它裏面定義的該體系最基本最共性內容的功能。

因此，一個體系要想被使用，直接查閱該系統中的父類的功能便可知道該體系的基本用法。那麼想要使用一個體系時，須要創建對象。建議創建最子類對象，由於最子類不只可使用父類中的功能。還可使用子類特有的一些功能。

 

簡單說：對於一個繼承體系的使用，查閱頂層父類中的內容，建立最底層子類的對象。

 

子父類出現後，類中的成員都有了哪些特色：

1：成員變量。

     當子父類中出現同樣的屬性時，子類類型的對象，調用該屬性，值是子類的屬性值。

     若是想要調用父類中的屬性值，須要使用一個關鍵字：super

     This：表明是本類類型的對象引用。

     Super：表明是子類所屬的父類中的內存空間引用。

     注意：子父類中一般是不會出現同名成員變量的，由於父類中只要定義了，子類就不用在定義了，直接繼承過來用就能夠了。

2：成員函數。

當子父類中出現瞭如出一轍的方法時，創建子類對象會運行子類中的方法。好像父類中的方法被覆蓋掉同樣。因此這種狀況，是函數的另外一個特性：覆蓋(複寫，重寫)

何時使用覆蓋呢？當一個類的功能內容須要修改時，能夠經過覆蓋來實現。

3：構造函數。

發現子類構造函數運行時，先運行了父類的構造函數。爲何呢?

緣由：子類的全部構造函數中的第一行，其實都有一條隱身的語句super();

super(): 表示父類的構造函數，並會調用於參數相對應的父類中的構造函數。而super():是在調用父類中空參數的構造函數。

爲何子類對象初始化時，都須要調用父類中的函數？(爲何要在子類構造函數的第一行加入這個super()?)

由於子類繼承父類，會繼承到父類中的數據，因此必需要看父類是如何對本身的數據進行初始化的。因此子類在進行對象初始化時，先調用父類的構造函數，這就是子類的實例化過程。

 

注意：子類中全部的構造函數都會默認訪問父類中的空參數的構造函數，由於每個子類構造內第一行都有默認的語句super();

若是父類中沒有空參數的構造函數，那麼子類的構造函數內，必須經過super語句指定要訪問的父類中的構造函數。

若是子類構造函數中用this來指定調用子類本身的構造函數，那麼被調用的構造函數也同樣會訪問父類中的構造函數。

 

問題：super()和this()是否能夠同時出現的構造函數中。

兩個語句只能有一個定義在第一行，因此只能出現其中一個。

 

super()或者this():爲何必定要定義在第一行？

由於super()或者this()都是調用構造函數，構造函數用於初始化，因此初始化的動做要先完成。

 

繼承的細節：

何時使用繼承呢？

當類與類之間存在着所屬關係時，才具有了繼承的前提。a是b中的一種。a繼承b。狼是犬科中的一種。

英文書中，所屬關係：" is a "

注意：不要僅僅爲了獲取其餘類中的已有成員進行繼承。

 

因此判斷所屬關係，能夠簡單看，若是繼承後，被繼承的類中的功能，均可以被該子類所具有，那麼繼承成立。若是不是，不能夠繼承。

 

細節二：

在方法覆蓋時，注意兩點：

1：子類覆蓋父類時，必需要保證，子類方法的權限必須大於等於父類方法權限能夠實現繼承。不然，編譯失敗。

2：覆蓋時，要麼都靜態，要麼都不靜態。 (靜態只能覆蓋靜態，或者被靜態覆蓋)

 

繼承的一個弊端：打破了封裝性。對於一些類，或者類中功能，是須要被繼承，或者複寫的。

這時如何解決問題呢？介紹一個關鍵字，final:最終。

 

final特色：

1：這個關鍵字是一個修飾符，能夠修飾類，方法，變量。

2：被final修飾的類是一個最終類，不能夠被繼承。

3：被final修飾的方法是一個最終方法，不能夠被覆蓋。

4：被final修飾的變量是一個常量，只能賦值一次。

 

    其實這樣的緣由的就是給一些固定的數據起個閱讀性較強的名稱。

    不加final修飾不是也可使用嗎？那麼這個值是一個變量，是能夠更改的。加了final，程序更爲嚴謹。常量名稱定義時，有規範，全部字母都大寫，若是由多個單詞組成，中間用 _ 鏈接。

 

抽象類: abstract

抽象：不具體，看不明白。抽象類表象體現。

在不斷抽取過程當中，將共性內容中的方法聲明抽取，可是方法不同，沒有抽取，這時抽取到的方法，並不具體，須要被指定關鍵字abstract所標示，聲明爲抽象方法。

抽象方法所在類必定要標示爲抽象類，也就是說該類須要被abstract關鍵字所修飾。

 

抽象類的特色：

1：抽象方法只能定義在抽象類中，抽象類和抽象方法必須由abstract關鍵字修飾（能夠描述類和方法，不能夠描述變量）。

2：抽象方法只定義方法聲明，並不定義方法實現。

3：抽象類不能夠被建立對象(實例化)。

4：只有經過子類繼承抽象類並覆蓋了抽象類中的全部抽象方法後，該子類才能夠實例化。不然，該子類仍是一個抽象類。

 

抽象類的細節：

1：抽象類中是否有構造函數？有，用於給子類對象進行初始化。

2：抽象類中是否能夠定義非抽象方法？

    能夠。其實，抽象類和通常類沒有太大的區別，都是在描述事物，只不過抽象類在描述事物時，有些功能不具體。因此抽象類和通常類在定義上，都是須要定義屬性和行爲的。只不過，比通常類多了一個抽象函數。並且比通常類少了一個建立對象的部分。

3：抽象關鍵字abstract和哪些不能夠共存？final , private , static

4：抽象類中可不能夠不定義抽象方法？能夠。抽象方法目的僅僅爲了避免讓該類建立對象。

-----------------------------------------------------------------------------------------------

模板方法設計模式：

解決的問題：當功能內部一部分實現時肯定，一部分實現是不肯定的。這時能夠把不肯定的部分暴露出去，讓子類去實現。

abstract class GetTime{

    public final void getTime(){ //此功能若是不須要複寫，可加final限定

        long start = System.currentTimeMillis();

        code(); //不肯定的功能部分，提取出來，經過抽象方法實現

        long end = System.currentTimeMillis();

        System.out.println("毫秒是："+(end-start));

    }

    public abstract void code(); //抽象不肯定的功能，讓子類複寫實現

}

class SubDemo extends GetTime{

    public void code(){ //子類複寫功能方法

        for(int y=0; y<1000; y++){

            System.out.println("y");

        }

    }

}