是否可以在派生类或任何其他类中调用抽象类的方法

Question

是否可以在派生类或任何其他类中调用抽象类的方法。我的代码如下，我想在Program的Main方法中调用Abstr的Describe()方法。 是否可以？如果答案是肯定的怎么办？

class Program
{
    public void Main()
    {
        //I want to call the Describe() method here, how do i do that
        Console.ReadLine();
    }
}

public abstract class Abstr
{
    public void Describe()
    {
        //do something
    }
}

Answer 1

由于您的方法不是静态的，因此您需要从该抽象类初始化一个变量并从中调用该方法。为此，您可以通过 concreate 类继承抽象类，然后调用该方法。请注意，抽象类无法初始化，抛出像 Abstr Abstr = new Abstr(); 这样的构造函数是无效的。所以：

public abstract class Abstr
{
    public void Describe()
    {
        //do something
    }
}

public class Concrete : Abstr
{
   /*Some other methods and properties..*/ 
}

class Program
{
    public void Main()
    {
        Abstr abstr = new Concrete();
        abstr.Describe();
        Console.ReadLine();
    }
}

Answer 2

您应该能够直接使用 Abstr.Describe()。它是一个静态方法，因此抽象类并不重要。

编辑

现在问题中的代码已被编辑，并且方法上的 static 关键字已被删除，该答案不再适用。

Answer 3

问：是否可以在派生类中调用抽象类的方法
类？

答：当然可以，只要它是公共的、受保护的（和同一个类或子类）或内部的（和同一个程序集）

问：还有其他课程吗？

答：当然，只要它是公共的或内部的（以及相同的程序集）

良好的链接：
http://agsmith.wordpress.com/2007/12/15/内部和保护/

Answer 4

是的，可以使用代码：此处

这也适用于非静态方法

Answer 5

致电编辑就足够了

：

原始帖子已更改，因此该答案无效。

 Abstr.Describe();

问候。

Answer 6

是的，只要子类型（以及想要调用该方法的代码）可以访问超类型中的方法定义。

这是一些示例代码。是否调用子类型或超类型中的方法定义取决于重写的定义方式：

public abstract class AbstractSupertype
{
  public void Alpha()
  {
    Console.WriteLine( "AbstractSupertype.Alpha()" ) ;
    return ;
  }
  public abstract void Bravo() ;
  public virtual  void Charlie()
  {
    Console.WriteLine( "AbstractSupertype.Charlie()" ) ;
    return ;
  }
}

public class ConcreteSubtype : AbstractSupertype
{
  public new void Alpha()
  {
    Console.WriteLine( "ConcreteSubtype.Alpha()" ) ;
  }
  public override void Bravo()
  {
    Console.WriteLine( "ConcreteSubtype.Bravo()" ) ;
  }
  public override void Charlie()
  {
    Console.WriteLine( "ConcreteSubtype.Charlie()" ) ;
  }
}
class Program
{
  static void Main( string[] args )
  {
    ConcreteSubtype   subTypeInstanceReference   = new ConcreteSubtype() ;
    AbstractSupertype superTypeInstanceReference = subTypeInstanceReference ;

    subTypeInstanceReference.Alpha()     ; // invokes subtype's method
    superTypeInstanceReference.Alpha()   ; // invokes supertype's method

    subTypeInstanceReference.Bravo()     ; // invokes subtype's method
    superTypeInstanceReference.Bravo()   ; // invokes subtype's method

    subTypeInstanceReference.Charlie()   ; // invokes subtype's method
    superTypeInstanceReference.Charlie() ; // invokes subtype's method

    return ;
  }
}