[TOC] # 定義 創建java文件， 與類名相同 ~~~ public class 類名 { //可編寫0至n個屬性 數據類型 變量名1； 數據類型 變量名2； //可編寫0至n個方法 修飾符 返回值類型 方法名(參數){ 執行語句; } } ~~~ # 使用 導包：我們將所有的類放到同一個文件夾下，可以避免導包。 創建對象：數據類型 變量名 = new 數據類型(); 訪問屬性：變量名.屬性 # 局部變量和成員變量區別 區別一：定義的位置不同 定義在類中的變量是成員變量 定義在方法中或者{}語句里面的變量是局部變量 區別二：在內存中的位置不同 成員變量存儲在對內存的對象中 局部變量存儲在棧內存的方法中 區別三：聲明周期不同 成員變量隨著對象的出現而出現在堆中，隨著對象的消失而從堆中消失 局部變量隨著方法的運行而出現在棧中，隨著方法的彈棧而消失 區別四：初始化不同 成員變量因為在堆內存中，所有默認的初始化值 局部變量沒有默認的初始化值，必須手動的給其賦值才可以使用。 # 繼承 當子父類中出現了同名成員變量時，在子類中若要訪問父類中的成員變量，必須使用關鍵字super來完成。super用來表示當前對象中包含的父類對象空間的引用 父類私有的成員，子類不能繼承，因為根本看不到 不能為了繼承某個功能而隨意進行繼承操作， 必須要符合 is a 的關系 * 蘋果 is a 水果 * 男人 is a 人 * 狗 is a 人 ， 這種情況就不能繼承了 # 覆蓋 子類中出現與父類一模一樣的方法時，會出現覆蓋操作，也稱為override重寫、復寫或者覆蓋 重寫需要注意的細節問題： * 子類方法覆蓋父類方法，必須要保證權限大于等于父類權限。 * 寫法上稍微注意:必須一模一樣:方法的返回值類型 方法名 參數列表都要一樣。 # 接口和抽象類的區別： * 相同點: - 都位于繼承的頂端,用于被其他類實現或繼承; - 都不能直接實例化對象; - 都包含抽象方法,其子類都必須覆寫這些抽象方法; * 區別: - 抽象類為部分方法提供實現,避免子類重復實現這些方法,提高代碼重用性;接口只能包含抽象方法; - 一個類只能繼承一個直接父類(可能是抽象類),卻可以實現多個接口;(接口彌補了Java的單繼承) - 抽象類是這個事物中應該具備的你內容, 繼承體系是一種 is..a關系 - 接口是這個事物中的額外內容,繼承體系是一種 like..a關系 * 二者的選用: - 優先選用接口,盡量少用抽象類; - 需要定義子類的行為,又要為子類提供共性功能時才選用抽象類; # 接口中的成員特點： 成員變量： 只能是final 修飾的常量 默認修飾符： public static final 構造方法： 無 成員方法： 只能是抽象方法 默認修飾符: public abstract # 多態 Java中多態的代碼體現在一個子類對象(實現類對象)既可以給這個子類(實現類對象)引用變量賦值，又可以給這個子類(實現類對象)的父類(接口)變量賦值。 如Student類可以為Person類的子類。那么一個Student對象既可以賦值給一個Student類型的引用，也可以賦值給一個Person類型的引用。 最終多態體現為父類引用變量可以指向子類對象。 多態的前提是必須有子父類關系或者類實現接口關系，否則無法完成多態。 在使用多態后的父類引用變量調用方法時，會調用子類重寫后的方法。 ## 定義 多態的定義格式：就是父類的引用變量指向子類對象 父類類型 變量名 = new 子類類型(); 變量名.方法名(); * 普通類多態定義的格式 父類 變量名 = new 子類(); ~~~ 如： class Fu {} class Zi extends Fu {} //類的多態使用 Fu f = new Zi(); ~~~ * 抽象類多態定義的格式 抽象類 變量名 = new 抽象類子類(); ~~~ 如： abstract class Fu { public abstract void method(); } class Zi extends Fu { public void method(){ System.out.println(“重寫父類抽象方法”); } } //類的多態使用 Fu fu= new Zi(); ~~~ * 接口多態定義的格式 接口 變量名 = new 接口實現類(); ~~~ 如： interface Fu { public abstract void method(); } class Zi implements Fu { public void method(){ System.out.println(“重寫接口抽象方法”); } } //接口的多態使用 Fu fu = new Zi(); ~~~ ## 注意事項 * 同一個父類的方法會被不同的子類重寫。在調用方法時，調用的為各個子類重寫后的方法。 ~~~ 如 Person p1 = new Student(); Person p2 = new Teacher(); p1.work(); //p1會調用Student類中重寫的work方法 p2.work(); //p2會調用Teacher類中重寫的work方法 ~~~ 當變量名指向不同的子類對象時，由于每個子類重寫父類方法的內容不同，所以會調用不同的方法。 * 多態成員變量 **當子父類中出現同名的成員變量時，多態調用該變量時： 編譯時期：參考的是引用型變量所屬的類中是否有被調用的成員變量。沒有，編譯失敗。 運行時期：也是調用引用型變量所屬的類中的成員變量。 簡單記：編譯和運行都參考等號的左邊。編譯運行看左邊。** * 多態成員方法 **編譯時期：參考引用變量所屬的類，如果沒有類中沒有調用的方法，編譯失敗。 運行時期：參考引用變量所指的對象所屬的類，并運行對象所屬類中的成員方法。 簡而言之：編譯看左邊，運行看右邊。** ## 多態-轉型 多態的轉型分為向上轉型與向下轉型兩種： * 向上轉型：當有子類對象賦值給一個父類引用時，便是向上轉型，多態本身就是向上轉型的過程。 使用格式： 父類類型 變量名 = new 子類類型(); 如：Person p = new Student(); * 向下轉型：一個已經向上轉型的子類對象可以使用強制類型轉換的格式，將父類引用轉為子類引用，這個過程是向下轉型。如果是直接創建父類對象，是無法向下轉型的！ 使用格式： 子類類型 變量名 = (子類類型) 父類類型的變量; 如:Student stu = (Student) p; //變量p 實際上指向Student對象 ## 弊端 當父類的引用指向子類對象時，就發生了向上轉型，即把子類類型對象轉成了父類類型。向上轉型的好處是隱藏了子類類型，提高了代碼的擴展性。 但向上轉型也有弊端，只能使用父類共性的內容，而無法使用子類特有功能，功能有限制。看如下代碼 我們來總結一下： * 什么時候使用向上轉型： 當不需要面對子類類型時，通過提高擴展性，或者使用父類的功能就能完成相應的操作，這時就可以使用向上轉型。 ~~~ 如：Animal a = new Dog(); a.eat(); ~~~ * 什么時候使用向下轉型 當要使用子類特有功能時，就需要使用向下轉型。 ~~~ 如：Dog d = (Dog) a; //向下轉型 d.lookHome();//調用狗類的lookHome方法 ~~~ * 向下轉型的好處：可以使用子類特有功能。 * 弊端是：需要面對具體的子類對象；在向下轉型時容易發生ClassCastException類型轉換異常。在轉換之前必須做類型判斷。 如：if( !a instanceof Dog){…} # instanceof 我們可以通過instanceof關鍵字來判斷某個對象是否屬于某種數據類型。如學生的對象屬于學生類，學生的對象也屬于人類。 使用格式： ~~~ boolean b = 對象 instanceof 數據類型; ~~~ 如 ~~~ Person p1 = new Student(); // 前提條件，學生類已經繼承了人類 boolean flag = p1 instanceof Student; //flag結果為true boolean flag2 = p2 instanceof Teacher; //flag結果為false ~~~ # 構造方法 構造方法的體現： * 構造方法沒有返回值類型。也不需要寫返回值。因為它是為構建對象的，對象創建完，方法就執行結束。 * 構造方法名稱必須和類型保持一致。 * 構造方法沒有具體的返回值。 構造方法的代碼體現： ~~~ class Person { // Person的成員屬性age和name private int age; private String name; // Person的構造方法，擁有參數列表 Person(int a, String nm) { // 接受到創建對象時傳遞進來的值，將值賦給成員屬性 age = a; name = nm; } } ~~~ 構造方法的細節： 1、一個類中可以有多個構造方法，多個構造方法是以重載的形式存在的 2、構造方法是可以被private修飾的，作用：其他程序無法創建該類的對象 ## this調用構造方法 構造方法之間的調用，可以通過this關鍵字來完成。 * 構造方法調用格式： ~~~ this(參數列表); ~~~ # super * 子父類中構造方法的調用 在創建子類對象時，父類的構造方法會先執行，因為子類中所有構造方法的第一行有默認的隱式super();語句。 格式： ~~~ 調用本類中的構造方法 this(實參列表); 調用父類中的空參數構造方法 super(); 調用父類中的有參數構造方法 super(實參列表); ~~~ 為什么子類對象創建都要訪問父類中的構造方法？因為子類繼承了父類的內容，所以創建對象時，必須要先看父類是如何對其內容進行初始化的 原因：子類會繼承父類中的內容，所以子類在初始化時，必須先到父類中去執行父類的初始化動作。這樣，才可以使用父類中的內容。 當父類中沒有空參數構造方法時，子類的構造方法必須有顯示的super語句，指定要訪問的父類有參數構造方法 如果子類的構造方法第一行寫了this調用了本類其他構造方法，那么super調用父類的語句還有嗎？ 這時是沒有的，因為this()或者super(),只能定義在構造方法的第一行，因為初始化動作要先執行。 父類構造方法中是否有隱式的super呢？ 也是有的。記住：只要是構造方法默認第一行都是super(); 父類的父類是誰呢？super調用的到底是誰的構造方法呢？ Java體系在設計，定義了一個所有對象的父類Object * 注意： 類中的構造方法默認第一行都有隱式的super()語句，在訪問父類中的空參數構造方法。所以父類的構造方法既可以給自己的對象初始化，也可以給自己的子類對象初始化。 如果默認的隱式super()語句在父類中沒有對應的構造方法，那么必須在構造方法中通過this或者super的形式明確要調用的構造方法 # 繼承中的構造方法注意事項： 1. 如果我們手動給出了構造方法，編譯器不會在給我們提供默認的空參數構造方法 如果我們沒寫任何的構造方法，編譯器提供給我們一個空參數構造方法 2. 在構造方法中，默認的第一條語句為 super(); 它是用來訪問父類中的空參數構造方法，進行父類成員的初始化操作 3. 當父類中沒有空參數構造方法的時候，怎么辦？ a: 通過 super(參數) 訪問父類有參數的構造方法 b: 通過 this(參數) 訪問本類中其他構造方法 注意:[本類中的其他構造方法已經能夠正常訪問父類構造方法] 4.super(參數) 與 this(參數) 不能同時在構造方法中存在 # final * final修飾類不可以被繼承，但是可以繼承其他類 * final修飾的方法不可以被覆蓋,但父類中沒有被final修飾方法，子類覆蓋后可以加final。 * final修飾的變量稱為常量，這些變量只能賦值一次。 * 引用類型的變量值為對象地址值，地址值不能更改，但是地址內的對象屬性值可以修改。 ~~~ final Person p = new Person(); Person p2 = new Person(); p = p2; //final修飾的變量p，所記錄的地址值不能改變 p.name = "小明";//可以更改p對象中name屬性值 p不能為別的對象，而p對象中的name或age屬性值可更改。 ~~~ * 修飾成員變量，需要在創建對象前賦值，否則報錯。(當沒有顯式賦值時，多個構造方法的均需要為其賦值。) ~~~ class Demo { //直接賦值 final int m = 100; //final修飾的成員變量，需要在創建對象前賦值，否則報錯。 final int n; public Demo(){ //可以在創建對象時所調用的構造方法中，為變量n賦值 n = 2016; } } ~~~ # static * 被static修飾的成員變量屬于類，不屬于這個類的某個對象。（也就是說，多個對象在訪問或修改static修飾的成員變量時，其中一個對象將static成員變量值進行了修改，其他對象中的static成員變量值跟著改變，即多個對象共享同一個static成員變量） ~~~ class Demo { public static int num = 100; } class Test { public static void main(String[] args) { Demo d1 = new Demo(); Demo d2 = new Demo(); d1.num = 200; System.out.println(d1.num); //結果為200 System.out.println(d2.num); //結果為200 } } ~~~ * 被static修飾的成員可以并且建議通過類名直接訪問。 訪問靜態成員的格式： ~~~ 類名.靜態成員變量名 類名.靜態成員方法名(參數) 對象名.靜態成員變量名 ------不建議使用該方式，會出現警告 對象名.靜態成員方法名(參數) ------不建議使用該方式，會出現警告 ~~~ ## 注意 * 靜態內容是優先于對象存在，只能訪問靜態，不能使用this/super。靜態修飾的內容存于靜態區 ~~~ class Demo { //成員變量 public int num = 100; //靜態方法 public static void method(){ //this.num; 不能使用this/super。 System.out.println(this.num); } } ~~~ * 同一個類中，靜態成員只能訪問靜態成員 ~~~ class Demo { //成員變量 public int num = 100; //靜態成員變量 public static int count = 200; //靜態方法 public static void method(){ //System.out.println(num); 靜態方法中，只能訪問靜態成員變量或靜態成員方法 System.out.println(count); } } ~~~ * main方法為靜態方法僅僅為程序執行入口，它不屬于任何一個對象，可以定義在任意類中。 ## 定義靜態常量 開發中，我們想在類中定義一個靜態常量，通常使用public static final修飾的變量來完成定義。此時變量名用全部大寫，多個單詞使用下劃線連接。 定義格式： ~~~ public static final 數據類型 變量名 = 值; ~~~ * 注意： 接口中的每個成員變量都默認使用public static final修飾。 所有接口中的成員變量已是靜態常量，由于接口沒有構造方法，所以必須顯示賦值。可以直接用接口名訪問。 ~~~ interface Inter { public static final int COUNT = 100; } 訪問接口中的靜態變量 Inter.COUNT ~~~ # 匿名對象 匿名對象是指創建對象時，只有創建對象的語句，卻沒有把對象地址值賦值給某個變量。 如：已經存在的類： ~~~ public class Person{ public void eat(){ System.out.println(); } } 創建一個普通對象 Person p = new Person(); 創建一個匿名對象 new Person(); ~~~ * 創建匿名對象直接使用，沒有變量名。 ~~~ new Person().eat() //eat方法被一個沒有名字的Person對象調用了。 ~~~ * 匿名對象在沒有指定其引用變量時，只能使用一次。 ~~~ new Person().eat(); 創建一個匿名對象，調用eat方法 new Person().eat(); 想再次調用eat方法，重新創建了一個匿名對象 ~~~ # 內部類 * 什么是內部類 將類寫在其他類的內部，可以寫在其他類的成員位置和局部位置，這時寫在其他類內部的類就稱為內部類。其他類也稱為外部類。 * 什么時候使用內部類 在描述事物時，若一個事物內部還包含其他可能包含的事物，比如在描述汽車時，汽車中還包含這發動機，這時發動機就可以使用內部類來描述。 ~~~ class 汽車 { //外部類 class 發動機 { //內部類 } } ~~~ * 內部類的分類 內部類分為成員內部類與局部內部類。 我們定義內部類時，就是一個正常定義類的過程，同樣包含各種修飾符、繼承與實現關系等。在內部類中可以直接訪問外部類的所有成員 ## 成員內部類 成員內部類，定義在外部類中的成員位置。與類中的成員變量相似，可通過外部類對象進行訪問 * 定義格式 ~~~ class 外部類 { 修飾符 class 內部類 { //其他代碼 } } ~~~ * 訪問方式 外部類名.內部類名 變量名 = new 外部類名().new 內部類名(); * 成員內部類代碼演示 定義類 ~~~ class Body {//外部類，身體 private boolean life= true; //生命狀態 public class Heart { //內部類，心臟 public void jump() { System.out.println("心臟噗通噗通的跳") System.out.println("生命狀態" + life); //訪問外部類成員變量 } } } ~~~ * 訪問內部類 ~~~ public static void main(String[] args) { //創建內部類對象 Body.Heart bh = new Body().new Heart(); //調用內部類中的方法 bh.jump(); } ~~~ ## 局部內部類 局部內部類，定義在外部類方法中的局部位置。與訪問方法中的局部變量相似，可通過調用方法進行訪問 * 定義格式 ~~~ class 外部類 { 修飾符 返回值類型 方法名(參數) { class 內部類 { //其他代碼 } } } ~~~ * 訪問方式 > 在外部類方法中，創建內部類對象，進行訪問 * 局部內部類代碼演示 定義類 ~~~ class Party {//外部類，聚會 public void puffBall(){// 吹氣球方法 class Ball {// 內部類，氣球 public void puff(){ System.out.println("氣球膨脹了"); } } //創建內部類對象，調用puff方法 new Ball().puff(); } } ~~~ 訪問內部類 ~~~ public static void main(String[] args) { //創建外部類對象 Party p = new Party(); //調用外部類中的puffBall方法 p.puffBall(); } ~~~ ## 匿名內部類概念 內部類是為了應對更為復雜的類間關系。查看源代碼中會涉及到，而在日常業務中很難遇到，這里不做贅述。 最常用到的內部類就是匿名內部類，它是局部內部類的一種。 定義的匿名內部類有兩個含義： 臨時定義某一指定類型的子類 定義后即刻創建剛剛定義的這個子類的對象 * 定義匿名內部類的作用與格式 作用：匿名內部類是創建某個類型子類對象的快捷方式。 格式： ~~~ new 父類或接口(){ //進行方法重寫 }; ~~~ * 代碼演示 ~~~ //已經存在的父類： public abstract class Person{ public abstract void eat(); } //定義并創建該父類的子類對象，并用多態的方式賦值給父類引用變量 Person p = new Person(){ public void eat() { System.out.println(“我吃了”); } }; //調用eat方法 p.eat(); ~~~ 使用匿名對象的方式，將定義子類與創建子類對象兩個步驟由一個格式一次完成，。雖然是兩個步驟，但是兩個步驟是連在一起完成的。 匿名內部類如果不定義變量引用，則也是匿名對象。代碼如下： ~~~ new Person(){ public void eat() { System.out.println(“我吃了”); } }.eat(); ~~~ # 包 java的包，其實就是我們電腦系統中的文件夾，包里存放的是類文件。 當類文件很多的時候，通常我們會采用多個包進行存放管理他們，這種方式稱為分包管理。 在項目中，我們將相同功能的類放到一個包中，方便管理。并且日常項目的分工也是以包作為邊界。 類中聲明的包必須與實際class文件所在的文件夾情況相一致，即類聲明在a包下，則生成的.class文件必須在a文件夾下，否則，程序運行時會找不到類。 ## 聲明格式 通常使用公司網址反寫，可以有多層包，包名采用全部小寫字母，多層包之間用”.”連接 ~~~ 類中包的聲明格式： package 包名.包名.包名…; ~~~ ## 包的訪問 在訪問類時，為了能夠找到該類，必須使用含有包名的類全名（包名.類名）。 包名.包名….類名 ~~~ 如： java.util.Scanner java.util.Random ~~~ 帶有包的類，創建對象格式：包名.類名 變量名 = new包名.類名(); * 前提：包的訪問與訪問權限密切相關，這里以一般情況來說，即類用public修飾的情況。 * 類的簡化訪問 當我們要使用一個類時，這個類與當前程序在同一個包中（即同一個文件夾中），或者這個類是java.lang包中的類時通常可以省略掉包名，直接使用該類。 * 當我們要使用的類，與當前程序不在同一個包中（即不同文件夾中），要訪問的類必須用public修飾才可訪問。 ## 導包 我們每次使用類時，都需要寫很長的包名。很麻煩，我們可以通過import導包的方式來簡化。 可以通過導包的方式使用該類，可以避免使用全類名編寫（即，包類.類名）。 導包的格式： ~~~ import 包名.類名; ~~~ 當程序導入指定的包后，使用類時，就可以簡化了。演示如下 ~~~ //導入包前的方式 //創建對象 java.util.Random r1 = new java.util.Random(); java.util.Random r2 = new java.util.Random(); java.util.Scanner sc1 = new java.util.Scanner(System.in); java.util.Scanner sc2 = new java.util.Scanner(System.in); //導入包后的方式 import java.util.Random; import java.util.Scanner; //創建對象 Random r1 = new Random(); Random r2 = new Random(); Scanner sc1 = new Scanner(System.in); Scanner sc2 = new Scanner(System.in); ~~~ * import導包代碼書寫的位置：在聲明包package后，定義所有類class前，使用導包import包名.包名.類名; # 代碼塊 ## 局部代碼塊 局部代碼塊是定義在方法或語句中 特點： * 以”{}”劃定的代碼區域，此時只需要關注作用域的不同即可 * 方法和類都是以代碼塊的方式劃定邊界的 ## 構造代碼塊 構造代碼塊是定義在類中成員位置的代碼塊 特點： * 優先于構造方法執行，構造代碼塊用于執行所有對象均需要的初始化動作 * 每創建一個對象均會執行一次構造代碼塊。 ~~~ public class Person { private String name; private int age; //構造代碼塊 { System.out.println("構造代碼塊執行了"); } Person(){ System.out.println("Person無參數的構造函數執行"); } Person(int age){ this.age = age; System.out.println("Person（age）參數的構造函數執行"); } } class PersonDemo{ public static void main(String[] args) { Person p = new Person(); Person p1 = new Person(23); } } ~~~ ## 靜態代碼塊 執行順序：（優先級從高到低。）靜態代碼塊>mian方法>構造代碼塊>構造方法。 靜態代碼塊是定義在成員位置，使用static修飾的代碼塊。 特點： * 它優先于主方法執行、優先于構造代碼塊執行，當以任意形式第一次使用到該類時執行。 * 該類不管創建多少對象，靜態代碼塊只執行一次。 * 可用于給靜態變量賦值，用來給類進行初始化。 ~~~ public class Person { private String name; private int age; //靜態代碼塊 static{ System.out.println("靜態代碼塊執行了"); } } ~~~ # 修飾符 常用來修飾類、方法、變量的修飾符如下： * public 權限修飾符，公共訪問, 類,方法,成員變量 * protected 權限修飾符，受保護訪問, 方法,成員變量 * 默認什么也不寫 也是一種權限修飾符，默認訪問, 類,方法,成員變量 * private 權限修飾符，私有訪問, 方法,成員變量 * static 靜態修飾符 方法,成員變量 * final 最終修飾符 類,方法,成員變量,局部變量 * abstract 抽象修飾符 類 ,方法 我們編寫程序時，權限修飾符一般放于所有修飾符之前，不同的權限修飾符不能同時使用； 同時，abstract與private不能同時使用； 同時，abstract與static不能同時使用； 同時，abstract與final不能同時使用。 * 修飾類能夠使用的修飾符： 修飾類只能使用public、默認的、final、abstract關鍵字 使用最多的是 public關鍵字 * 修飾成員變量能夠使用的修飾符： public : 公共的 protected : 受保護的 : 默認的 private ：私有的 final : 最終的 static : 靜態的 使用最多的是 private * 修飾構造方法能夠使用的修飾符： public : 公共的 protected : 受保護的 : 默認的 private ：私有的 使用最多的是 public * 修飾成員方法能夠使用的修飾符： public : 公共的 protected : 受保護的 : 默認的 private ：私有的 final : 最終的 static : 靜態的 abstract : 抽象的 使用最多的是 public