c# - 如何在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)ch).sleep();

---

正如@Thorsten在下面评论的那样，这是有效的，因为Parent.sleep它是一种非虚拟方法，并且在类中没有被覆盖。Child如果它被覆盖，那么您将无法Parent.sleep使用ch. （对于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

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

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

您可以像这样在 Child 上创建一个名为 ParentSleep 的新方法：

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

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

然后像这样调用它：

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