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

寫程式碼：

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

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

3，確定步驟。每一個思路部分用到哪些語句，方法，和物件。

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

學習新技術的四點：

1，該技術是什麼？

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

3，該技術怎麼使用。demo

4，該技術什麼時候用？test。

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

接 口：★★★★★

　　1：是用關鍵字interface定義的。

　　2：介面中包含的成員，最常見的有全域性常量、抽象方法。

　　　　注意：介面中的成員都有固定的修飾符。

　　　　成員變數：public static final 

　　　　成員方法：public abstract 

　　　　interface Inter{

　　　　　　public static final int x = 3;

　　　　　　public abstract void show();

}

　　3：介面中有抽象方法，說明介面不可以例項化。介面的子類必須實現了介面中所有的抽象方法後，該子類才可以例項化。否則，該子類還是一個抽象類。

　　4：類與類之間存在著繼承關係，類與介面中間存在的是實現關係。

　　　　繼承用extends  ；實現用implements ；

　　5：介面和類不一樣的地方，就是，介面可以被多實現，這就是多繼承改良後的結果。java將多繼承機制通過多現實來體現。 

　　6：一個類在繼承另一個類的同時，還可以實現多個介面。所以介面的出現避免了單繼承的侷限性。還可以將類進行功能的擴充套件。

　　7：其實java中是有多繼承的。介面與介面之間存在著繼承關係，介面可以多繼承介面。

　　介面都用於設計上，設計上的特點：（可以理解主機板上提供的介面）

　　　　1：介面是對外提供的規則。

　　　　2：介面是功能的擴充套件。

　　　　3：介面的出現降低了耦合性。

　　抽象類與介面：

　　抽象類：一般用於描述一個體系單元，將一組共性內容進行抽取，特點：可以在類中定義抽象內容讓子類實現，可以定義非抽象內容讓子類直接使用。它裡面定義的都是一些體系中的基本內容。

　　介面：一般用於定義物件的擴充套件功能，是在繼承之外還需這個物件具備的一些功能。

　　抽象類和介面的共性：都是不斷向上抽取的結果。

　　抽象類和介面的區別：

　　　　1：抽象類只能被繼承，而且只能單繼承。

　　　　　　介面需要被實現，而且可以多實現。 

　　　　2：抽象類中可以定義非抽象方法，子類可以直接繼承使用。

　　　　　　介面中都有抽象方法，需要子類去實現。

　　　　3：抽象類使用的是  is a 關係。

　　　　　　介面使用的 like a 關係。 

　　　　4：抽象類的成員修飾符可以自定義。

　　　　　　介面中的成員修飾符是固定的。全都是public的。

　　在開發之前，先定義規則，A和B分別開發，A負責實現這個規則，B負責使用這個規則。至於A是如何對規則具體實現的，B是不需要知道的。這樣這個介面的出現就降低了A和B直接耦合性。 

——————————————————————————————————————————————————————

多 態★★★★★（面向物件特徵之一）：函式本身就具備多型性，某一種事物有不同的具體的體現。

　　體現：父類引用或者介面的引用指向了自己的子類物件。//Animal a = new Cat();

　　多型的好處：提高了程式的擴充套件性。

　　多型的弊端：當父類引用指向子類物件時，雖然提高了擴充套件性，但是隻能訪問父類中具備的方法，不可以訪問子類中特有的方法。(前期不能使用後期產生的功能，即訪問的侷限性)

　　多型的前提：

　　　　1：必須要有關係，比如繼承、或者實現。

　　　　2：通常會有覆蓋操作。

　　多型的出現思想上也做著變化：以前是建立物件並指揮物件做事情。有了多型以後，我們可以找到物件的共性型別，直接操作共性型別做事情即可，這樣可以指揮一批物件做事情，即通過操作父類或介面實現。

——————————————————————————————————————————————————————

　　class 畢姥爺{

　　　　void 講課(){

　　　　　　System.out.println("企業管理");

　　　　}

　　　　void 釣魚(){

　　　　　　System.out.println("釣魚");

　　　　}

　　}

　　class 畢老師 extends 畢姥爺{

　　　　void 講課(){

　　　　　　System.out.println("JAVA");

　　　　}

　　　　void 看電影(){

　　　　　　System.out.println("看電影");

　　　　}

　　}

　　class {

　　　　public static void main(String[] args) {

　　　　　　畢姥爺 x = new 畢老師(); //畢老師物件被提升為了畢姥爺型別。 

　　　　　　// x.講課();

　　　　　　// x.看電影();  //錯誤.

　　　　　　畢老師 y = (畢老師)x; //將畢姥爺型別強制轉換成畢老師型別。 

　　　　　　y.看電影();//在多型中，自始自終都是子類物件在做著型別的變化。

　　　　}

　　}

——————————————————————————————————————————————————————

　　如果想用子類物件的特有方法，如何判斷物件是哪個具體的子類型別呢？

　　　　可以可以通過一個關鍵字 instanceof ;//判斷物件是否實現了指定的介面或繼承了指定的類

　　格式：<物件 instanceof 型別> ，判斷一個物件是否所屬於指定的型別。

　　Student instanceof Person = true;//student繼承了person類

　　多型在子父類中的成員上的體現的特點：

　　　　1，成員變數：在多型中，子父類成員變數同名。

　　　　　　在編譯時期：參考的是引用型變數所屬的類中是否有呼叫的成員。（編譯時不產生物件，只檢查語法錯誤）

　　　　　　執行時期：也是參考引用型變數所屬的類中是否有呼叫的成員。

　　　　　　簡單一句話：無論編譯和執行，成員變數參考的都是引用變數所屬的類中的成員變數。

　　　　　　再說的更容易記憶一些：成員變數 ——— 編譯執行都看 = 左邊。

　　2，成員函式。

　　　　編譯時期：參考引用型變數所屬的類中是否有呼叫的方法。

　　　　執行事情：參考的是物件所屬的類中是否有呼叫的方法。

　　　　為什麼是這樣的呢？因為在子父類中，對於一模一樣的成員函式，有一個特性：覆蓋。

　　　　簡單一句：成員函式，編譯看引用型變數所屬的類，執行看物件所屬的類。

　　　　更簡單：成員函式 ——— 編譯看 = 左邊，執行看 = 右邊。

　　3，靜態函式。 

　　　　編譯時期：參考的是引用型變數所屬的類中是否有呼叫的成員。

　　　　執行時期：也是參考引用型變數所屬的類中是否有呼叫的成員。

　　　　為什麼是這樣的呢？因為靜態方法，其實不所屬於物件，而是所屬於該方法所在的類。

　　　　呼叫靜態的方法引用是哪個類的引用呼叫的就是哪個類中的靜態方法。

　　　　簡單說：靜態函式 ——— 編譯執行都看 = 左邊。

——————————————————————————————————————————————————————

——————java.lang.Object

　　Object：所有類的直接或者間接父類，Java認為所有的物件都具備一些基本的共性內容，這些內容可以不斷的向上抽取，最終就抽取到了一個最頂層的類中的，該類中定義的就是所有物件都具備的功能。

具體方法：

　　1，boolean equals(Object obj)：用於比較兩個物件是否相等，其實內部比較的就是兩個物件地址。

　　而根據物件的屬性不同，判斷物件是否相同的具體內容也不一樣。所以在定義類時，一般都會複寫equals方法，建立本類特有的判斷物件是否相同的依據。

　　public boolean equals(Object obj){

　　　　if(!(obj instanceof Person))

　　　　return false;

　　　　Person p = (Person)obj;

　　　　return this.age == p.age;

　　}

　　2，String toString()：將物件變成字串；預設返回的格式：類名@雜湊值 = getClass().getName() + '@' + Integer.toHexString(hashCode())

　　為了物件對應的字串內容有意義，可以通過複寫，建立該類物件自己特有的字串表現形式。 

　　public String toString(){

　　　　return "person : "+age;

　　}

　　3，Class getClass()：獲取任意物件執行時的所屬位元組碼檔案物件。

　　4，int hashCode()：返回該物件的雜湊碼值。支援此方法是為了提高雜湊表的效能。

　　通常equals，toString，hashCode，在應用中都會被複寫，建立具體物件的特有的內容。

——————————————————————————————————————————————————————

　　內部類：如果A類需要直接訪問B類中的成員，而B類又需要建立A類的物件。這時,為了方便設計和訪問，直接將A類定義在B類中。就可以了。A類就稱為內部類。內部類可以直接訪問外部類中的成員。而外部類想要訪問內部類，必須要建立內部類的物件。

——————————————————————————————————————————————————————

class Outer{

　　int num = 4;

　　class  Inner {

　　　　void show(){

　　　　　　System.out.println("inner show run "+num);

　　　　}

　　}

　　public void method(){

　　Inner in = new Inner();//建立內部類的物件。

　　in.show();//呼叫內部類的方法。 

　　}

}

——————————————————————————————————————————————————————

　　當內部類定義在外部類中的成員位置上，可以使用一些成員修飾符修飾 private、static。

　　1：預設修飾符。

　　　　直接訪問內部類格式：外部類名.內部類名 變數名 =  外部類物件.內部類物件;

　　　　Outer.Inner in = new Outer.new Inner();//這種形式很少用。

　　　　但是這種應用不多見，因為內部類之所以定義在內部就是為了封裝。想要獲取內部類物件通常都通過外部類的方法來獲取。這樣可以對內部類物件進行控制。

　　2：私有修飾符。

　　　　通常內部類被封裝，都會被私有化，因為封裝性不讓其他程式直接訪問。 

　　3：靜態修飾符。

　　　　如果內部類被靜態修飾，相當於外部類，會出現訪問侷限性，只能訪問外部類中的靜態成員。

　　　　注意；如果內部類中定義了靜態成員，那麼該內部類必須是靜態的。

　　內部類編譯後的檔名為：“外部類名$內部類名.java”；

　　為什麼內部類可以直接訪問外部類中的成員呢？

　　　　那是因為內部中都持有一個外部類的引用。這個是引用是 外部類名.this 

　　　　內部類可以定義在外部類中的成員位置上，也可以定義在外部類中的區域性位置上。

　　　　當內部類被定義在區域性位置上，只能訪問區域性中被final修飾的區域性變數。

　　匿名內部類：沒有名字的內部類。就是內部類的簡化形式。一般只用一次就可以用這種形式。匿名內部類其實就是一個匿名子類物件。想要定義匿名內部類：需要前提，內部類必須繼承一個類或者實現介面。

　　匿名內部類的格式：new 父類名&介面名(){ 定義子類成員或者覆蓋父類方法 }.方法。

　　匿名內部類的使用場景：

　　　　當函式的引數是介面型別引用時，如果介面中的方法不超過3個。可以通過匿名內部類來完成引數的傳遞。

　　　　其實就是在建立匿名內部類時，該類中的封裝的方法不要過多，最好兩個或者兩個以內。

相關推薦