對於Java的多態概念的理解

　　　　在學習Java的過程中,我們無論如何也繞不過多態這個東西。它到底是個什麽東西呢？

　　其實，它就是指調用相同名字的方法，但是得到的結果是不同的。

第一： 對象是方法

　　多態的作用範圍是方法，不是類不是對象，也不是對象裏面的屬性

第二： 多態產生的條件

　　1、有繼承---在子類中有方法重寫---在方法的調用中，有指向子類的父類的引用

　　2、有方法的重載，就是相同方法名，但參數不同（個數，類型，順序）

第三：為什麽需要多態？

　　因為真實世界中的情況是紛繁復雜的，為了應對生活中的種種情況，我們就

需要程序能夠分別應對各種情況。即增加了程序的靈活性，來滿足客戶需求。

第四：Java運行時的多態性

　　運行時多態性或動態方法分派是一個過程，它對重寫方法的調用在運行時體現而不是編譯時。

　　在此過程中，通過超類的引用變量調用重寫的方法。 要調用的方法基於引用的對象。

　　了解運行時多態性之前，讓我們先來向上轉換。

　　向上轉換

　　當父類的引用變量引用子類的對象時，稱為向上轉換。 例如：

class A{}  
class B extends A{}  
A a=new B();  //向上轉換...

Java運行時多態性示例1

在這個例子中，我們創建兩個類：Bike和Splendar。 Splendar類擴展Bike類並覆蓋其run()方法。通過父類(Bike

因為方法調用是由JVM不是編譯器決定的，所以它被稱為運行時多態性。

class Bike {
    void run() {
        System.out.println("running");
    }
}

class Splender extends Bike {
    void run() {
        System.out.println("running safely with 60km");
    }

    public static void main(String args[]) {
        Bike b 
 
= new Splender();// upcasting - 向上轉換
        b.run();
    }
}

執行上面代碼得到以下結果 -

running safely with 60km.

Java運行時多態性示例2：Bank

考慮一種情況，Bank類是一個提供獲得利率的方法的類。 但是，利率可能因銀行而異。 例如，SBI，ICICI和AXIS銀行分別提供8.4％，7.3％和9.7％的利率。

註意：此示例也在方法覆蓋中給出，但沒有向上轉換。

class Bank {
    float getRateOfInterest() {
        return 0;
    }
}

class SBI extends Bank {
    float getRateOfInterest() {
        return 8.4f;
    }
}

class ICICI extends Bank {
    float getRateOfInterest() {
        return 7.3f;
    }
}

class AXIS extends Bank {
    float getRateOfInterest() {
        return 9.7f;
    }
}

class TestPolymorphism {
    public static void main(String args[]) {
        Bank b;
        b = new SBI();
        System.out.println("SBI Rate of Interest: " + b.getRateOfInterest());
        b = new ICICI();
        System.out.println("ICICI Rate of Interest: " + b.getRateOfInterest());
        b = new AXIS();
        System.out.println("AXIS Rate of Interest: " + b.getRateOfInterest());
    }
}

上面代碼執行結果如下 -

SBI Rate of Interest: 8.4
ICICI Rate of Interest: 7.3
AXIS Rate of Interest: 9.7

Java運行時多態性示例3：Shape

class Shape { // 基類(形狀)
    void draw() {
        System.out.println("drawing...");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("drawing rectangle...");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("drawing circle...");
    }
}

class Triangle extends Shape {
    void draw() {
        System.out.println("drawing triangle...");
    }
}

class TestPolymorphism2 {
    public static void main(String args[]) {
        Shape s;
        s = new Rectangle();
        s.draw();
        s = new Circle();
        s.draw();
        s = new Triangle();
        s.draw();
    }
}

上面代碼執行結果如下 -

drawing rectangle...
drawing circle...
drawing triangle...

Java運行時多態性示例4：Animal

class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("eating bread...");
    }
}

class Cat extends Animal {
    void eat() {
        System.out.println("eating rat...");
    }
}

class Lion extends Animal {
    void eat() {
        System.out.println("eating meat...");
    }
}

class TestPolymorphism3 {
    public static void main(String[] args) {
        Animal a;
        a = new Dog();
        a.eat();
        a = new Cat();
        a.eat();
        a = new Lion();
        a.eat();
    }
}

上面代碼執行結果如下 -

eating bread...
eating rat...
eating meat...

Java運行時多態性與數據成員

上面示例中，都是有關方法被覆蓋而不是數據成員，因此運行時多態性不能由數據成員實現。
在下面給出的例子中，這兩個類都有一個數據成員:speedlimit，通過引用子類對象的父類的

引用變量來訪問數據成員。 由於我們訪問的數據成員沒有被重寫，因此它將訪問父類的數據成員。

規則： 運行時多態性不能由數據成員實現。

class Bike {
    int speedlimit = 90;
}

class Honda3 extends Bike {
    int speedlimit = 150;

    public static void main(String args[]){  
        Bike obj=new Honda3();  
        System.out.println(obj.speedlimit);//90 
    }
}

上面代碼執行結果如下 -

90

總結：在實際使用的時候，我們會定義多個同名的方法，通過方法重載和方法重寫的方式。

方法重載： 例如Java自帶的println方法，無論是輸入數字、字符、字符串，都可以正確的打印出來。　　　

作為用戶，它不關心是怎麽實現的，只要拿來就能用，就能完成想要程序去完成的任務，

那麽，這個程序就是ok的，就醬紫~

多態的深入理解