java抽象類和抽象方法

1、什麼是抽象類和抽象方法

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

2、爲何須要抽象類和抽象方法

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

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

1. 抽象類抽象方法必須被abstract修飾。
2. 抽象類中能夠有普通方法，可是有抽象方法的類必須是抽象類。抽象類中的普通方法由於不能被建立對象，因此不能使用這個普通方法。
3. 抽象類除了不能實例化對象以外，類的其它功能依然存在。
4. 抽象方法中能夠有被static修飾main方法，而且能夠執行。
5. 一個類在繼承抽象類後，必須實現抽象類中定義的全部抽象方法。除非它本身也聲明爲抽象類。
6. 抽象方法名後面直接跟一個分號，而不是花括號。

 

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

　　一、抽象類中能夠有普通方法，可是有抽象方法的類必須是抽象類。

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

　

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

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

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

}

　　

　　三、抽象方法中能夠有被static修飾main方法，而且能夠執行。

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

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


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

　　四、抽象類的使用通常通繼承來實現，且子類中要麼對抽象類的方法進行重寫，要麼聲明子類也爲抽象類

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


abstract class Demo03 extends Demo01{

}

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

　　五、抽象類中的靜態方法能夠用類名.方法名的方式調用

 

 

 　　六、抽象的實例：

有抽象類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 類繼承 成員方法，且經過該方法能夠設置或獲取成員變量。

5、抽象類的其餘補充嗎

　　抽象類是否有構造器：

　　

 

 　　從圖中咱們能夠知道抽象類也是有構造器的，並別在子類建立對象時被調用。

　　

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


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


//抽象類的構造方法

　　二、final與abstract的矛盾

　　final關鍵字能夠修飾類、方法、變量。final修飾的類不能被派生；final修飾的方法，禁止子類重寫。因此咱們能夠看出，final和abstract不能一塊兒使用。

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