Java知識回顧（7）繼承、多態與接口、封裝

時間 2019-12-10

標籤 java 知識回顧繼承接口封裝欄目 Java 简体版

原文原文鏈接

1、繼承

1.1 繼承的特性

子類擁有父類非 private 的屬性、方法。

子類能夠擁有本身的屬性和方法，即子類能夠對父類進行擴展。

子類能夠用本身的方式實現父類的方法。

Java 的繼承是單繼承，可是能夠多重繼承。單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如 A 類繼承 B 類，B 類繼承 C 類，因此按照關係就是 C 類是 B 類的父類，B 類是 A 類的父類，這是 Java 繼承區別於 C++ 繼承的一個特性。

提升了類之間的耦合性（繼承的缺點，耦合度高就會形成代碼之間的聯繫越緊密，代碼獨立性越差）。

1.2 繼承關鍵字

　　繼承可使用 extends 和 implements 這兩個關鍵字來實現繼承，並且全部的類都是繼承於 java.lang.Object，當一個類沒有繼承的兩個關鍵字，則默認繼承object（這個類在 java.lang 包中，因此不須要 import）祖先類。java

　　final 關鍵字聲明類能夠把類定義爲不能繼承的，即最終類；或者用於修飾方法，該方法不能被子類重寫。編程

1.3 構造器

子類是不繼承父類的構造器（構造方法或者構造函數）的，它只是調用（隱式或顯式）。安全

若是父類的構造器帶有參數，則必須在子類的構造器中顯式地經過 super 關鍵字調用父類的構造器並配以適當的參數列表。編程語言

若是父類構造器沒有參數，則在子類的構造器中不須要使用 super 關鍵字調用父類構造器，系統會自動調用父類的無參構造器。 ide

2、重寫(Override)與重載(Overload)

2.1 重寫(Override)

重寫是子類對父類的容許訪問的方法的實現過程進行從新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！函數

重寫的好處在於子類能夠根據須要，定義特定於本身的行爲。也就是說子類可以根據須要實現父類的方法。測試

重寫方法不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的異常。例如：父類的一個方法申明瞭一個檢查異常 IOException，可是在重寫這個方法的時候不能拋出 Exception 異常，由於 Exception 是 IOException 的父類，只能拋出 IOException 的子類異常。this

在面向對象原則裏，重寫意味着能夠重寫任何現有方法。spa

方法的重寫規則設計

參數列表必須徹底與被重寫方法的相同；
返回類型與被重寫方法的返回類型能夠不相同，可是必須是父類返回值的派生類（java5 及更早版本返回類型要同樣，java7 及更高版本能夠不一樣）；
訪問權限不能比父類中被重寫的方法的訪問權限更低。例如：若是父類的一個方法被聲明爲public，那麼在子類中重寫該方法就不能聲明爲protected。
父類的成員方法只能被它的子類重寫。
聲明爲final的方法不能被重寫。
聲明爲static的方法不能被重寫，可是可以被再次聲明。
子類和父類在同一個包中，那麼子類能夠重寫父類全部方法，除了聲明爲private和final的方法。
子類和父類不在同一個包中，那麼子類只可以重寫父類的聲明爲public和protected的非final方法。
重寫的方法可以拋出任何非強制異常，不管被重寫的方法是否拋出異常。可是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更普遍的強制性異常，反之則能夠。
構造方法不能被重寫。
若是不能繼承一個方法，則不能重寫這個方法。

Super關鍵字的使用

當須要在子類中調用父類的被重寫方法時，要使用super關鍵字。

class Animal{
   public void move(){
      System.out.println("動物能夠移動");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 應用super類的方法
      System.out.println("狗能夠跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 對象
      b.move(); //執行 Dog類的方法
 
   }
}

2.2 重載(Overload)

重載(overloading) 是在一個類裏面，方法名字相同，而參數不一樣。返回類型能夠相同也能夠不一樣。

每一個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。

最經常使用的地方就是構造器的重載。

重載規則:

被重載的方法必須改變參數列表(參數個數或類型不同)；
被重載的方法能夠改變返回類型；
被重載的方法能夠改變訪問修飾符；
被重載的方法能夠聲明新的或更廣的檢查異常；
方法可以在同一個類中或者在一個子類中被重載。
沒法以返回值類型做爲重載函數的區分標準。

2.3 總結

方法的重寫(Overriding)和重載(Overloading)是java多態性的不一樣表現，重寫是父類與子類之間多態性的一種表現，重載能夠理解成多態的具體表現形式。

(1)方法重載是一個類中定義了多個方法名相同,而他們的參數的數量不一樣或數量相同而類型和次序不一樣,則稱爲方法的重載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,並且參數的個數與類型同樣,返回值也同樣的方法,就稱爲重寫(Overriding)。
(3)方法重載是一個類的多態性表現,而方法重寫是子類與父類的一種多態性表現

3、多態

3.1 多態的含義與應用

多態性是對象多種表現形式的體現。

如，同一個事件發生在不一樣的對象上會產生不一樣的結果。

多態的優勢

1. 消除類型之間的耦合關係
2. 可替換性
3. 可擴充性
4. 接口性
5. 靈活性
6. 簡化性

多態存在的三個必要條件

繼承
重寫（Overriding）
父類引用指向子類對象

當使用多態方式調用方法時，首先檢查父類中是否有該方法，若是沒有，則編譯錯誤；若是有，再去調用子類的同名方法。

多態的好處：可使程序有良好的擴展，並能夠對全部類的對象進行通用處理。

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 對象調用 show 方法
      show(new Dog());  // 以 Dog 對象調用 show 方法
                
      Animal a = new Cat();  // 向上轉型  
      a.eat();               // 調用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下轉型  
      c.work();        // 調用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 類型判斷
        if (a instanceof Cat)  {  // 貓作的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗作的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

3.2 虛函數

虛函數的存在是爲了多態。

Java 中其實沒有虛函數的概念，它的普通函數就至關於 C++ 的虛函數，動態綁定是Java的默認行爲。若是 Java 中不但願某個函數具備虛函數特性，能夠加上 final 關鍵字變成非虛函數。

重寫

咱們將介紹在 Java 中，當設計類時，被重寫的方法的行爲怎樣影響多態性。

咱們已經討論了方法的重寫(子類可以重寫父類的方法)。當子類對象調用重寫的方法時，調用的是子類的方法，而不是父類中被重寫的方法。

要想調用父類中被重寫的方法，則必須使用關鍵字 super。

例

父類

public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 構造函數");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("郵寄支票給： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

Employee

子類

public class Salary extends Employee
{
   private double salary; // 整年工資
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 類的 mailCheck 方法 ");
       System.out.println("郵寄支票給：" + getName()
       + " ，工資爲：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("計算工資，付給：" + getName());
      return salary/52;
   }
}

Salary

測試

/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("員工 A", "北京", 3, 3600.00);
      Employee e = new Salary("員工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用調用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用調用 mailCheck--");
      e.mailCheck();
    }
}

以上實例編譯運行結果以下：

Employee 構造函數
Employee 構造函數
使用 Salary 的引用調用 mailCheck -- 
Salary 類的 mailCheck 方法 
郵寄支票給：員工 A ，工資爲：3600.0

使用 Employee 的引用調用 mailCheck--
Salary 類的 mailCheck 方法 
郵寄支票給：員工 B ，工資爲：2400.0

3.3 多態的實現方式

方式一：重寫：

方式二：接口

1. 生活中的接口最具表明性的就是插座，例如一個三接頭的插頭都能接在三孔插座中，由於這個是每一個國家都有各自規定的接口規則，有可能到國外就不行，那是由於國外本身定義的接口類型。
2. java中的接口相似於生活中的接口，就是一些方法特徵的集合，但沒有方法的實現。

方式三：抽象類和抽象方法

4、接口

接口（英文：Interface），在JAVA編程語言中是一個抽象類型，是抽象方法的集合，接口一般以interface來聲明。一個類經過繼承接口的方式，從而來繼承接口的抽象方法。

接口並非類，編寫接口的方式和類很類似，可是它們屬於不一樣的概念。類描述對象的屬性和方法。接口則包含類要實現的方法。

除非實現接口的類是抽象類，不然該類要定義接口中的全部方法。

接口沒法被實例化，可是能夠被實現。一個實現接口的類，必須實現接口內所描述的全部方法，不然就必須聲明爲抽象類。另外，在 Java 中，接口類型可用來聲明一個變量，他們能夠成爲一個空指針，或是被綁定在一個以此接口實現的對象。

接口與類類似點：

一個接口能夠有多個方法。
接口文件保存在 .java 結尾的文件中，文件名使用接口名。
接口的字節碼文件保存在 .class 結尾的文件中。
接口相應的字節碼文件必須在與包名稱相匹配的目錄結構中。

接口與類的區別：

接口不能用於實例化對象。
接口沒有構造方法。
接口中全部的方法必須是抽象方法。
接口不能包含成員變量，除了 static 和 final 變量。
接口不是被類繼承了，而是要被類實現。
接口支持多繼承。

接口特性

接口中每個方法也是隱式抽象的,接口中的方法會被隱式的指定爲 public abstract（只能是 public abstract，其餘修飾符都會報錯）。
接口中能夠含有變量，可是接口中的變量會被隱式的指定爲 public static final 變量（而且只能是 public，用 private 修飾會報編譯錯誤）。
接口中的方法是不能在接口中實現的，只能由實現接口的類來實現接口中的方法。

抽象類和接口的區別

1. 抽象類中的方法能夠有方法體，就是能實現方法的具體功能，可是接口中的方法不行。
2. 抽象類中的成員變量能夠是各類類型的，而接口中的成員變量只能是 public static final 類型的。
3. 接口中不能含有靜態代碼塊以及靜態方法(用 static 修飾的方法)，而抽象類是能夠有靜態代碼塊和靜態方法。
4. 一個類只能繼承一個抽象類，而一個類卻能夠實現多個接口。

重寫接口中聲明的方法時，須要注意如下規則：

類在實現接口的方法時，不能拋出強制性異常，只能在接口中，或者繼承接口的抽象類中拋出該強制性異常。
類在重寫方法時要保持一致的方法名，而且應該保持相同或者相兼容的返回值類型。
若是實現接口的類是抽象類，那麼就不必實現該接口的方法。

在實現接口的時候，也要注意一些規則：

一個類能夠同時實現多個接口。
一個類只能繼承一個類，可是能實現多個接口。
一個接口能繼承另外一個接口，這和類之間的繼承比較類似。

接口的繼承

一個接口能繼承另外一個接口，和類之間的繼承方式比較類似。接口的繼承使用extends關鍵字，子接口繼承父接口的方法。

在Java中，類的多繼承是不合法，但接口容許多繼承。

在接口的多繼承中extends關鍵字只須要使用一次，在其後跟着繼承接口。

5、Java 封裝

在面向對象程式設計方法中，封裝（英語：Encapsulation）是指一種將抽象性函式接口的實現細節部份包裝、隱藏起來的方法。

封裝能夠被認爲是一個保護屏障，防止該類的代碼和數據被外部類定義的代碼隨機訪問。

要訪問該類的代碼和數據，必須經過嚴格的接口控制。

封裝最主要的功能在於咱們能修改本身的實現代碼，而不用修改那些調用咱們代碼的程序片斷。

適當的封裝可讓程式碼更容易理解與維護，也增強了程式碼的安全性。

封裝的優勢

1. 良好的封裝可以減小耦合。
2. 類內部的結構能夠自由修改。
3. 能夠對成員變量進行更精確的控制。
4. 隱藏信息，實現細節。

6、抽象類、方法

6.1 抽象類

在面向對象的概念中，全部的對象都是經過類來描繪的，可是反過來，並非全部的類都是用來描繪對象的，若是一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。

抽象類除了不能實例化對象以外，類的其它功能依然存在，成員變量、成員方法和構造方法的訪問方式和普通類同樣。

因爲抽象類不能實例化對象，因此抽象類必須被繼承，才能被使用。也是由於這個緣由，一般在設計階段決定要不要設計抽象類。

父類包含了子類集合的常見的方法，可是因爲父類自己是抽象的，因此不能使用這些方法。

在Java中抽象類表示的是一種繼承關係，一個類只能繼承一個抽象類，而一個類卻能夠實現多個接口。

6.2 抽象方法

若是你想設計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現由它的子類肯定，那麼你能夠在父類中聲明該方法爲抽象方法。

Abstract 關鍵字一樣能夠用來聲明抽象方法，抽象方法只包含一個方法名，而沒有方法體。

抽象方法沒有定義，方法名後面直接跟一個分號，而不是花括號。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其他代碼
}