如何调用抽象类方法

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();
    }
}