面向對象一文搞定，終生難忘（面向對象心得）

一、面向過程和面向對象

1.1、面向過程

強調的是我該怎么去做。即功能的執行過程，即先干啥，后干啥。在面向過程中，我們會寫很多的函數，每一個函數負責完成某一個功能。

而一個主函數里面有多個小函數，需要完成某個功能的時候依次調用即可

由此我們發現面向過程的設計思想存在以下幾個缺陷：系統軟件適應性差，可拓展性差，維護性低。

1.2、面向對象

一種基于面向過程的新的編程思想，顧名思義該思想是站在對象的角度思考問題，我們把多個功能合理的放到不同對象里，強調的是我該讓誰來做

面向對象最小的程序單元是類，必須先存在類的定義，再有對象，而具備某種功能的實體，稱為對象

面向過程和面向對象的差別如下：

面向過程和面向對象各有千秋，面向對象更符合我們常規的思維方式，穩定性好，可重用性強，易于開發大型軟件產品，有良好的可維護性，它擁有三大特征：

封裝

繼承

多態

二、變量

2.1、變量的分類

根據變量定義的位置的不同，我們大致可以把變量分為兩大類：

成員變量：直接定義在類中，方法的外面，又稱之為字段，不是屬性

局部變量：除了成員變量外，其他變量都是局部變量，僅僅存在于方法內、代碼塊、方法的形式參數中

2.2、變量的初始值

變量的初始化表示在內存中開辟一個存儲空間進行存儲，只有初始化后才可以使用，不同的變量類型初始值不同

成員變量

默認是有初始值的，不同類型的初始值不同

局部變量

局部變量沒有初始值，必須手動初始化才可以使用

2.3、變量的作用域

變量根據定義的位置不同，也決定了各自的作用域是不同的，關鍵是看變量所在的花括號的位置

成員變量

在所定義的類中都有效

局部變量

從開始定義的位置到花括號內有效，花括號外就無效了

2.4、變量的生命周期

變量的生命周期，通俗的來說就是變量在內存中可以存活多久

成員變量

成員變量是屬于對象的，對象在堆內存中，所以成員變量也是存儲在堆內存中的，隨著對象的1消亡而消亡

局部變量

局部變量是存儲在棧內存的，隨著方法的調用的結束而消亡

局部變量是存儲在方法中的，每次調用方法都會在棧空間開辟一個內存空間，我們成為棧幀，方法1調用結束，棧幀就被銷毀了，內存中存儲的變量數據也就銷毀了

三、類

3.1、類的定義

類是擁有相同特性（狀態）和行為（功能）的多個對象的抽象

使用成員變量來表示狀態

使用成員方法來表示行為

格式

public class 類名{ //可編寫0到N個成員變量 修飾符 數據類型 變量名1; 修飾符 數據類型 變量名2; //可編寫0到N個成員方法 修飾符 返回值類型 方法名稱(參數){ //方法體 } }

注意：

成員方法和變量都不可以用static修飾，修飾符不是必須的

在描述對象的類中，不需要定義main方法，main方法在專門的測試類中編寫，切測試類和描述對象的類是分開編寫的

四、對象

4.1、對象的創建

類名 對象遍歷名 = new 類名();

如果我們直接打印對象的話，打印的是類似數組地址的hashCode值

4.2、匿名對象

創建對象之后沒有賦值給某個遍歷，只能使用一次

new 類名();

4.3、給字段設置數據

對象變量名.字段名 = 值；

4.4、獲取字段的數據

數據類型 變量 = 對象變量.字段名；

4.5、對象調用方法

對象變量名.方法(參數)；

4.6、對象實例化的內存分析

以下面簡單地Cat類進行分析

public class Cat(){ String name; int age; }

創建對象

Cat cat = new Cat();

此時如果通過查看對象的name和age屬性可以發現分別為初始值null和0

給對象賦值

cat.name="xiaolin"; cat.age=18;

對象調用方法

public class Cat(){ String name; int age; public void say(){ System.out.println("我們一起學貓叫"); } }

五、構造器（構造方法）

5.1、構造器的定義

構造器，也稱之為構造方法（Constructor），作用是用來創建對象和給對象做初始化操作，只能在創建對象的時候使用一次

構造器的語法

public 類名(參數){ //方法體 } //示范： public class Cat { public Cat() { } //省略其他代碼 }

構造器的特點

構造器名稱和類名相同

不能定義返回類型

構造器中不能出現return語句

5.2、默認構造器

我們在創建類的時候，沒有手動寫構造器，而沒有報錯，原因是因為如果我們在編寫對象的時候，如果沒有寫構造器的話，編譯器會在編譯源文件的時候，自動創建一個默認構造器，默認構造器的特點：無參數、無方法體。

如果類使用了public修飾，那么他默認的構造器也會使用public修飾，反之亦然

5.3、構造器的使用

沒有構造器之前

之前，我們是先通過一個默認參數構造器，先創建出一個對象再初始化（給字段設置值）

Cat cat = new Cat(); c.name = "xialin"; c.age = 18;

有了構造器之后

有了構造器之后，可以直接通過構造器同時完成對象創建和初始化操作

public class Cat { String name; int age; public Cat(String name, int age) { this,name = name; this.age = age; } void say() { System.out.println("我是" + name + ",今年" + age + "歲"); } }

Cat cat = new Cat("zs", 19); cat.say(); Cat cat = new Cat(); // 此行報錯

當自己定義出構造器之后，編譯器不再創建默認的構造器了，所以就不再自動有無參構造器，我們一般在開發中無參構造器和有參構造器會同時編寫，他們構成重載關系

public class Cat { String name; int age; //無參數構造器 public Cat() { } //帶參數構造器 public Cat(String name, int age) { this,name = name; this.age = age; } //其他代碼 }

六、封裝

封裝是面向對象三大特征之一，其含義有兩個（掌握思想）：

把對象的字段和方法存放在一個獨立的模塊中（類）

信息隱藏，盡可能隱藏對象的數據和功能的實現細節

封裝的好處:

保證數據的安全性，防止調用者隨意修改數據

提高組件的重用性，把公用功能放到一個類中，誰需要該功能，直接調用即可

限制字段不能夠隨意修改的利器就是訪問修飾符

6.1、訪問修飾符

訪問修飾符，決定了有沒有權限訪問某個資源，封裝的本質就是要讓有些類看不到另外一些類中定義的字段和方法。Java提供了不同的訪問權限修飾符來限定類中的成員讓誰可以訪問到

private：表示當前類是私有的，只能在本類中訪問，離開本類之后就不能直接訪問

不寫：表示當前包私有，定義和調用只能在同一個包中，才能訪問

protected：表示子類訪問權限，同一個包的可以訪問，即使不同包但是有繼承關系也是可以訪問的

public：表示公共的，可以在當前項目的任何地方訪問

一般在開發中都是提供私有屬性，暴露公有的訪問方法

6.2、JavaBean規范

JavaBean是一種某些符合條件的特殊類，但是必須遵循一定的規范：

類必須使用public修飾

必須保證有公共無參數構造器，即使手動提供了帶參數的構造器，也得手動提供無參數構造器

段使用private修飾，每個字段提供一對getter和setter方法

public String getName(){ return name; //返回name字段存儲的值 } public void setName(String n){ name = n; //把傳過來的參數n的值,存儲到name字段中 }

6.3、構造器和setter方法

構造器和setter方法都可以給對象設置數據：

構造器，在創建對象的時候設置初始數據，只能初始化一次。

setter方法，創建對象后再設置初始數據，可以設置多次。

七、繼承

面向對象的繼承思想，可以解決多個類存在共同代碼的問題

被繼承的類，稱之為父類、基類

繼承父類的類，稱之為子類，拓展類

父類：存放多個子類共同的字段和方法

子類：存放自己特有的字段和方法

7.1、繼承的語法

在程序中，如果一個類需要繼承另一個類，此時使用extends關鍵字

public class 子類名 extends 父類名{ }

注意：Java中類只支持單繼承，不支持多繼承，但是支持多重繼承。也就是說一個子類只能有一個直接的父類，父類也可以再有父類。一個父類也可以有多個子類

class Student1(); class Student2(); class Student extend Student1,Student2(){}//錯誤

Object類是Java語言的根類，任何類都是Object的子類，要么是直接子類，要么是間接子類

7.2、子類可以繼承到父類哪些成員

子類繼承父類之后，可以擁有到父類的某一些成員（字段和方法），根據訪問修飾符來判斷：

父類中用public和protected修飾的成員，子類均可以繼承

如果父類和子類在同一個包中，使用缺省訪問修飾的成員，此時子類可以繼承到

如果父類中的成員用private修飾，子類繼承不到，因為private只能在奔本類中訪問

父類的構造器，子類也無法繼承，因為構造器必須和類名相同

7.3、方法的重寫

當子類存在一個和父類一模一樣的方法時，我們就稱之為子類覆蓋了父類的方法，也稱之為重寫。那么我們就可以在子類方法體中，重寫編寫邏輯代碼

方法調用的順序為：通過對象調用方法時，先在子類中查找有沒有對應的方法，若存在就執行子類的，若子類不存在就執行父類的，如果父類也沒有，報錯。

方法重寫需要注意的點：

private修飾的方法不能被子類所繼承，也就不存在重寫的概念

實例方法簽名必須相同（方法簽名=方法名+方法參數列表）

子類方法的返回值類型和父類的返回值類型相同或者是其子類

子類方法中聲明拋出的異常小于或者等于父類方法聲明拋出的異常類型

子類方法的訪問權限比父類的訪問權限更大或者相等

一般開發都是直接拷貝父類的方法定義粘貼到子類中，重新編寫子類的方法體

7.4、super關鍵字

在子類中的某一個方法中需要去調用父類中被覆蓋的方法，此時得使用super關鍵字。

如果調用被覆蓋的方法不使用super關鍵字，此時調用的是本類中的方法。super關鍵字表示父類對象的意思

7.5、抽象

抽象方法用abstract來修飾方法，被abstract修飾的方法具備兩個特征：

該方法沒有方法體

要求子類必須覆蓋該方法

7.5.1、抽象方法

使用abstract修飾的方法，稱為抽象方法

public abstract 返回類型 方法名(參數);

抽象方法的特點：

使用abstract修飾，沒有方法體，留給子類去覆蓋

抽象方法必須定義在抽象類或者接口中

7.5.2、抽象類

使用abstract修飾的類，稱為抽象類

public abstract class 類名{ }

抽象類的特點：

抽象類不能創建對象，調用沒有方法體的抽象方法沒有任何意義

抽象類中可以同時擁有抽象方法和普通方法

抽象類必須有子類才有意義，子類必須覆蓋父類的抽象方法，否則子類也得作為抽象類

7.6、Object類和常用方法

Object本身表示對象的意思，是Java中的根類，要么是一個類的直接父類，要么就是一個類的間接父類。任何類都直接（間接）繼承了Object類

class A{} //等價于 class A extends Object{}

因為所有類都是Object類的子類， 所有類的對象都可以調用Object類中的方法，經常使用的方法有

7.6.1、boolean equals(Object obj)

boolean equals(Object obj)：拿當前調用該方法的對象和參數obj做比較

在Object類中的equals方法和“ == ”符號相同，都是比較對象是否是同一個的存儲地址。

public class ObjectDemo { public static void main(String[] args) { //創建Person對象p1 Person p1 = new Person(); //創建Person對象p2 Person p2 = new Person(); //比較p1和p2的內存地址是否相同 boolean ret1 = p1 == p2; boolean ret2 = p1.equals(p2); System.out.println(ret1); //false System.out.println(ret2); //false } }

7.6.2、toString方法

toString表示把對象中的字段信息轉換為字符串格式

打印對象其實就是打印對象的toString()方法，但是toString()方法默認打印的是對象的hashCode的值

com._04_object.Person@15db9742

所以一般我們都會重寫toString()方法

public String toString() { return "Person [name=" + name + ", age=" + age + "]"; }

7.7、== 符號詳解

每一次使用new關鍵字，都表示在堆內存中創建一塊新的內存空間

如果是基本數據類型：比較的是兩個值是否相等

如果是對象數據類型：比較的是是否為同一塊內存地址

八、多態

8.1、接口

接口是一種約定規范，是多個抽象方法的集合。僅僅只是定義了應該有哪些功能，本身不實現功能，至于每個功能具體怎么實現，就交給實現類完成。

接口中的方法是抽象方法，并不提供功能實現，體現了規范和實現相分離的思想，也體現了組件之間低耦合的思想。接口僅僅提供方法的定義，卻不提供方法的代碼實現

所謂耦合度，表示組件之間的依賴關系。依賴關系越多，耦合性越強，同時表明組件的獨立性越差，在開發中往往提倡降低耦合性，可提高其組件獨立性，舉一個很簡單的例子：

集成顯卡：顯卡和主板焊死在一起，顯卡壞了，只能換主板

獨立顯卡：顯卡和主板相分離，顯卡插到主板上即可，顯卡壞了，只換顯卡，不用換主板

8.1.1、接口的定義

接口可以認為是一種特殊的類，但是定義類的時候使用class關鍵字，定義接口使用interface關鍵字，接口中的方法都是公共的抽象方法

public interface 接口名{ //抽象方法1(); //抽象方法2(); //抽象方法2(); }

注意：從Java 8開始, Java支持在接口中定義有實現的方法

public interface IMan { public abstract void walk();//抽象方法 default void defaultMethod(){ System.out.println("有默認實現的方法, 屬于對象"); } static void defaultMethod(){ System.out.println("有默認實現的方法, 屬于類"); } }

類可以繼承類，但是只能單繼承的，接口也可以繼承接口，但是卻可以繼承多個接口，也就是說一個接口可以同時繼承多個接口

8.1.2、接口實現類

和抽象類一樣，接口是不可以創建對象的，如果想實現接口的功能，就必須定義一個類去實現接口，并且覆蓋接口中的所有方法，這個類稱為實現類，這種類和接口的關系稱為實現關系

public class 類名 implements 接口名{ //覆蓋接口中抽象方法 }

接口：定義多個抽象方法，僅僅定義有哪些功能，不做任何實現

實現類：實現接口，重寫接口中的抽象方法，完成具體功能的實現

8.2、多態

在繼承關系，是一種”is A”的關系，也就說子類是父類的一種特殊情況

public class Animal{} public class Dog extends Animal{} public class Cat extends Animal{}

此時我們可以認為貓和狗都是一種特殊動物，那么可以使用動物類型來表示貓或者狗

Dog dog = new Dog(); //創建一只狗對象,賦給子類類型變量 Animal animal = new Cat(); //創建一只貓對象,賦給父類類型變量

此時對象animal具有兩種類型：

編譯類型：聲明對象時候的類型（Animal）

運行類型：對象真實的類型（Cat）

當編譯類型和運行類型不一致的時候，多態就產生了

所謂的多態就是表示一個對象有多種形態，簡單來說就是同一引用類型，由于引用的實例不同，對同一方法產生的結果也不同

Person person = null; person = new Man(); //person此時表示Man類型 person = new Woman();//person此時表示Woman類型

多態一定建立在方法重寫或者實現之上，可以是繼承關系（類和類），也可以是實現關系（接口和實現類），在開發中，一般都指接口和實現類之間的關系，多態在在開發中有兩種定義格式

8.2.1、操作繼承關系（開發中不是很多）

父類引用變量指向于子類對象，調用方法時實際調用的是子類的方法

父類 變量名 = new 子類(); 變量名.方法();

Animal類:

public class Animal { public void shout() { System.out.println("動物...叫..."); } }

Cat類:

public class Cat extends Animal{ public void shout() { System.out.println("貓叫..."); } }

Test類:

public class AnimalDemo{ public static void main(String[] args){ Animal animal = new Cat(); animal.shout(); } }

運行結果:

貓叫

8.2.2、操作實現關系

接口 變量名 = new 實現類(); 變量名.方法();

ISwimable 接口：

public interface ISwimable{ void swim(); }

Fish類：

public class Fish implements ISwimable{} public void swim(){ Sysout.out.println("魚在游") } }

Test類：

public class Fish implements{ public static void main(String[] args){ ISwimable fish = new Fish(); fish.swim(); } }

結果：

魚在游泳

8.2.3、多態中方法調用問題

如果我們把子類對象賦值給父類對象

Animal animal = new Cat(); animal.shout();

那么animal對象在調用shout方法的時候，他調用的是子類自己的方法還是父類的方法呢？

我們可以看得出，在編譯時期，JVM會先去找父類的方法，如果找到了就去找子類的同名方法，如果子類也有就運行子類的方法，否則就運行父類的方法，如果連父類的方法都沒有找到的話，直接編譯失敗失敗

8.2.4、類型轉換和instanceof運算符

自動類型轉換：把子類對象賦給父類變量（多態）

Animal a = new Dog(); Object obj = new Dog(); //Object是所有類的根類

把父類類型對象賦給子類類型變量（前提：該對象的真實類型應該是子類類型）

當需要調用子類特有的方法時，必須經過強制類型轉換，不過有一個要求：父類必須是真實的子類類型才可以轉換

Animal a = new Dog(); Dog d = (Dog) a;//正確 Cat c = (Cat) a;//錯誤，真實類型為Dog

判斷該對象是否是某一個類的實例

語法格式

boolean b = 對象A instanceof 類B; //判斷 A對象是否是 B類的實例？如果是,返回true

面向接口編程，體現的就是多態，其好處：把實現類對象賦給接口類型變量，屏蔽了不同實現類之間的實現差異，從而可以做到通用編程

8.3、面試題

接口和抽象類的區別

接口中所有的方法隱含的都是抽象的，但是抽象類中可以同時包含抽象方法和普通方法以及靜態常量

類可以實現很多個接口，但是只能繼承一個抽象類

類如果要實現一個接口，那么他必須要實現接口聲明的所有方法，但是類可以不實現抽象類中的所有方法，但是這個類必須是抽象類

接口中不存在構造方法，因為接口的成員變量都是static final變量，是在編譯的時候就完成了初始化操作了，無需通過構造方法來進行初始化操作，而抽象類必須有構造方法

抽象類和接口的概念的區別：

抽象類是從一些類中抽取他們的共有的屬性，方法的修飾符可以是public或者是protected以及缺省，抽象類注重對類本身的抽象，抽象方法沒有方法體，僅僅是聲明了該方法，讓繼承他的子類去實現

接口主要是對類的行為抽象，接口也可以有變量和方法，但是變量以及方法的修飾符必須是public static final（缺省時會默認加上）和public abstract（缺省時默認也是這個）

九、關鍵字（this、super）

9.1、this關鍵字

this關鍵字表示當前對象（誰調用this所在的方法，this就是哪一個對象主要）存在于兩個位置：

在構造器中：表示當前創建的對象

在方法中：哪一個對象調用this所在的方法，此時this就表示哪個對象

什么時候需要使用this關鍵字

為了解決局部變量和成員變量之間的二義性，此時必須使用

同一個類中非static方法之間的互相調用，此時可以省略，但是基本不會省略

調用本類其他的構造方法

public class Dog { private String name; private int age; public Dog() { } public Dog(String name) { this(name, 0);// 調用兩個參數的構造器(構造器之間的重載),必須放在構造器第一行 } public Dog(String name, int age) { this.name = name; this.age = age; } public void say() { String name = "局部變量"; System.out.println(name); // 訪問局部變量 System.out.println(this.name);// 訪問成員變量 this.other();// 調用當前類中非static方法 } public void other() { System.out.println(this.age);//此時的this是誰 } }

this內存圖

this關鍵字表示當前對象本身，一般用于類的內部，其內部存在一個地址，指向當前初始化對象本身

當new一個對象的時候，實際上產生了兩個引用，一個是供Dog內部調用其他成員變量或者成員方法的this關鍵字，另一個是供外界程序調用實例成員的dog持有類信息

9.2、super關鍵字

super表示當前對象的父類對象，在創建子類對象的時候，在子類構造器的第一行會先調用父類的構造器

super雖然表示父類對象，但是他僅僅只是一個關鍵字，內部并沒有地址，所以不能夠引用

什么時候使用super

訪問父類中非私有的實例方法，此時必須使用super

在子類的構造器中，調用父類的構造器，此時必須使用super

如果想訪問父類的非私有成員變量，此時必須使用super

父類：

public class Person { private String name; private int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } public void doWork() { System.out.println("Person...doWork..."); } }

子類：

public class Student extends Person { private String sn; public Student(String sn) { super();// 隱式調用父類無參數構造器,必須作為構造第一行 this.sn = sn; } public Student(String name, int age, String sn) { super(name, age);// 顯示去調用父類有參數構造器,必須作為構造第一行 this.sn = sn; } public void doWork() { super.doWork(); // 此時調用父類的doWork()方法 this.doWork(); // 此時調用自己的doWork()方法 System.out.println("Student...doWork..."); } }

總結

super調用構造方法必須寫在子類構造方法的第一行

如果子類構造方法沒有顯示調用父類構造方法時，那么JVM會默認調用父類的無參構造器

十、修飾符（static、final）

10.1、static修飾符

static修飾的字段和方法都直接屬于類，不屬于該類的對象（字段和方法屬于誰，就讓誰來調用）

有static修飾的變量和方法：屬于類，直接用類名調用即可，在同一個類中調用可以省略類名不寫

沒有static修飾的變量和方法：屬于對象，必須先創建對象，然后用對象調用

注意：static方法不能使用super和this關鍵字

因為static是類級別的，super和this是對象級別的，存在類的時候不一定存在對象，也就說使用類名調用static方法時，此時可能是沒有對象的。

10.1.1、靜態方法

static修飾的方法稱為靜態方法，歸類所有，也稱為類方法

修飾符 static 返回值類型 方法名(形參列表){ }

靜態方法有兩種訪問方式：

類名.靜態方法名()√

對象.靜態方法名()Java是不推薦這種訪問機制的

靜態方法的特性

靜態方法中可以訪問靜態變量和其他靜態方法

實例方法中可以訪問靜態成員變量以及靜態成員方法

10.1.2、靜態變量

在類中，用static關鍵字修飾的成員變量稱為靜態變量，歸類所有，也稱為類變量，類的所有實例對象都可以訪問，被類的所有實例或者對象共享

static 數據類型 成員變量

靜態變量的訪問

類名.靜態變量

類的對象.靜態變量（Java不推薦）

10.2、final修飾符

final的含義是最終的，不可改變的，可以修飾類、方法、變量，他是來限制某個類不可以有子類，不可以覆蓋方法

final修飾的類

表示最終的類，該類不可以再擁有子類

final public class Super { } public class Sub extends Super{ //此行語法報錯 }

final修飾的方法

最終的方法，該方法不可以被子類覆蓋

public class Super { final public void doWork() { } } public class Sub extends Super{ public void doWork() { //此行語法報錯 } }

final修飾的變量

表示常量，該變量只能賦值一次，不可以再重新賦值

基本數據類型：表示的值不能再改變

引用數據類型：所引用的地址不可以再改變

final int age = 17; age = 100; //此行語法報錯 final Dog d = new Dog(); d.setAge(5); //d的字段值是可以改變的 d = new Dog(); //此行語法報錯

十一、代碼塊

直接使用{}括起來的一段代碼區域，代碼塊里面的變量屬于局部變量，僅在{}內有效

他有三種存在形式：普通代碼塊、構造代碼塊、靜態代碼塊

11.1、普通代碼塊

直接定義在方法內部的代碼塊，一般的，不會直接使用局部代碼塊的，結合if、while、for等關鍵字使用，表示一塊代碼區域，作用域可以嵌套

public class CodeBlockDemo { public static void main(String[] args) { System.out.println("begin..."); { //直接使用代碼塊，一般不用 int age = 17; } System.out.println(age); //此行報錯,超出age作用范圍,就不能訪問到了 if (100 > 5) { System.out.println("100 > 5"); } System.out.println("end..."); } }

11.2、構造代碼塊

構造代碼塊在類的內部，方法的外部，隨著一個對象的創建而執行一次，在構造方法前執行

package day09_ObjectAdvanced.Classing.StaticBlock; /** * @author Xiao_Lin * @version 1.0 * @date 2020/12/9 16:29 */ public class Dog { private String name; static String age="111"; { System.out.println("我是構造代碼塊"); } public Dog(){ System.out.println("我是無參構造方法"); } public Dog(String name){ System.out.println("我是有參構造方法"); } public void shut(){ System.out.println("我是叫方法"); } }

如果需要在構造方法執行前加載一些資源（如讀配置文件、XML文件等等），我們可以把構造對象前的一切操作都放在構造代碼塊中執行

11.3、靜態代碼塊

用static關鍵字所修飾的代碼塊稱為靜態代碼塊，位于類的內部、方法的外部，且只執行一次，在構造代碼塊、構造方法前執行

package day09_ObjectAdvanced.Classing.StaticBlock; /** * @author Xiao_Lin * @version 1.0 * @date 2020/12/9 16:29 */ public class Dog { private String name; static String age="111"; static { System.out.println("我是靜態代碼塊"); } { System.out.println("我是構造代碼塊"); } public Dog(){ System.out.println("我是無參構造方法"); } public Dog(String name){ System.out.println("我是有參構造方法"); } public void shut(){ System.out.println("我是叫方法"); } }

十二、內部類

12.1、類的組織方式

12.1.1、類和類的平行關系

一個文件可以定義多個類，但只能存在一個public類，且文件的名字和public類的名字要保持一致

public class Dog{ } class Cat{ }

Dog和Cat地位一樣，和分開定義兩個文件是一模一樣的

12.1.2、類和類之間包含關系

public class Outer { public class Inner{ } }

Outer和Inner是包含關系，Outer稱為外部類，而Inner稱為內部類，內部類Inner作為一個Outer的成員而存在

12.2、內部類的概述

什么是內部類，把一個類定義在另一個類的內部，把里面的類稱之為內部類，把外面的類稱之為外部類，內部類的分類有：

成員內部類

靜態內部類

方法內部類

匿名內部類

12.3、匿名內部類

當一個類只使用一次，可以聲明成匿名內部類

匿名內部類 必須有實現存在，多以實現接口居多

public class Outer { public void print(){ /* class Inner implements AInterface{ @Override public void showInfo() { System.out.println("inner.showInfo"); } } new Inner().showInfo(); */ /* AInterface aInterface = new AInterface(){ @Override public void showInfo() { System.out.println("inner.showInfo"); } }; aInterface.showInfo(); */ // 通過匿名類創建匿名對象 new AInterface(){ @Override public void showInfo() { System.out.println("inner.showInfo"); } }.showInfo(); } }

十三、枚舉類

枚舉是一種特殊的類，固定一個類只能有哪些對象

13.1、枚舉類的定義

public enum 枚舉類型{ 常量對象A、常量對象B、常量對象C }

publicc enum Story{ HISTORY、ENGLISH、MATH }

我們自定義的枚舉類都是在底層直接繼承了 java.lang.Enum 類，枚舉中都是全局公共的靜態常量，可以直接用枚舉類名調用

Stroy story = Story.ENGLISH;

因為java.lang.Enum類是所有枚舉類的父類,所以所有的枚舉對象可以調用Enum類中的方法

String name = 枚舉對象.name(); // 返回枚舉對象的常量名稱 int ordinal = 枚舉對象.ordinal(); // 返回枚舉對象的序號,從0開始

注意：枚舉類不能使用創建對象

Java

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。