Question

我有一个名为Hospital.java的界面

Options +FollowSymlinks
RewriteEngine on
RewriteBase /

RewriteCond %{REQUEST_URI} [NC]
RewriteRule ^(.*)$ /$1?lang=EN [L]

我有一个名为StreetHospital.java的抽象类

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

现在我正在使用另一个类CommunityHospital.java来扩展StreetHospital.java

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

我正在MainHospital类中创建CommunityHospital对象

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

我收到了这个输出：

public class MainHospital {

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

    }
}

我的问题是如何打印＆＃34;街道医院运营＆＃34;输出中的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
    }
}

我建议您查看here了解更多详情并了解其概念。

如果你的方法覆盖了它的一个超类的方法，你可以通过使用关键字 super 。
来调用重写的方法

Answer 3

一种方法是从operate类中删除CommunityHospital方法。

在设计方面，这意味着社区医院的运作与街道医院的运作没有区别。

另一个考虑因素是你实际上想要街道医院的运作，然后在社区医院的运作中需要完成一些具体细节。对于CommunityHospital operate函数应该如下所示：

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

Answer 4

您正在扩展一个类，但随后会覆盖其方法。因此，无论何时拨打operate，都会使用CommunityHospital中覆盖的operate。如果删除它，它会从StreetHospital类中找到operate方法。

如果出于某种原因，您需要在CommunityHospital中使用super.operate()方法，请不要实施新方法，只需拨打StreetHospital即可。这将调用operate类“{{1}}方法。

Answer 5

社区医院会覆盖操作方法，因此如果该类没有调用超级，那么就不可能......

修改类如：

p-column

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＆＃39; s 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的任何其他子类上调用obj.pos = [700, 700, 0]。

但是，我真的很难想到一个实际情况，这将是一个很好的设计。

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之外别无他法。

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

打印：

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

如何调用抽象类方法

12 个答案: