深入理解Java面向對象三大特性 封裝 繼承 多態

就像所以Java的書籍一樣，開篇必須是面向對象的特征，封裝、繼承、多態。

1.封裝

封裝的定義：

• 首先是抽象，把事物抽象成一個類，其次才是封裝，將事物擁有的屬性和動作隱藏起來，只保留特定的方法與外界聯系

為什么需要封裝：

• 封裝符合面向對象設計原則的第一條：單一性原則，一個類把自己該做的事情封裝起來，而不是暴露給其他類去處理，當內部的邏輯發生變化時，外部調用不用因此而修改，他們只調用開放的接口，而不用去關心內部的實現

舉例：

 

public class Human
{
    private int age;
    private String name;

    public int getAge()
    {
        return age;
    }

    public void setAge( int age ) throws Exception
    {
        //封裝age的檢驗邏輯，而不是暴露給每個調用者去處理
        if( age > 120 )
        {
            throw new Exception( "Invalid value of age" );
        }
        this.age = age;
    }

    public String getName()
    {
        return name;
    }

    public void setName( String name )
    {
        this.name = name;
    }
}

2. 繼承

Java的類可以分為三類：

• 類：使用class定義，沒有抽象方法
• 抽象類：使用abstract class定義，可以有也可以沒有抽象方法
• 接口：使用interface定義，只能有抽象方法

在這三個類型之間存在如下關系：

• 類可以extends：類、抽象類（必須實現所有抽象方法），但只能extends一個，可以implements多個接口（必須實現所有接口方法）
• 抽象類可以extends：類，抽象類（可全部、部分、或者完全不實現父類抽象方法），可以implements多個接口（可全部、部分、或者完全不實現接口方法）
• 接口可以extends多個接口

繼承以后子類可以得到什么：

• 子類擁有父類非private的屬性和方法
• 子類可以添加自己的方法和屬性，即對父類進行擴展
• 子類可以重新定義父類的方法，即多態里面的覆蓋，后面會詳述

關於構造函數：

• 構造函數不能被繼承，子類可以通過super()顯示調用父類的構造函數
• 創建子類時，編譯器會自動調用父類的 無參構造函數
• 如果父類沒有定義無參構造函數，子類必須在構造函數的第一行代碼使用super()顯示調用

類默認擁有無參構造函數，如果定義了其他有參構造函數，則無參函數失效，所以父類沒有定義無參構造函數，不是指父類沒有寫無參構造函數。看下面的例子，父類為Human，子類為Programmer。

public class Human
{
    //定義了有參構造函數，默認無參構造函數失效
    public Human(String name)
    {
    }
}

public class Programmer
    extends Human
{
    public Programmer()
    {
        //如不顯示調用，編譯器會出現如下錯誤
        //Implicit super constructor Human() is undefined. Must explicitly invoke another constructor
        super( "x" );
    }
}

為什么需要繼承：

• 代碼重用是一點，最重要的還是所謂想上轉型，即父類的引用變量可以指向子類對象，這是Java面向對象最重要特性多態的基礎

3. 多態

在了解多態之前，首先需要知道方法的唯一性標識即什么是相同/不同的方法：

• 一個方法可以由：修飾符如public、static+返回值+方法名+參數+throw的異常 5部分構成
• 其中只有方法名和參數是唯一性標識，意即只要方法名和參數相同那他們就是相同的方法
• 所謂參數相同，是指參數的個數，類型，順序一致，其中任何一項不同都是不同的方法

何謂重載：

• 重載是指一個類里面（包括父類的方法）存在方法名相同，但是參數不一樣的方法，參數不一樣可以是不同的參數個數、類型或順序
• 如果僅僅是修飾符、返回值、throw的異常 不同，那這是2個相同的方法，編譯都通不過，更不要說重載了

//重載的例子
public class Programmer
    extends Human
{
    public void coding() throws Exception
    {

    }

    public void coding( String langType )
    {

    }

    public String coding( String langType, String project )
    {
        return "";
    }
}

//這不是重載，而是三個相同的方法，編譯報錯
public class Programmer
    extends Human
{
    public void coding() throws Exception
    {

    }

    public void coding()
    {

    }

    public String coding()
    {
        return "";
    }
}

何謂覆蓋/重寫：

• 覆蓋描述存在繼承關系時子類的一種行為
• 子類中存在和父類相同的方法即為覆蓋，何謂相同方法請牢記前面的描述，方法名和參數相同，包括參數個數、類型、順序

public class Human
{
    public void coding( String langType )
    {

    }
}

public class Programmer
    extends Human
{
    //此方法為覆蓋/重寫
    public void coding( String langType )
    {

    }

    //此方法為上面方法的重載
    public void coding( String langType, String project )
    {

    }
}

覆蓋/重寫的規則：

• 子類不能覆蓋父類private的方法，private對子類不可見，如果子類定義了一個和父類private方法相同的方法，實為新增方法
• 重寫方法的修飾符一定要大於或等於被重寫方法的修飾符(public > protected > default > private)
• 重寫拋出的異常需與父類相同或是父類異常的子類，或者重寫方法干脆不寫throws
• 重寫方法的返回值必須與被重寫方法一致，否則編譯報錯
• 靜態方法不能被重寫為非靜態方法，否則編譯出錯

理解了上述知識點，是時候定義多態了：

• 多態可以說是“一個接口，多種實現”或者說是父類的引用變量可以指向子類的實例，被引用對象的類型決定調用誰的方法，但這個方法必須在父類中定義
• 多態可以分為兩種類型：編譯時多態（方法的重載）和運行時多態（繼承時方法的重寫），編譯時多態很好理解，后述內容針對運行時多態
• 運行時多態依賴於繼承、重寫和向上轉型

上例子：

class Human
{
    public void showName()
    {
        System.out.println( "I am Human" );
    }
}

//繼承關系
class Doctor
    extends Human
{
    //方法重寫
    public void showName()
    {
        System.out.println( "I am Doctor" );
    }
}

class Programmer
    extends Human
{
    public void showName()
    {
        System.out.println( "I am Programmer" );
    }
}

public class Test
{
    //向上轉型
    public Human humanFactory( String humanType )
    {
        if( "doctor".equals( humanType ) )
        {
            return new Doctor();
        }
        if( "programmer".equals( humanType ) )
        {
            return new Programmer();
        }
        return new Human();
    }

    public static void main( String args[] )
    {
        Test test = new Test();
        Human human = test.humanFactory( "doctor" );
        human.showName();//Output:I am Doctor
        human = test.humanFactory( "programmer" );
        human.showName();//Output:I am Programmer
        //一個接口的方法，表現出不同的形態，意即為多態也
    }
}

向上轉型的缺憾：

• 只能調用父類中定義的屬性和方法，對於子類中的方法和屬性它就望塵莫及了，必須強轉成子類類型

總結概括：

• 當超類對象引用變量引用子類對象時，被引用對象的類型而不是引用變量的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法，但是它仍然要根據繼承鏈中方法調用的優先級來確認方法，該優先級為：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)

稍微復雜的例子：

class Human {

    public void fun1() {
        System.out.println("Human fun1");
        fun2();
    }

    public void fun2() {
        System.out.println("Human fun2");
    }
}

class Programmer extends Human {

    public void fun1(String name) {
        System.out.println("Programmer's fun1");
    }

    public void fun2() {
        System.out.println("Programmer's fun2");
    }
}

public class Test {
    public static void main(String[] args) {
        Human human = new Programmer();
        human.fun1();
    }
    /*
     * Output:
     *  Human fun1
     *  Programmer's fun2
     */
}

• Programmer中的fun1(String name) 和Human中的fun1()，只是方法名相同但參數不一樣，所以是重載關系
• Programmer中的fun2()和Human中的fun2()是相同的方法，即Programmer重寫了Human的fun2()方法
• 把Programmer的對象向上轉型賦值個Human后，human.fun1()會調用父類中的fun1()方法，子類的fun1(String name)是不同的方法
• 在human的fun1()中又調用了fun2()方法，該方法在Programmer中被重寫，實際調用的是被引用變量Programmer中的fun2()方法

 

package test;

class A {
    public void func() {
        System.out.println("func in A");
    }
}

class B extends A {
    public void func() {
        System.out.println("func in B");
    }
}

class C extends B {
    public void func() {
        System.out.println("func in B");
    }
}

public class Bar {
    public void test(A a) {
        a.func();
        System.out.println("test A in Bar");
    }

    public void test(C c) {
        c.func();
        System.out.println("test C in Bar");
    }

    public static void main(String[] args) {
        Bar bar = new Bar();
        A a = new A();
        B b = new B();
        C c = new C();
        bar.test(a);
        bar.test(b);
        bar.test(c);
        /*
            func in A
            test A in Bar
            func in B
            test A in Bar
            func in B
            test C in Bar
         */
    }
}

 經典例子：

• 請參看http://blog.csdn.net/thinkGhoster/article/details/2307001
• 牢記調用順序：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)