如何调用抽象类方法

问题描述 投票：0回答：12

我有一个名为 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

我的问题是如何在输出中打印“Street Hospital Operate”sysout 语句？

java class inheritance abstract
12个回答
5
投票

你不能那样做。

一个类中不能有两个具有相同名称和参数的方法。一旦您在 CommunityHospital 中重写了操作()，StreetHospital 中的相同方法就不再存在。

2
投票

向 

CommunityHospital
添加另一个函数，并命名为 
superOperate
，如下所示：

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

并从任何地方调用它

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 来调用重写的方法。

1
投票

一种方法是从 

operate
类中删除 
CommunityHospital
方法。

就设计而言，这意味着社区医院的运作与街道医院的运作没有什么不同。

另一个考虑因素是您确实想要街道医院的运营，然后社区医院的运营需要完成一些细节。对于 

CommunityHospital
operate
函数应该如下所示：

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

您正在扩展一个类，但随后覆盖它的方法。因此，每当您调用 

operate
时，它都会使用 
CommunityHospital
中被覆盖的那个。如果删除它，它将从 
operate
类中找到 
StreetHospital
方法。

如果由于某种原因您确实需要 

operate
中的 
CommunityHospital
方法，请不要实现新方法，只需调用 
super.operate()
即可。这将调用 
StreetHospital
类的 
operate
方法。

1
投票

CommunityHospital 重写了操作方法，因此如果该类不调用 super 则不可能...

修改类：

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

    }
1
投票

如果你想以某种方式编写

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
的任何其他子类上调用。

但是，我真的很难想象一个实际案例，这将是一个好的设计。

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

    }

或者直接删除 

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

组建社区医院

0
投票

您可以使用 

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");
    }
}
0
投票

不幸的是，除了在子类中调用

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
0
投票

只要你不重写操作方法，当你扩展它时，它就可以在你的类中使用。

因此，在扩展类时不要重写类中的操作方法。

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

这应该有效。

-3
投票

使用向下铸造的概念。 我已经用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();
    }
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.