Java的三大特性是什么

Java的三大特性是什么，很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

Java的三大特性：封裝、繼承、多態

1. 訪問權限修飾符

Java中關于訪問權限的四個修飾符，表格如下

其中比較尷尬的是protected修飾符，有點卡在中間，不上不下的感覺

因為它不適合用來修飾屬性

假設用它修飾屬性，那么任何一個人都可以通過繼承這個類，來直接訪問到這個類的屬性，從而破壞"封裝性"

2. 抽象類（abstract）

什么是抽象類？

抽象類就是用abstract修飾，且不能被直接初始化的類，但是可以通過子類來初始化 比如：Father father = new Son()

對應的，抽象方法就是用abstract修飾的方法

抽象方法是一種很特殊的方法，它沒有方法體，即方法實現代碼為空，比如abstract public void fun();

抽象方法一般在子類中進行實現，它就好像是在說：我不寫代碼，我只是聲明一個方法名，剩下的交給我的子孫后代（繼承類）去做

抽象類有一個很重要的特點：抽象類可以沒有抽象方法，但是如果一個類有抽象方法，那么這個類肯定是抽象類

為什么會有抽象類

解耦，使代碼結構更加清晰

因為抽象類不能被直接創建為對象，它只是作為一個通用接口來供別人實現和調用，所以這樣就使得抽象的代碼更加清晰（它只聲明方法，不實現方法） 就好比，老板和員工，老板負責分發任務，員工負責去具體的實現任務

好了，關于抽象類，先介紹到這里，更詳細的后面的章節再深入

3. 重載(overloading)和覆寫(overwriting)

重載和覆寫是兩個很容易混淆的概念

重載：同一個類中，一個方法的多種表現形式（參數類型不同，參數個數不同）

覆寫：繼承設計中，子類覆蓋父類的方法（也可以叫做重寫，不過這樣跟重載有點混淆，所以個人喜歡叫做覆寫）

他們之間的區別如下

這里要注意幾點

1. 覆寫時，子類的方法訪問權限不能低于父類，比如父類方法為public，那么子類也只能為public

2. 重載時，訪問權限和方法返回值，不能作為用來判斷一個方法是否為重載的依據；只能說重載允許不同的訪問權限和返回值

覆寫示范

代碼示范如下，

// 覆寫一：正確示范
@Override
public void fun(){
    System.out.println("son fun");
}
// 覆寫二：錯誤示范，訪問權限低了
@Override
private void fun(){
    // 報錯：'fun()' in 'SonDemo' clashes with 'fun()' in 'Father'; attempting to assign weaker access privileges ('private'); was 'public'
    System.out.println("son fun");
}

@Override這個是干嘛的？之前沒見過啊

這個修飾符用來說明這個方法是覆寫方法，不寫也可以，系統會自己識別方法是不是覆寫的

那為啥還要多此一舉呢？用系統默認的識別機制不好嗎？

要多此一舉；不好；

因為加了注解，代碼可讀性更高，代碼更加規范，別人看了代碼后，立馬就知道這個方法是覆寫方法

重載示范

重載用圖展示可能會更加清晰

圖示解釋：

1. 參數類型和參數個數，只要滿足其一，就可以說這個方法被重載了

2. 訪問權限和方法返回值用虛線框，是為了說明他們兩個只是重載的一個附加表現形式（可有可無），不能作為重載的判斷依據

下面用代碼演示下

// 基礎方法
public void fun1(int a){

}
// 重載一：參數個數不同
public void fun1(){

}
// 重載二：參數類型不同
public void fun1(float a){

}
// 重載三：錯誤示范，僅僅用訪問權限的不同來重載
private void fun1(int a){
    // 編譯報錯：'fun1(int)' is already defined
}
// 重載四：錯誤示范，僅僅用返回值的不同來重載
public int fun1(int a){
    // 編譯報錯：'fun1(int)' is already defined
    return 0;
}

下面進入正文，開始順序介紹這三大特性

正文

1. 封裝（Encapsulation）

就是把類的屬性私有化(private修飾），再通過公有方法(public)進行訪問和修改

為什么要封裝呢？

1. 追蹤變化：可以在set方法中，編寫代碼來追蹤屬性的改變記錄

   public void setName(String name) {
       System.out.println("名字即將被修改");
       System.out.println("舊名字：" + this.name);
       System.out.println("新名字：" + name);
       this.name = name;
   }

   
   

2. 修改底層實現：在修改屬性名時，不會影響外部接口對屬性的訪問

   比如：name屬性改為firstName和lastName，name就可以在get方法中修改返回值為firstName+lastName，對外接口沒變化

   // 修改前
       private String name;
   
       public String getName() {
           return name;
       }
   
   // 修改后
       private String firstName;
       private String lastName;
       // 方法名不用變，只是方法內容作了修改
   	public String getName() {
           return firstName + lastName;
       }

   
   

   
   

3. 校驗數據：可以在set方法中，校驗傳來的數據是否符合屬性值的設定范圍，防止無效數據的亂入

   public void setAge(int age) throws Exception {
       if(age>1000 || age<0){
           throw new Exception("年齡不符合規范，0~1000");
       }
       this.age = age;
   }

   
   

2. 繼承(Inheritance)

如果子類繼承了父類，那么子類就可以復用父類的方法和屬性，并且可以在此基礎上新增方法和屬性

這里要注意的一點是：Java是單繼承語言，即每個類只能有一個父類

這里還要普及一個常識：如果一個類沒有指定父類（即沒有繼承任何類），那么這個類默認繼承Object類

為什么要用繼承呢？

為了代碼復用，減少重復工作

單繼承不會太局限嗎？為啥不用多繼承？

因為多繼承會導致"致命方塊"問題（因為像撲克牌的方塊符號）

• 比如A同時繼承B和C，然后B和C各自繼承D

• B和C各自覆寫了D的fun方法

• 那這時A該調用哪個類的fun方法呢

下面用圖來說話

那為什么叫致命方塊，而不是致命三角形呢？那個D類好像是多余的

不多余

這個D類其實就是上面講到的抽象類的作用：將共有的部分fun()抽象出來（或者提供一個基礎的實現），然后子類分別去實現各自的，這也是多態的一種體現（下面會將多態）

如果沒有D類，那么B和C的fun()就會存在重復代碼，這時你可能就想要搞一個父類出來了，這個父類就是D類

那要怎么判斷繼承類設計得好不好呢？

通過is-a關系來判斷

is-a關系指的是一個是另一個的關系，男人是人（說得通），人是男人（一半說得通）

用is-a關系可以很好地體現你的繼承類設計的好還是壞

• 如果子類都可以說是一個父類，那么這個繼承關系設計的就很好（男人是人，is-a關系）

• 如果子類和父類只是包含或者引用的關系，那么這個繼承關系就很糟糕（貓是貓籠，包含關系）

有沒有什么辦法可以阻止類的繼承？就像private修飾符用來封裝屬性，其他人訪問不到一樣

有啊，final修飾符可以阻止類的繼承

這里重點講一下final修飾符

final可以用來修飾屬性、方法、類，表示他們是常量，不可被修改的

final修飾屬性：屬性是常量，必須在定義時初始化，或者構造函數中初始化

final修飾方法：方法不能被覆寫

final修飾類：類不能被繼承

說到final，有必要提一下內聯

內聯指的是，如果一個方法內容很短，且沒有被其他類覆寫時，方法名會被直接替換為方法內容

比如：final getName()這個方法可以內聯為name屬性

再比如：getSum(){return a+b},會直接被內聯為a+b

為什么會有內聯這個東西呢？

因為這樣可以提高效率（細節：CPU在處理方法調用的指令時，使用的分支轉移會擾亂預取指令的策略，這個比較底層，這里先簡單介紹，后面章節再深入）

那它有沒有什么缺點呢？

有，如果一個方法內容過長，又誤被當做內聯處理，那么就會影響性能

比如你的代碼多個地方都調用這個方法，那么你的代碼就會膨脹變得很大，從而影響性能

那有沒有辦法可以解決呢？

有，虛擬機的即時編譯技術

即時編譯會進行判斷，如果一個方法內容很長，且被多次調用，那么它會自動關閉內聯機制，防止代碼膨脹

3. 多態(Polymorphism)

字面理解，就是多種形態，在Java中，多態指的是，一個類可以有多種表現形態

多態主要是 用來創建可擴展的程序

像我們上面提到的繼承就是屬于多態的一種

還有一種就是接口（interface）

接口類一種是比抽象類更加抽象的類

因為抽象類起碼還可以實現方法，但是接口類沒得選，就只能定義方法，不能實現

不過從Java8開始，接口支持定義默認方法和靜態方法

接口的默認方法（default修飾符）和靜態方法（static修飾符)，會包含方法內容，這樣別人可以直接調用接口類的方法（后面章節再細講）

這樣你會發現接口變得很像抽象類了，不過接口支持多實現（即一個類可以同時實現多個類，但是一個類同時只能繼承一個類）

這樣一來，Java相當于間接地實現了多繼承

下圖說明繼承和實現的區別：單繼承，多實現

多態一般用在哪些場景呢？

場景很多，這里說兩個最常用的

• 場景一：方法的參數，即方法定義時，父類作為方法的形參，然后調用時傳入子類作為方法的實參

• 場景二：方法的返回值，即方法定義時，父類作為方法的返回值，然后在方法內部實際返回子類

代碼示范如下：

public class PolyphorismDemo {
    public static void main(String[] args) {
        PolyphorismDemo demo = new PolyphorismDemo();
        //場景一：形參，將貓（子類）賦值給動物（父類）
        demo.fun(new Cat());
        //場景二：返回值，將貓賦值給動物
        Animal animal = demo.fun2();
    }
    
    public void fun(Animal animal){
        
    }
    
    public Animal fun2(){
        return new Cat();
    }
}

class Animal{
    
}

class Cat extends Animal{
    
}

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。