如何調用抽象類方法

Question

我有一個名為Hospital.java的界面

public interface Hospital {
    public void operate();
    public void doScan();
    public void doVaccination();
}

我有一個名為StreetHospital.java的抽象類

public abstract class StreetHospital implements Hospital{
    public void operate(){
        System.out.println("Street Hospital operate");
  }
}

現在我正在使用另一個類CommunityHospital.java來擴展StreetHospital.java

public class CommunityHospital extends StreetHospital{

    public void doScan(){
        System.out.println("CommunityHospital doScan");
    }
    public void doVaccination(){
        System.out.println("CommunityHospital doVaccination");
}
    public void operate(){
        System.out.println("CommunityHospital operate");
    }
}

我在MainHospital類中創建了CommunityHospital對象

public class MainHospital {

    public static void main(String[] args){
        CommunityHospital ch = new CommunityHospital();
        ch.operate();
        ch.doScan();
        ch.doVaccination();

    }
}

我得到這個輸出：

CommunityHospital operate
CommunityHospital doScan
CommunityHospital doVaccination

我的問題是如何在輸出中打印“街道醫院操作”sysout語句？

Answer 1

你不能這樣做。

在一個具有相同名稱和參數的類中不能有兩個方法。 一旦你在CommunityHospital中覆蓋了operations（），StreetHospital中的同一個方法就不再存在了。

Answer 2

您需要使用super關鍵字來調用子類中的超類成員，如下所示：

public class CommunityHospital extends StreetHospital{

    public void doScan(){
        System.out.println("CommunityHospital doScan");
    }
    public void doVaccination(){
        System.out.println("CommunityHospital doVaccination");
    }
    public void operate(){
        super.operate();//call super class operate to get StreetHospital features
        //If you want, you can add CommunityHospital features here
    }
}

我建議你在這里查看更多細節並理解這個概念。

如果您的方法覆蓋了其超類的方法之一，則可以通過使用關鍵字super來調用重寫方法。

Answer 3

一種方法是從CommunityHospital類中刪除operate方法。

在設計方面，這意味着社區醫院的運營與街道醫院的運營沒有區別。

另一個考慮因素是你實際上想要街道醫院的運作，然后在社區醫院的運作中需要完成一些具體細節。 對於CommunityHospital operate功能應如下所示：

public void operate() {
        super.operate(); //Street hospital operate
        // Add community hospital operate details here
} 

Answer 4

您正在擴展一個類，但隨后會覆蓋它的方法。 因此，無論何時召喚operate它都將使用CommunityHospital那個被覆蓋的那個。 如果刪除它，它將從StreetHospital類中找到operate方法。

如果出於某種原因，您確實需要在CommunityHospital使用operate方法，請不要實現新方法，只需調用super.operate() 。 這將調用StreetHospital類的operate方法。

Answer 5

CommunityHospital覆蓋了操作方法，所以如果那個類沒有調用super那么就不可能......

修改類如：

 public void operate(){
        super.operate(); // call the method from super class

    }

Answer 6

向CommunityHospital添加另一個函數，另一個名稱是superOperate如下所示：

public void superOperate(){
    super.operate();
}

並從任何地方調用它

Answer 7

 public void operate(){
        super.operate(); // call the method from super class

    }

或者只是刪除

@Override
    public void operate() {
        System.out.println("CommunityHospital operate");
    }

形成社區醫院

Answer 8

如果你想以某種方式編寫StreetHospital ，以便子類可以覆蓋operate() ，但仍可以調用StreetHospital operate() （未覆蓋的），你可以這樣做：

public abstract class StreetHospital implements Hospital {
    public final void streetOperate() {
        System.out.println("Street Hospital operate");
    }
    public void operate() {
        streetOperate();
    }
}

現在operate()可以被重寫，但streetOperate()仍然可以在任何所謂CommunityHospital對象，或任何其他子類StreetHospital 。

但是，我真的很難想到一個實際情況，這將是一個很好的設計。

Answer 9

你可以用super來做到這一點

class CommunityHospital extends StreetHospital{
    // same code
    public void operate(){
        super.operate(); //-> this line
        //System.out.println("CommunityHospital operate");
    }
}

如果您不想允許覆蓋它，也可以使operate方法final 。

abstract class StreetHospital implements Hospital{
    final public void operate(){
        System.out.println("Street Hospital operate");
    }
}

Answer 10

只要您不覆蓋操作方法，當您擴展它時，它將在您的類中可用。

因此，在擴展它時，不要覆蓋類中的操作方法。

public class CommunityHospital extends StreetHospital {
   public class CommunityHospital extends StreetHospital {

    public void doScan() {
        System.out.println("CommunityHospital doScan");
    }

    public void doVaccination() {
        System.out.println("CommunityHospital doVaccination");
    }
}

這應該工作。

Answer 11

不幸的是，除了在子類中調用super.operate之外super.operate他法。

在java中向上轉換不起作用。 顯示它的演示：

package com.stackoverflow.main;

class A {
    void operate() {
        System.out.println("A");
    }
}

class B extends A {
    void operate() {
        System.out.println("B");
    }
}

public class Main {

    public static void main(String[] args) {
        A b = new B();
        ((A) b).operate();
    }
}

打印：

B

Answer 12

使用向下鑄造的概念。 我用C＃編寫了代碼

abstract class MyClass1 {
    public void operate() {
        System.Console.WriteLine("base class");
    }
    public abstract void operate1();
    public virtual void operate2() {
        System.Console.WriteLine("Virtual");
    }
}

class myclass2 : MyClass1 {
    public override void operate1() {
        Console.WriteLine("Success");
    }
    public override void operate2() {
        Console.WriteLine("overidden");
    }
    public new void operate() {
        Console.WriteLine("!base class");
    }
}

class program {
    static void Main(string[] args) {
        MyClass1 m = new myclass2();
        m.operate();
    }
}