• 2021-12-19 09:29:04

C#多重继承（多层次继承）

using System;

/// <summary>
/// C#多重继承
/// </summary>
namespace MultipleInheritance
{
//线
class Line
{
protected int length;
public Line(int l = 0)
{
length = l;
}
public int area()
{
return length;
}
}
//方形
class Rectangle : Line
{
protected int width;
public Rectangle(int l = 0, int w = 0) : base(l) {
width = w;
}
public new int area()
{
return width * length;
}
}
//方体
class Cube : Rectangle
{
private int height;
public Cube(int l = 0, int w = 0, int h = 0) : base(l, w) {
height = h;
}
public new int area()
{
return width * length * height;
}
}
class RectangleTester
{
static void Main(string[] args)
{
Cube r = new Cube(10, 20, 30);
Console.WriteLine("Line类（线）-长度：{0}", ((Line)r).area());
Console.WriteLine("Rectangle类（方形）-面积：{0}", ((Rectangle)r).area());
Console.WriteLine("Cube类（方体）-体积：{0}", r.area());
}
}
}

C#多继承（多父类继承）

using System;

/// <summary>
/// C#多继承
/// </summary>
namespace MultipleInheritance
{
//线
class Line
{
protected int length;
public Line(int l = 0)
{
length = l;
}
public int area()
{
return length;
}
}
//翻倍
interface Double
{
int area2(int n);
}
//方形
class Rectangle : Line, Double
{
protected int width;
public Rectangle(int l = 0, int w = 0) : base(l) {
width = w;
}
public new int area()
{
return width * length;
}
public int area2(int n)
{
return area() * n;
}
}
//方体
class Cube : Rectangle, Double
{
private int height;
public Cube(int l = 0, int w = 0, int h = 0) : base(l, w) {
height = h;
}
public new int area()
{
return width * length * height;
}
public new int area2(int n)
{
return area() * n;
}
}

class RectangleTester
{
static void Main(string[] args)
{
Cube r = new Cube(1, 2, 3);
Console.WriteLine("Line类（线）-长度：{0}", ((Line)r).area());
Console.WriteLine("Rectangle类（方形）-面积：{0}", ((Rectangle)r).area());
Console.WriteLine("Cube类（方体）-体积：{0}", r.area());
Console.WriteLine();
/*
Console.WriteLine("Rectangle类（方形）-面积翻2倍：{0}", ((Rectangle)r).area2(2));
Console.WriteLine("Cube类（方体）-体积翻3倍：{0}", r.area2(3));
Console.WriteLine();
*/
Double r2 = new Cube(1, 2, 3);
Console.WriteLine("Rectangle类（方形）-面积翻2倍：{0}", ((Rectangle)r2).area2(2));
Console.WriteLine("Cube类（方体）-体积翻3倍：{0}", r2.area2(3));
}
}
}


更多相关内容
• 其实想写这篇文章,是因为突然在整理论坛上的帖子的时候,突然发现一个人问我如何才能在C#中实现多重继承,当时我答的很隐晦,因此这里我想补充说明一下. 首先,我要说明一下,C#中是没有类的多重继承这个概念.要使用...

其实想写这篇文章,是因为突然在整理论坛上的帖子的时候,突然发现一个人问我如何才能在C#中实现多重继承,当时我答的很隐晦,因此这里我想补充说明一下.

首先,我要说明一下,C#中是没有类的多重继承这个概念.要使用多重继承必须要通过接口Interface来完成.可是大家都知道Interface实际上就是一个虚函数列表指针.内部封装的只有函数和属性.而且接口(Interface)不能实力化只能通过派生(因为没有构造函数)才可以使用.这一点和抽象类很类似,可是抽象类是个类,他有方法的实现.它所描述的对象是一个无法在现实中具现的对象,但它本身是个类对象.而接口实际上是一种标准.说了这么多,下面我来举一个例子如何在C#中实现多重继承.

myBase.cs

 using  System; using  System.Collections.Generic; using  System.Linq; using  System.Text;   namespace  Intdv {      public  abstract  class  myBase      {          public  myBase()          {              //              // To do something here              //          }      } }

myDerive1.cs

 using  System; using  System.Collections.Generic; using  System.Linq; using  System.Text;   namespace  Intdv {      class  myDerive1 : Intdv.myBase      {          string  myName;            public  myDerive1()          {              //              // To do something here              //                myName =  "yarshary" ;          }            public  void  ShowMyName()          {              Console.WriteLine( "my name is: "  +  this .myName);          }            public  void  reName( string  n)          {              myName = n;          }         }        public  interface  ImyDerive1      {          void  ShowMyName();          void  reName( string  n);      } }

myDerive2.cs

 using  System; using  System.Collections.Generic; using  System.Linq; using  System.Text;   namespace  Intdv {      public  class  myDerive2:Intdv.myBase      {          int  MyAge;            public  myDerive2()          {              //              // To do something here              //                MyAge = 21;          }            public  void  ShowMyAge()          {              Console.WriteLine( "my age is:"  + MyAge);          }            public  void  reAge( int  a)          {              this .MyAge = a;          }        }        public  interface  ImyDerive2      {          void  ShowMyAge();            void  reAge( int  a);      } }

myMDerive.cs

 using  System; using  System.Collections.Generic; using  System.Linq; using  System.Text;   namespace  Intdv {      public  sealed  class  myMDerive:Intdv.myBase, Intdv.ImyDerive1, Intdv.ImyDerive2      {          Intdv.myDerive1 d1;          Intdv.myDerive2 d2;            public  myMDerive()          {              //              // To do something here              //                d1 =  new  myDerive1();              d2 =  new  myDerive2();          }            public  void  ShowMyName()          {              d1.ShowMyName();          }            public  void  reName( string  n)          {              d1.reName(n);          }              public  void  ShowMyAge()          {              d2.ShowMyAge();          }            public  void  reAge( int  a)          {              d2.reAge(a);          }      } }

事例分析,首先我上在一开始定义了一个基类myBase,并派生出了两个派生类分别为myDerive1,myDerive2
这两个类分别定义了一组操作,myDerive1中定义了操作ShowMyName 和 reName 并通过接ImyDerive1加以
描述. myDerive2中定义了操作ShowMyAge 和 reAge 并通过接口ImyDerive2来描述,这样我在多重继承中
只用继承接口也就是ImyDerive1和ImyDerive2就可以保证操作列表的继承,操作的实现通过组合模型.在
接口方法中体现.这里还是从代码来说明,我的派生对象myMDerive(M即多从继承之意),虽然只继承了接口,
可是在构造函数中,却动态分配(New)了myDerive1 和 myDerive2 两个对象.并在操作ShowMyName 等接口继承来的操作中实际调用了myDerive1 和 myDerive2 的操作.由于myDerive1 和 myDerive2 是在
myMDerive内定义的,所以客户端代码(也就是我的主函数)并不需要管理对象的分配和释放(当然在CLR托管
环境中对象的释放一般也并非人为).

由以上例子,可以看出,实现借口留出函数接口具体实现通过组合的方式来实现多重继承中方法体的实现.这样既保证了单一继承父类的唯一性,又保证了多重继承的优点.我个人认为是个很不错的设计方法,并且在我的程序设计中很多地方都采用了该方法.那么好了,就到这里了.

展开全文
• 其实想写这篇文章,是因为突然在整理论坛上的帖子的时候,突然发现一个人问我如何才能在C#中实现多重继承,当时我答的很隐晦,因此这里我想补充说明一下. 首先,我要说明一下,C#中是没有类的多重继承这个概念.要使用...
myBase.cs

?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespaceIntdv
{
publicabstract classmyBase
{
publicmyBase()
{
//
// To do something here
//
}
}
}

myDerive1.cs

?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespaceIntdv
{
classmyDerive1 : Intdv.myBase
{
stringmyName;
publicmyDerive1()
{
//
// To do something here
//
myName ="yarshary";
}
publicvoid ShowMyName()
{
Console.WriteLine("my name is: "+ this.myName);
}
publicvoid reName(stringn)
{
myName = n;
}
}
publicinterface ImyDerive1
{
voidShowMyName();
voidreName(stringn);
}
}

myDerive2.cs

?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespaceIntdv
{
publicclass myDerive2:Intdv.myBase
{
intMyAge;
publicmyDerive2()
{
//
// To do something here
//
MyAge = 21;
}
publicvoid ShowMyAge()
{
Console.WriteLine("my age is:"+ MyAge);
}
publicvoid reAge(inta)
{
this.MyAge = a;
}
}
publicinterface ImyDerive2
{
voidShowMyAge();
voidreAge(int a);
}
}

myMDerive.cs

?
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespaceIntdv
{
publicsealed classmyMDerive:Intdv.myBase, Intdv.ImyDerive1, Intdv.ImyDerive2
{
Intdv.myDerive1 d1;
Intdv.myDerive2 d2;
publicmyMDerive()
{
//
// To do something here
//
d1 =new myDerive1();
d2 =new myDerive2();
}
publicvoid ShowMyName()
{
d1.ShowMyName();
}
publicvoid reName(stringn)
{
d1.reName(n);
}
publicvoid ShowMyAge()
{
d2.ShowMyAge();
}
publicvoid reAge(inta)
{
d2.reAge(a);
}
}
}


其实想写这篇文章,是因为突然在整理论坛上的帖子的时候,突然发现一个人问我如何才能在C#中实现多重继承,当时我答的很隐晦,因此这里我想补充说明一下.

首先,我要说明一下,C#中是没有类的多重继承这个概念.要使用多重继承必须要通过接口Interface来完成.可是大家都知道Interface实际上就是一个虚函数列表指针.内部封装的只有函数和属性.而且接口(Interface)不能实力化只能通过派生(因为没有构造函数)才可以使用.这一点和抽象类很类似,可是抽象类是个类,他有方法的实现.它所描述的对象是一个无法在现实中具现的对象,但它本身是个类对象.而接口实际上是一种标准.说了这么多,下面我来举一个例子如何在C#中实现多重继承.

myBase.cs

 using  System;  using  System.Collections.Generic;  using  System.Linq;  using  System.Text;  namespace Intdv {  public abstract class myBase  { public myBase() { // // To do something here // } } }

myDerive1.cs

 using  System;  using  System.Collections.Generic;  using  System.Linq;  using  System.Text;  namespace Intdv {  class myDerive1 : Intdv.myBase { string myName; public myDerive1() { // // To do something here // myName = "yarshary" ; } public void ShowMyName()  { Console.WriteLine( "my name is: " + this .myName); } public void reName( string n) { myName = n; } } public interface ImyDerive1 { void ShowMyName(); void reName( string n); } }

myDerive2.cs

 using  System;  using  System.Collections.Generic;  using  System.Linq;  using  System.Text;  namespace Intdv {  public class myDerive2:Intdv.myBase { int MyAge; public myDerive2() { // // To do something here // MyAge = 21; } public void ShowMyAge()  { Console.WriteLine( "my age is:" + MyAge); } public void reAge( int a) { this .MyAge = a; } } public interface ImyDerive2 { void ShowMyAge(); void reAge( int a);  } }

myMDerive.cs

 using  System;  using  System.Collections.Generic;  using  System.Linq;  using  System.Text;  namespace Intdv {  public sealed class myMDerive:Intdv.myBase, Intdv.ImyDerive1, Intdv.ImyDerive2 { Intdv.myDerive1 d1; Intdv.myDerive2 d2; public myMDerive() { // // To do something here // d1 = new myDerive1(); d2 = new myDerive2(); } public void ShowMyName()  { d1.ShowMyName(); } public void reName( string n) { d1.reName(n); } public void ShowMyAge()  { d2.ShowMyAge(); } public void reAge( int a) { d2.reAge(a); } } }

事例分析,首先我上在一开始定义了一个基类myBase,并派生出了两个派生类分别为myDerive1,myDerive2
这两个类分别定义了一组操作,myDerive1中定义了操作ShowMyName 和 reName 并通过接ImyDerive1加以
描述. myDerive2中定义了操作ShowMyAge 和 reAge 并通过接口ImyDerive2来描述,这样我在多重继承中
只用继承接口也就是ImyDerive1和ImyDerive2就可以保证操作列表的继承,操作的实现通过组合模型.在
接口方法中体现.这里还是从代码来说明,我的派生对象myMDerive(M即多从继承之意),虽然只继承了接口,
可是在构造函数中,却动态分配(New)了myDerive1 和 myDerive2 两个对象.并在操作ShowMyName 等接口继承来的操作中实际调用了myDerive1 和 myDerive2 的操作.由于myDerive1 和 myDerive2 是在
myMDerive内定义的,所以客户端代码(也就是我的主函数)并不需要管理对象的分配和释放(当然在CLR托管
环境中对象的释放一般也并非人为).

由以上例子,可以看出,实现借口留出函数接口具体实现通过组合的方式来实现多重继承中方法体的实现.这样既保证了单一继承父类的唯一性,又保证了多重继承的优点.我个人认为是个很不错的设计方法,并且在我的程序设计中很多地方都采用了该方法.那么好了,就到这里了.

展开全文
• 1、c#类的继承 在现有类(基类、父类)上建立新类(派生类、子类)的处理过程称为继承。派生类能自动获得基类的除了构造函数和析构函数以外的所有成员，可以在派生类中添加新的属性和方法扩展其功能。继承的特性: 可...

# c#类

## 1、c#类的继承

在现有类(基类、父类)上建立新类(派生类、子类)的处理过程称为继承。派生类能自动获得基类的除了构造函数和析构函数以外的所有成员，可以在派生类中添加新的属性和方法扩展其功能。继承的特性: 可传递性:C从B派生，B从A派生，那么C不仅继承B也继承A。 单一性:只能从一个基类中继承，不能同时继承多个基类继承中的访问修饰符base和this关键字基类的构造函数和析构函数不能被继承的。但可以使用关键字base来继承基类的构造函数。 C#中的base关键字代表基类，使用base关键字可以调用基类的构造函数、属性和方法。

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

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

总面积：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();
}
}
}

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

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

## 2、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

转载于:https://www.cnblogs.com/wys000/p/9585893.html

展开全文
• C#中是没有类的多重继承这个概念，要使用多重继承必须要通过接口Interface来完成 可是大家都知道Interface实际上就是一个虚函数列表指针.内部封装的只有函数和属性.而且接口(Interface)不能实力化只能通过派生(因为...
• namespace 多层继承问题 { class Program { static void Main(string[] args) { SuperSubDerivedClass superSubDerivedClass = new SuperSubDerivedClass(); SubDerivedClass subDerivedClass = ...
• 其实想写这篇文章,是因为突然在整理论坛上的帖子的时候,突然发现一个人问我如何才能在C#中实现多重继承,当时我答的很隐晦,因此这里我想补充说明一下. 首先,我要说明一下,C#中是没有类的多重继承这个概念.要使用多重...
• a. 类之间不支持，接口之间支持 b.类对接口叫做实现，不叫继承
• C#支持多重继承么？ a. 类之间不支持，接口之间支持 b. 类对接口叫做实现，不叫继承
• 接口是啥? 简单来说就是一种约定，也是C#里面非常重要的. 我们知道在C#中一个派生类(子类...4.接口可以帮助实现多重继承 5.接口里的内容必须实现 6.接口没有字段 可以有方法、属性等 7.接口是公共的(public) 8.abs
• 1. 多重继承：A继承B，C继承A 2. 多继承：A继承B，C，D等等 class A:public B,public C{ } 参见项目：MultipleInheritance 转载于:https://www.cnblogs.com/pjishu/p/9261031.html...
• OOP三特性：继承、封装、多态继承C#属于单继承，即派生类最多只能有一个直接基类，但可以传递继承，即A类派生B类，B类派生C类，派生类会保留所有基类以及传递基类的字段、属性、方法等所有内容。如果要在派生类中...
• 接口使用的注意事项： 接口方法不能用public abstract等修饰。接口内不能有字段变量，构造函数。 接口内可以定义属性（有get和set的方法）。如string color { get ;...实现接口时，必须和接口的格式一致。...
• a.类之间不支持，接口之间支持 b.类对接口叫做实现，不叫继承
• } } } C# 多重继承 多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。 C# 不支持多重继承。但是，您可以使用接口来实现多重继承。...
• 我们知道C++中类可以多重继承,这也符合现实情况,比如某个绿帽高戴的男同志身边的某位美女可能同时具备几个身份,老婆,小三,孩子他妈.这样的话这位美女得同时继承这三个类.不过由于多继承会有一些缺陷,比如二义性.而且...
• 首先介绍一些面向对象(Object-Oriented，OO)术语，看看 C#在继承方面支持和不支持的功能。· 单重继承：表示一个类可以派生自一个基类，C#就采用这种继承。· 多重继承...
• ## C#接口实现多继承

千次阅读 2020-06-14 22:17:46
C#中接口可以多继承，接口之间可以相互继承和多继承。一个类可以同时继承一个类和多个接口，但是接口不能继承类。 using System; /** 假如你是一名在职学生，你就具有双重身份。一个身份是学生，必须完成学习任务...
• 抽象类和多重继承 一. 引言 图形的面积如何计算？ 在现实生活中需要知道具体的图形才能求面积 问题：shape类有必要存在么？ 二. 抽象类 面向对象中的抽象类 可用于表示现实世界中的抽象概念 是一种只能定义类型，...
• C#继承的概念 继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更加容易。同时也有利于重用代码和节省开发时间。 当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要...
• ## 论C#如何实现多继承

万次阅读 热门讨论 2014-08-27 20:39:04
谁说c#不能实现多继承，看本文是怎样那你的代码可以实现多继承的吧！
• ## C#中的继承

千次阅读 2021-10-28 10:11:00
（1）继承的概念 继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。 当创建一个类时，我们...C#继承的特点: ①派生类是对基类的扩展，派生类可以.
• 继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 等干脆取消了多继承。想快速学习C++的读者可以不必细读。 多继承的语法也很简单，将多个基类用逗号隔开即可。例如...
• C#中我们在使用类时，继承允许我们用一个类来定义另一个类，这就使得在创建和维护应用程序变得更加容易，同时也有利于重用代码和节省开发时间。继承也是C#面向对象编程的重要概念之一。 当我们创建一个类时，如果...
• c#反射及继承 详解反射请点击：http://www.cnblogs.com/landeanfen/p/4642814.html ** SonClass1.cs和BaseClass.cs是放在一个文件夹里面CodeLib 在文件夹里定义的一个类 BaseClass.cs using System; using System....
• C#面向对象编程-练习题 1．C#中的方法重写使用关键字（a）。 override overload static Inherit 2．以下的C#代码，试图用来定义一个接口： public interface IFile{ int A; int delFile() { A = 3; ...
• 继承的类型： 有实现继承和接口继承实现继承： 表示一个类型派生于一个基类型,它拥有该基类型的所有成员字段和函数。在实现继承中,派生类型采用基...一些语言支持所谓的“多重继承”，即一个类派生自多个类。使用多重

...

c# 订阅