如何在C＃中使用子类的实例访问父类的方法

Question

我有这个代码

class parent 
{
  public void sleep()
   {
     // Some Logic
   }
}

class Child : Parent
{
  public void sleep()
  {
    // some logic
  }
}

class Implement
{
  Child ch = new Child();
  ch.sleep();
}

但是现在我想通过使用已经创建的子类实例来访问父类的sleep（）方法。

Answer 1

您可以将对象转换为父类型。

Child ch = new Child();
var parent = (Parent)ch;
parent.sleep();

Answer 2

您只需要将创建的Child对象Parent为Parent ：

((Parent)ch).sleep();

---

就像@Thorsten在下面评论的那样，这是有效的，因为Parent.sleep是一个非虚拟方法，并且在Child类中没有被重写 。 如果重写了它，那么您将Parent.sleep使用ch调用Parent.sleep实现。 （对于virtual方法，调用的方法是“最派生的实现”，也就是使用override关键字在类层次结构中此方法的最派生的实现。）

Answer 3

要访问父成员，必须强制转换对象。

public class A
{
   public virtual void One();
   public void Two();
}

public class B : A
{
   public override void One();
   public new void Two();
}

B b = new B();
A a = b as A;

a.One(); // Calls implementation in B
a.Two(); // Calls implementation in A
b.One(); // Calls implementation in B
b.Two(); // Calls implementation in B

来源： 方法签名中的新关键字

建议：您正在隐藏继承的成员。 您应该使用“ new”关键字，如下所示：

    class Parent
    {
        public void MethodA()
        {
            Console.WriteLine("Parent");
        }
    }

    class Child : Parent
    {
        public new void MethodA()
        {
            Console.WriteLine("Child");
        }
    }

Answer 4

您可以在Child上创建一个名为ParentSleep的新方法，如下所示：

class Child : Parent
{
  public void sleep()
  {
    // some logic
  }

  public void ParentSleep()
  {
     base.sleep();
  }
}

然后这样称呼它：

Child ch = new Child();
ch.ParentSleep();

Answer 5

如果您想通过接口以及父类实现此功能，可以执行以下操作：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExplicitInterfaceImplementation
{
    class Program
    {
        static void Main(string[] args)
        {
            SampleClass sc = new SampleClass();
            var mc = (MainSampleClass)sc;
            IControl ctrl = (IControl)sc;
            ISurface srfc = (ISurface)sc;

            mc.Paint();
            sc.Paint();
            ctrl.Paint();
            srfc.Paint();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// Interface 1
    /// </summary>
    interface IControl
    {
        void Paint();
    }

    /// <summary>
    /// Interface 2
    /// </summary>
    interface ISurface
    {
        void Paint();
    }

    /// <summary>
    /// Parent/Main Class 
    /// </summary>
    public class MainSampleClass
    {
        /// <summary>
        /// Parent class Paint Method.
        /// </summary>
        public void Paint()
        {
            Console.WriteLine("Paint method in - Parent MainSampleClass");
        }
    }

    /// <summary>
    /// SampleClass is the Child class inherited from Parent/Main Class and two interfaces
    /// Parent/Main class having a Paint() method and two interfaces having 
    /// Paint() method - each of them having same name but they are not same(different from each other).
    /// </summary>
    public class SampleClass : MainSampleClass,IControl, ISurface
    {
        /// <summary>
        /// new method(Paint()) for Child class, separate from parent class(Paint() method)
        /// </summary>
        public new void Paint()
        {
            Console.WriteLine("Paint method in - Child SampleClass");
        }

        /// <summary>
        /// Implementing IControl.Paint() method.
        /// </summary>
        void IControl.Paint()
        {
            System.Console.WriteLine("Paint method in - IControl Interface");
        }

        /// <summary>
        /// Implementing ISurface.Paint() method. 
        /// </summary>
        void ISurface.Paint()
        {
            System.Console.WriteLine("Paint method in - ISurface Interface");
        }
    }
}

Answer 6

class Implement
{
    Parent parentChild = new Child();
    parentChild.sleep();
}