C# 继承

C# 继承

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了 属于（IS-A） 关系。例如，哺乳动物 属于（IS-A） 动物，狗 属于（IS-A） 哺乳动物，因此狗 属于（IS-A） 动物。

基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数。

C# 中创建派生类的语法如下：

<访问修饰符符> class <基类>
{
 ...
}
class <派生类> : <基类>
{
 ...
}

假设，有一个基类 Shape，它的派生类是 Rectangle：

using System;
namespace InheritanceApplication
{
   class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 派生类
   class Rectangle: Shape
   {
      public int getArea()
      {
         return (width * height);
      }
   }
   
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // 打印对象的面积
         Console.WriteLine("总面积： {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

总面积： 35

基类的初始化

派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。您可以在成员初始化列表中进行父类的初始化。

下面的程序演示了这点：

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度： {0}", length);
         Console.WriteLine("宽度： {0}", width);
         Console.WriteLine("面积： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

长度： 4.5
宽度： 7.5
面积： 33.75
成本： 2362.5

C# 多重继承

多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。

C# 不支持多重继承。但是，您可以使用接口来实现多重继承。下面的程序演示了这点：

using System;
namespace InheritanceApplication
{
   class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 基类 PaintCost
   public interface PaintCost
   {
      int getCost(int area);

   }
   // 派生类
   class Rectangle : Shape, PaintCost
   {
      public int getArea()
      {
         return (width * height);
      }
      public int getCost(int area)
      {
         return area * 70;
      }
   }
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();
         int area;
         Rect.setWidth(5);
         Rect.setHeight(7);
         area = Rect.getArea();
         // 打印对象的面积
         Console.WriteLine("总面积： {0}",  Rect.getArea());
         Console.WriteLine("油漆总成本： ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

总面积： 35
油漆总成本： $2450

笔记

1.创建子类对象调用子类的构造函数时，会首先调用父类的无参构造函数。

using System;

namespace ConsoleApp1
{
    class Program
    {
        class father
        {
            public father()
            {
                Console.WriteLine("father");
            }
        }
        class son : father
        {
            public son()
            {
                Console.WriteLine("son");
            }
        }
        static void Main(string[] args)
        {
            son s = new son();
            Console.ReadKey();
        }
    }
}

输出结果：

father
son

2.关于继承的几点：

• 1、继承的语法：class 子类类名 : class 父类类名{ //子类类体 }
• 2、继承的特点：子类拥有所有父类中所有的字段、属性和方法
• 3、一个类可以有多个子类，但是父类只能有一个
• 4、一个类在继承另一个类的同时，还可以被其他类继承
• 5、在 C# 中，所有的类都直接或者间接的继承自 Object 类

前面的几点都说得差不多了，说说第 5 点:

class Hardware  //类Hardware是父类
{
    public string name;
    public double price;

}
class CPU : Hardware  //类CPU是子类
{
    public string kind;
}
class MainBoard : CPU  //第4点 类CPU是MainBoard的父类
{

}
class Display
{


}
class Program
{
    static void Main(string[] args)
    {
        CPU c = new CPU();
        c.name = "";
        c.price = 1;
        c.ToString();  //可以发现无论是父类还是子类中都没有ToString这个方法的  
    }
}
在程序的任何地方输入 Object 后，鼠标放上去后右键，找到转到定义后点击或者直接按 F12，就可以看到以下代码：

public class Object
{
    //
    // 摘要:
    //     初始化 System.Object 类的新实例。
    [NonVersionableAttribute]
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
    public Object();

    //
    // 摘要:
    //     在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。
    [NonVersionableAttribute]
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
    ~Object();

    //
    // 摘要:
    //     确定指定的对象实例是否被视为相等。
    //
    // 参数:
    //   objA:
    //     要比较的第一个对象。
    //
    //   objB:
    //     要比较的第二个对象。
    //
    // 返回结果:
    //     如果对象被视为相等，则为 true，否则为 false。 如果 objA 和 objB 均为 null，此方法将返回 true。
    public static bool Equals(Object objA, Object objB);
    //
    // 摘要:
    //     确定指定的 System.Object 实例是否是相同的实例。
    //
    // 参数:
    //   objA:
    //     要比较的第一个对象。
    //
    //   objB:
    //     要比较的第二个对象。
    //
    // 返回结果:
    //     true如果objA是相同的实例作为objB或如果两者均null; 否则为false。
    [NonVersionableAttribute]
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
    public static bool ReferenceEquals(Object objA, Object objB);
    //
    // 摘要:
    //     确定指定的对象是否等于当前对象。
    //
    // 参数:
    //   obj:
    //     要与当前对象进行比较的对象。
    //
    // 返回结果:
    //     如果指定的对象等于当前对象，则为 true，否则为 false。
    public virtual bool Equals(Object obj);
    //
    // 摘要:
    //     作为默认哈希函数。
    //
    // 返回结果:
    //     当前对象的哈希代码。
    public virtual int GetHashCode();
    //
    // 摘要:
    //     获取当前实例的 System.Type。
    //
    // 返回结果:
    //     当前实例的准确运行时类型。
    [SecuritySafeCritical]
    public Type GetType();
    //
    // 摘要:
    //     返回表示当前对象的字符串。
    //
    // 返回结果:
    //     表示当前对象的字符串。
    public virtual string ToString();
    //
    // 摘要:
    //     创建当前 System.Object 的浅表副本。
    //
    // 返回结果:
    //     当前 System.Object 的浅表副本。
    [SecuritySafeCritical]
    protected Object MemberwiseClone();
}

本人也是在学习中，如果有什么错误欢迎指正。