java抽象類和抽象方法

一、什么是抽象類和抽象方法

　　沒有具體功能的實現，通過子類繼承后重寫方法來實現一定約束的類稱之為抽象類，抽象類必須被abstract修飾。抽象方法就是只有方法聲明，沒有方法體的方法。抽象類的使用一般通過繼承來實現

二、為什么需要抽象類和抽象方法

　　引用抽象方法和抽象類，是java提供的一種語法工具，引導使用者正確的使用它們，減少誤用。相當於對子類進行一定限制。

三、抽象類和抽象方法的語法規則及其注意事項

1. 抽象類抽象方法必須被abstract修飾。
2. 抽象類中可以有普通方法，但是有抽象方法的類必須是抽象類。抽象類中的普通方法因為不能被創建對象，所以不能使用這個普通方法。
3. 抽象類除了不能實例化對象之外，類的其它功能依然存在。
4. 抽象方法中可以有被static修飾main方法，並且可以執行。
5. 一個類在繼承抽象類后，必須實現抽象類中定義的所有抽象方法。除非它自己也聲明為抽象類。
6. 抽象方法名后面直接跟一個分號，而不是花括號。

 

四、抽象類和抽象方法的實現案例

　　1、抽象類中可以有普通方法，但是有抽象方法的類必須是抽象類。

public abstract class Demo01 {
    public abstract void run();
    public void test(){}
}
//編譯通過，不報錯

public  class Demo01 {
    public abstract void run();
    public void test(){}
}
//報錯：
Class 'Demo01' must either be declared abstract or implement abstract method 'run()' in 'Demo01'
Abstract method in non-abstract class

　

　　2、抽象類除了不能實例化對象

public abstract class Demo01 {
    public abstract void run();

    public static void main(String[] args) {
        Demo01 demo01=new Demo01();
    }

}

　　

　　3、抽象方法中可以有被static修飾main方法，並且可以執行。

public abstract class Demo01 {
    public abstract void run();

    public static void main(String[] args) {
        System.out.println("抽象類中的main方法");
    }
}


//輸出結果：抽象類中的main方法

　　4、抽象類的使用一般通繼承來實現，且子類中要么對抽象類的方法進行重寫，要么聲明子類也為抽象類

public class Demo02 extends Demo01{
    @Override
    public void run() {
        
    }
}


abstract class Demo03 extends Demo01{

}

//Demo02和Demo3均能編譯通過。

　　5、抽象類中的靜態方法可以用類名.方法名的方式調用

 

 

 　　6、抽象的實例：

有抽象類Father，和抽象方法run（）。

public abstract class Father {
    private String name;
    private int age;
    private char sex='男';
    public int money=100_000;
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    abstract void run();

    public void say(){
        System.out.println("這是父類普通方法");
    }

    public static void go(){
        System.out.println("這是父類靜態方法");
    }

}

　　有子類Son繼承了抽象類，重寫了父類的抽象方法run

public class Son extends Father{
    private double salary;

    @Override
    void run() {
        System.out.println("子類重寫了父類的方法run");
        System.out.println(super.getSex());
        super.say();
    }

    public static void main(String[] args) {
       Son son=new Son();
       son.run();
       System.out.println(son.getSex());
       //System.out.println(super.getSex());  //錯誤
       son.setAge(47);
       System.out.println(son.getAge());
       son.setName("ThreePure");
       System.out.println(son.getName());
       //調用父類的公有屬性
       System.out.println(son.money);
       //使用繼承於父類的方法
       son.say();
    }
}

運行結果：

子類重寫了父類的方法run
男
這是父類普通方法
男
47
ThreePure
100000
這是父類普通方法

　　盡管我們不能實例化一個 Father類的對象，但是如果我們實例化一個 Son 類對象，該對象將從 Father 類繼承 成員方法，且通過該方法可以設置或獲取成員變量。

五、抽象類的其他補充嗎

　　抽象類是否有構造器：

　　

 

 　　從圖中我們可以知道抽象類也是有構造器的，並別在子類創建對象時被調用。

　　

public abstract class Demo3 {
    public Demo3() {
        System.out.println("抽象類的構造方法");
    }
}


public class Demo4 extends Demo3{
    public static void main(String[] args) {
        Demo4 demo4 =new Demo4();
    }
}


//抽象類的構造方法

　　2、final與abstract的矛盾

　　final關鍵字可以修飾類、方法、變量。final修飾的類不能被派生；final修飾的方法，禁止子類重寫。所以我們可以看出，final和abstract不能一起使用。

　　3、構造方法，類方法（用 static 修飾的方法）不能聲明為抽象方法。