java中的抽象類abstract怎麼使用？

抽象類概述

當編寫一個類時，我們往往會為該類定義一些方法，這些方法是用來描述該類的功能具體實現方式，那麼這些方法都有具體的方法體。

但是有的時候，某個父類只是知道子類應該包含怎麼樣的方法，但是無法準確知道子類如何實現這些方法。比如一個圖形類應該有一個求周長的方法，但是不同的圖形求周長的演算法不一樣。那該怎麼辦呢？

分析事物時，發現了共性內容，就出現向上抽取。會有這樣一種特殊情況，就是方法功能宣告相同，但方法功能主體不同。那麼這時也可以抽取，但只抽取方法宣告，不抽取方法主體。那麼此方法就是一個抽象方法。

1 、   案例程式碼 :

package com.itheima_01;

/*

 * abstract: 關鍵字，用於修飾方法和類

 * 抽象方法：不同類的方法是相似，但是具體內容又不太一樣，所以我們只能抽取他的宣告，沒有具體的方法體，沒有具體方法體的方法就是抽象方法

 * 抽象類：有抽象方法的類必須是抽象類

 *

 * 注意：一個類繼承了抽象類需要重寫他所有的抽象方法 , 否則這個類就得是抽象類

 */

public class AbstractDemo {

}

abstract class Animal1 {

public abstract void eat();

// 非抽象方法子類可以不重寫

public void run() {

}

}

class Cat1 extends Animal1 {

@Override

public void eat() {

System.out.println(" 貓吃魚 ");

}

/*public void eat() {

System.out.println(" 貓吃魚 ");

}*/

}

abstract class Dog1 extends Animal1 {

/*public void eat() {

System.out.println(" 狗吃屎 ");

}*/

}

2 、   抽象類的特點

  抽象類的特點：

   抽象方法只能在抽象類裡面

   抽象類和抽象方法必須被 abstract 修飾

   抽象類不能建立物件（不能例項化）

    抽象類中可以有非抽象的方法

    抽象類和類的關係也是繼承

    一個類繼承了抽象類要麼重寫所有的抽象方法，要麼他自己是抽象類

案例程式碼:

package com.itheima_01;

/*

 * 抽象類的特點：

 *   抽象方法只能在抽象類裡面

 *   抽象類和抽象方法必須被abstract 修飾

 *   抽象類不能建立物件（不能例項化）

 *   抽象類中可以有非抽象的方法

 *   抽象類和類的關係也是繼承

 *   一個類繼承了抽象類要麼重寫所有的抽象方法，要麼他自己是抽象類

 */

public class AbstractDemo2 {

public static void main(String[] args) {

//Animal a = new Animal();

}

}

abstract class Animal2 {

public abstract void eat();

public void run() {

}

}

class Cat2 extends Animal2 {

@Override

public void eat() {

// TODO Auto-generated method stub

}

}

3 、抽象類的成員的特點

A: 抽象類的成員特點：

   成員變數

   可以有成員變數

   可以有常量

   成員方法

   可以有抽象方法

   可以有非抽象方法

   構造方法

   可以有構造方法的，需要對抽象類的成員變數進行初始化

案例程式碼:

package com.itheima_01;

/*

 * 抽象類的成員特點：

 *   成員變數

 *   可以有成員變數

 *   可以有常量

 *   成員方法

 *   可以有抽象方法

 *   可以有非抽象方法

 *   構造方法

 *   可以有構造方法的，需要對抽象類的成員變數進行初始化

 *

 * final: 修飾類、成員變數、成員方法

 */

public class AbstractDemo3 {

public static void main(String[] args) {

Dog d = new Dog();

d.barking();

}

}

abstract class Animal {

String name = " 哮天犬 ";

final int num = 10;

public Animal() {

System.out.println(" 我是抽象類的構造方法 ");

}

public abstract void eat();

public void run() {}

}

class Dog extends Animal {

public void barking() {

System.out.println(name);

System.out.println(num);

}

@Override

public void eat() {

// TODO Auto-generated method stub

}

}

4 、抽象類的細節

 A: 抽象類關鍵字 abstract 可以和哪些關鍵字共存 ?

1.private ：

私有的方法子類是無法繼承到的，也不存在覆蓋，而abstract 和 private 一起使用修飾方法， abstract 既要子類去實現這個方法，而 private 修飾子類根本無法得到父類這個方法。互相矛盾。

2.final: 

   抽象類不能和 final 共存 , 因為抽象類自身無法建立物件 , 我們需要通過子類建立物件 , 一旦抽象類使用 final 關鍵字 , 那麼抽象類就沒有子類

   抽象方法不能和 final 共存 , 因為抽象方法後期需要被子類重寫 , 一旦加 final 無法重寫    

3.static:

   抽象方法不能和 static 關鍵字共存 , 因為一旦加 static 我們就可以通過類名直接訪問抽象方法 , 由於抽象方法沒有方法體 , 沒有任何意義 , 也不允許這樣做

B: 抽象類中是否可以不定義抽象方法 ?

是可以的，那這個抽象類的存在到底有什麼意義呢？不讓該類建立物件, 方法可以直接讓子類去使用

C: 抽象類是否有建構函式 ?

有, 抽象類的建構函式 , 是由子類的 super 語句來呼叫 , 用於給抽象類中的成員初始化

用關鍵字abstract 修飾的方法稱為抽象方法。

對於抽象方法，只允許宣告，不允許實現（沒有方法體），而且不允許finnal 和 abstract 修飾同一方法或類，也不允許 static 修飾 abstr 方法，即 abstract 方法必須是實列方法。

abstra 類不能用 new 運算子建立物件

abstract 類的子類必需重寫 abstra 類中的方法

abstra 類的物件作為上轉型物件

abstract class GirlFriend {

    abstract void speak();

    abstract void cooking();

}

class ChinaGirlFriend extends GirlFriend {

    void speak() {

        System.out.println(" 你好 ");

    }

    void cooking() {

        System.out.println(" 水煮魚 ");

    }

}

class AmericanGirlFriend extends GirlFriend {

    void speak() {

        System.out.println("Hello!");

    }

    void cooking() {

        System.out.println("Roast beef");

    }

}

class Boy {

    GirlFriend friend;

    void SetGirFriend(GirlFriend f) {

        friend = f;

    }

    void showGirlFriend() {

        friend.speak();

        friend.cooking();

    }

}

public class Test {

    public static void main(String[] args) {

        GirlFriend girl = new ChinaGirlFriend(); //girl is Upper  Transition Object

        Boy boy = new Boy();

        boy.SetGirFriend(girl);

        boy.showGirlFriend();

        girl = new AmericanGirlFriend();

        boy.SetGirFriend(girl);

        boy.showGirlFriend();

    }

}

面向抽象程式設計

在程式設計中我們經常會使用abstra 類，因為它只關心操作，而不在意具體實現細節。

所謂的面向抽象程式設計，是指設計某種重要的類時，不讓該類面向具體的類，而是面向抽象類。

import java.awt.*;

public class Test {

    public static void main(String[] args) {

        double a,b;

        Pillar pillar;

        Geometry bottom=null;

        pillar=new Pillar(bottom,100);

        System.out.println(" 體積 "+pillar.getVolume());

        bottom=new Rectangle(12,22);

        pillar=new Pillar(bottom,58);

        System.out.println(" 體積 "+pillar.getVolume());

        bottom=new Circle(10);

        pillar=new Pillar(bottom,58);

        System.out.println(" 體積 "+pillar.getVolume());

    }

}

abstract class Geometry {

    abstract double getArea();

}

class  Pillar {

    Geometry bottom;  //bottom is a variable by  the abstract class geometry

    double height;

 

    Pillar(Geometry bottom, double height) {

        this.bottom = bottom;

        this.height = height;

    }

    public double getVolume() {

        if (bottom == null) {

            System.out.println(" 沒有底，無法計算面積！ ");

            return  -1;

        }

        return bottom.getArea() * height;  //Bottom can call the getArea method that the subclass overrides

    }

}

class Circle extends Geometry {

    double r;

    Circle(double r) {

        this.r = r;

    }

    public double getArea() {

        return (3.14 * 3.14 * r);

    }

}

class Rectangle extends Geometry{

    double a, b;

    Rectangle(double a, double b) {

        this.a = a;

        this.b = b;

    }

    double getArea() {

        return a * b;

    }

}

為什麼使用抽象類

首先做一個分析如下：

1 ：定義 Dog 類

    有顏色屬性和叫的方法

2 ：定義 Bird 類

    有顏色屬性和叫的方法

3 ：定義其父類 Animal

1 ：抽取共性顏色屬性和叫的方法

   1 ：顏色的屬性可以使用預設初始化值。

   2 ：叫的方法在父類中如何定義？

      1 ：狗是旺旺

      2 ：鳥是嘰嘰喳喳

      3 ：可以將父類的方法定義為狗叫讓鳥繼承父類重寫叫的方法

            1 ：鳥怎麼確定是否要重寫父類方法。

            2 ：不重寫，編譯和執行都沒有問題，只是執行鳥叫的方法就會出現狗叫

      4 ：父類的方法很難確定。

上方描述程式碼如下：

function(){   //外匯返傭：http://www.kaifx.cn/

class Animal {

    String color;

     void shout(){

         // 如何定義呢 ? 是旺旺還是嘰嘰喳喳 ?

     }

}

class Dog extends Animal {

    void shout() {

        System.out.println(" 旺旺 ");

    }

}

class Bird extends Animal {

    void shout() {

        System.out.println(" 嘰嘰喳喳 ");

    }

}

那麼此時使用abstract 能夠解決這個問題 。

4 ：抽象類

1 ：當描述一個類的時候，如果不能確定功能函式如何定義，那麼該類就可以定義為抽象類，功能函式應該描述為抽象函式。

5 ：抽象類的實現方式

       1 ：定義 animal 類

              1 ：定義叫的方法，無法確定方法體，不寫方法體

                 1 ： public void shout (); 編譯失敗

              2 ：根據提示在 shout 的方法加入 abstract 修飾

                 1 ：編譯失敗，有新的提示

              3 ：根據提示將類加入 abstract 修飾

                 1 ：編譯通過

abstract class Animal {

    String color;

    abstract void shout();

}

class Dog extends Animal {

    void shout() {

        System.out.println(" 旺旺 ");

    }

}

class Bird extends Animal {

    void shout() {

        System.out.println(" 嘰嘰喳喳 ");

    }

}

6 ：抽象類的特點

       1 ：有抽象函式的類，該類一定是抽象類。

       2 ：抽象類中不一定要有抽象函式。

       3 ：抽象類不能使用 new 建立物件

          1 ：建立物件，使用物件的功能，抽象類的方法，沒有方法體。

       4 ：抽象類主要為了提高程式碼的複用性，讓子類繼承來使用。

       5 ：編譯器強制子類實現抽象類父類的未實現的方法。

          1 ：可以不實現，前提是子類的也要宣告為抽象的。

7 ：抽象的優點

       1 ：提高程式碼複用性

       2 ：強制子類實現父類中沒有實現的功能

       3 ：提高程式碼的擴充套件性，便於後期的程式碼維護

8 ：抽象類不能建立物件，那麼抽象類中是否有建構函式？

抽象類中一定有建構函式。主要為了初始化抽象類中的屬性。通常由子類實現。

9 ： final 和 abstract 是否可以同時修飾一個類？

        一定不能同時修飾。

abstract class Animal {

    String name;

    // 抽象類可以有建構函式

    Animal() {

    }

    Animal(String name) {

        this.name = name;

    }

    abstract void shout();

}

class Dog extends Animal {

    Dog() {

    }

    Dog(String name) {

        super(name);

    }

    void shout() {

        System.out.println(" 旺旺 ");

    }

}

class Demo3 {

    public static void main(String[] args) {

        // 抽象類不能建立物件

        // Animal a=new Animal();

        Dog d = new Dog(" 旺財 ");

       System.out.println();

    }

}

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/69946279/viewspace-2657918/，如需轉載，請註明出處，否則將追究法律責任。