C# 最基础知识介绍--多态

前言:????????

学过编程的人都知道有个名词叫" o o p 思 想 " —— {"面向对象编程"} " 面 向 对 象 编 程 " （object oriented programming，oop，面向对象程序设计）是一种计算机编程架构。oop 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。oop 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息 核心思想：封装，继承，多态.

一、c# 多态性

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。 多态性可以是静态的或动态的。在 静态多态性 中，函数的响应是在编译时发生的。在 动态多态性 中，函数的响应是在运行时发生的。 在 c# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 object。 多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

现实中，比如我们按下 f1 键这个动作：

• 如果当前在 flash 界面下弹出的就是 as 3 的帮助文档；
• 如果当前在 word 下弹出的就是 word 帮助；
• 在 windows 下弹出的就是 windows 帮助和支持。
• 同一个事件发生在不同的对象上会产生不同的结果。

二、静态多态性

在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。c# 提供了两种技术来实现静态多态性。分别为：

• 函数重载
• 运算符重载

三、函数重载

可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

下面的实例演示了几个相同的函数 add() ，用于对不同个数参数进行相加处理：

实例：

using system;
namespace polymorphismapplication
{
    public class testdata  
    {  
        public int add(int a, int b, int c)  
        {  
            return a + b + c;  
        }  
        public int add(int a, int b)  
        {  
            return a + b;  
        }  
    }  
    class program  
    {  
        static void main(string[] args)  
        {  
            testdata dataclass = new testdata();
            int add1 = dataclass.add(1, 2);  
            int add2 = dataclass.add(1, 2, 3);

            console.writeline("add1 :" + add1);
            console.writeline("add2 :" + add2);  
        }  
    }  
}

下面的实例演示了几个相同的函数 print()，用于打印不同的数据类型：

实例：

using system;
namespace polymorphismapplication
{
   class printdata
   {
      void print(int i)
      {
         console.writeline("输出整型: {0}", i );
      }

      void print(double f)
      {
         console.writeline("输出浮点型: {0}" , f);
      }

      void print(string s)
      {
         console.writeline("输出字符串: {0}", s);
      }
      static void main(string[] args)
      {
         printdata p = new printdata();
         // 调用 print 来打印整数
         p.print(1);
         // 调用 print 来打印浮点数
         p.print(1.23);
         // 调用 print 来打印字符串
         p.print("hello runoob");
         console.readkey();
      }
   }
}

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

输出整型: 1 输出浮点型: 1.23 输出字符串: hello runoob

四、c# 运算符重载

您可以重定义或重载 c# 中内置的运算符。因此，程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。

例如，请看下面的函数：

public static box operator+ (box b, box c)
{
   box box = new box();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   return box;
}

上面的函数为用户自定义的类 box 实现了加法运算符（+）。它把两个 box 对象的属性相加，并返回相加后的 box 对象。

1、运算符重载的实现

下面的程序演示了完整的实现：

实例：

using system;

namespace operatorovlapplication
{
   class box
   {
      private double length;      // 长度
      private double breadth;     // 宽度
      private double height;      // 高度

      public double getvolume()
      {
         return length * breadth * height;
      }
      public void setlength( double len )
      {
         length = len;
      }

      public void setbreadth( double bre )
      {
         breadth = bre;
      }

      public void setheight( double hei )
      {
         height = hei;
      }
      // 重载 + 运算符来把两个 box 对象相加
      public static box operator+ (box b, box c)
      {
         box box = new box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }

   }

   class tester
   {
      static void main(string[] args)
      {
         box box1 = new box();         // 声明 box1，类型为 box
         box box2 = new box();         // 声明 box2，类型为 box
         box box3 = new box();         // 声明 box3，类型为 box
         double volume = 0.0;          // 体积

         // box1 详述
         box1.setlength(6.0);
         box1.setbreadth(7.0);
         box1.setheight(5.0);

         // box2 详述
         box2.setlength(12.0);
         box2.setbreadth(13.0);
         box2.setheight(10.0);

         // box1 的体积
         volume = box1.getvolume();
         console.writeline("box1 的体积： {0}", volume);

         // box2 的体积
         volume = box2.getvolume();
         console.writeline("box2 的体积： {0}", volume);

         // 把两个对象相加
         box3 = box1 + box2;

         // box3 的体积
         volume = box3.getvolume();
         console.writeline("box3 的体积： {0}", volume);
         console.readkey();
      }
   }
}

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

box1 的体积： 210 box2 的体积： 1560 box3 的体积： 5400

2、可重载和不可重载运算符

下表描述了 c# 中运算符重载的能力：

实例针对上述讨论，让我们扩展上面的实例，重载更多的运算符：

实例：

using system;

namespace operatorovlapplication
{
    class box
    {
       private double length;      // 长度
       private double breadth;     // 宽度
       private double height;      // 高度
     
       public double getvolume()
       {
         return length * breadth * height;
       }
      public void setlength( double len )
      {
          length = len;
      }

      public void setbreadth( double bre )
      {
          breadth = bre;
      }

      public void setheight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符来把两个 box 对象相加
      public static box operator+ (box b, box c)
      {
          box box = new box();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          return box;
      }
     
      public static bool operator == (box lhs, box rhs)
      {
          bool status = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height
             && lhs.breadth == rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public static bool operator !=(box lhs, box rhs)
      {
          bool status = false;
          if (lhs.length != rhs.length || lhs.height != rhs.height
              || lhs.breadth != rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public static bool operator <(box lhs, box rhs)
      {
          bool status = false;
          if (lhs.length < rhs.length && lhs.height
              < rhs.height && lhs.breadth < rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator >(box lhs, box rhs)
      {
          bool status = false;
          if (lhs.length > rhs.length && lhs.height
              > rhs.height && lhs.breadth > rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator <=(box lhs, box rhs)
      {
          bool status = false;
          if (lhs.length <= rhs.length && lhs.height
              <= rhs.height && lhs.breadth <= rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator >=(box lhs, box rhs)
      {
          bool status = false;
          if (lhs.length >= rhs.length && lhs.height
             >= rhs.height && lhs.breadth >= rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public override string tostring()
      {
          return string.format("({0}, {1}, {2})", length, breadth, height);
      }
   
   }
   
   class tester
   {
      static void main(string[] args)
      {
        box box1 = new box();          // 声明 box1，类型为 box
        box box2 = new box();          // 声明 box2，类型为 box
        box box3 = new box();          // 声明 box3，类型为 box
        box box4 = new box();
        double volume = 0.0;   // 体积

        // box1 详述
        box1.setlength(6.0);
        box1.setbreadth(7.0);
        box1.setheight(5.0);

        // box2 详述
        box2.setlength(12.0);
        box2.setbreadth(13.0);
        box2.setheight(10.0);

       // 使用重载的 tostring() 显示两个盒子
        console.writeline("box1： {0}", box1.tostring());
        console.writeline("box2： {0}", box2.tostring());
       
        // box1 的体积
        volume = box1.getvolume();
        console.writeline("box1 的体积： {0}", volume);

        // box2 的体积
        volume = box2.getvolume();
        console.writeline("box2 的体积： {0}", volume);

        // 把两个对象相加
        box3 = box1 + box2;
        console.writeline("box3： {0}", box3.tostring());
        // box3 的体积
        volume = box3.getvolume();
        console.writeline("box3 的体积： {0}", volume);

        //comparing the boxes
        if (box1 > box2)
          console.writeline("box1 大于 box2");
        else
          console.writeline("box1 不大于 box2");
        if (box1 < box2)
          console.writeline("box1 小于 box2");
        else
          console.writeline("box1 不小于 box2");
        if (box1 >= box2)
          console.writeline("box1 大于等于 box2");
        else
          console.writeline("box1 不大于等于 box2");
        if (box1 <= box2)
          console.writeline("box1 小于等于 box2");
        else
          console.writeline("box1 不小于等于 box2");
        if (box1 != box2)
          console.writeline("box1 不等于 box2");
        else
          console.writeline("box1 等于 box2");
        box4 = box3;
        if (box3 == box4)
          console.writeline("box3 等于 box4");
        else
          console.writeline("box3 不等于 box4");

        console.readkey();
      }
    }
}

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

box1： (6, 7, 5) box2： (12, 13, 10) box1 的体积： 210 box2 的体积： 1560 box3：(18, 20, 15) box3 的体积： 5400 box1 不大于 box2 box1 小于 box2 box1 不大于等于 box2 box1 小于等于 box2 box1 不等于 box2 box3 等于 box4

五、动态多态性

c# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。 抽象类 包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

请注意，下面是有关抽象类的一些规则：

• 不能创建一个抽象类的实例。
• 不能在一个抽象类外部声明一个抽象方法。
• 通过在类定义前面放置关键字 sealed，可以将类声明为 密封类 。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。
  

下面的程序演示了一个抽象类：

实例：

using system;
namespace polymorphismapplication
{
   abstract class shape
   {
       abstract public int area();
   }
   class rectangle:  shape
   {
      private int length;
      private int width;
      public rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
      public override int area ()
      {
         console.writeline("rectangle 类的面积：");
         return (width * length);
      }
   }

   class rectangletester
   {
      static void main(string[] args)
      {
         rectangle r = new rectangle(10, 7);
         double a = r.area();
         console.writeline("面积： {0}",a);
         console.readkey();
      }
   }
}

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

rectangle 类的面积： 面积： 70

当有一个定义在类中的函数需要在继承类中实现时，可以使用 虚方法 。

虚方法是使用关键字 virtual 声明的。

虚方法可以在不同的继承类中有不同的实现。

对虚方法的调用是在运行时发生的。

动态多态性是通过 抽象类 和 虚方法 实现的。

以下实例创建了 shape 基类，并创建派生类 circle、 rectangle、triangle， shape 类提供一个名为 draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。

实例:

using system;
using system.collections.generic;

public class shape
{
    public int x { get; private set; }
    public int y { get; private set; }
    public int height { get; set; }
    public int width { get; set; }
   
    // 虚方法
    public virtual void draw()
    {
        console.writeline("执行基类的画图任务");
    }
}

class circle : shape
{
    public override void draw()
    {
        console.writeline("画一个圆形");
        base.draw();
    }
}
class rectangle : shape
{
    public override void draw()
    {
        console.writeline("画一个长方形");
        base.draw();
    }
}
class triangle : shape
{
    public override void draw()
    {
        console.writeline("画一个三角形");
        base.draw();
    }
}

class program
{
    static void main(string[] args)
    {
        // 创建一个 list<shape> 对象，并向该对象添加 circle、triangle 和 rectangle
        var shapes = new list<shape>
        {
            new rectangle(),
            new triangle(),
            new circle()
        };

        // 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 shape 对象调用 draw 方法
        foreach (var shape in shapes)
        {
            shape.draw();
        }

        console.writeline("按下任意键退出。");
        console.readkey();
    }

}

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

• 画一个长方形
• 执行基类的画图任务
• 画一个三角形
• 执行基类的画图任务
• 画一个圆形
• 执行基类的画图任务
• 按下任意键退出。
  

下面的程序演示通过虚方法 area() 来计算不同形状图像的面积：

实例:

using system;
namespace polymorphismapplication
{
   class shape
   {
      protected int width, height;
      public shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      public virtual int area()
      {
         console.writeline("父类的面积：");
         return 0;
      }
   }
   class rectangle: shape
   {
      public rectangle( int a=0, int b=0): base(a, b)
      {

      }
      public override int area ()
      {
         console.writeline("rectangle 类的面积：");
         return (width * height);
      }
   }
   class triangle: shape
   {
      public triangle(int a = 0, int b = 0): base(a, b)
      {
     
      }
      public override int area()
      {
         console.writeline("triangle 类的面积：");
         return (width * height / 2);
      }
   }
   class caller
   {
      public void callarea(shape sh)
      {
         int a;
         a = sh.area();
         console.writeline("面积： {0}", a);
      }
   }  
   class tester
   {
     
      static void main(string[] args)
      {
         caller c = new caller();
         rectangle r = new rectangle(10, 7);
         triangle t = new triangle(10, 5);
         c.callarea(r);
         c.callarea(t);
         console.readkey();
      }
   }
}

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

rectangle 类的面积： 面积：70 triangle 类的面积： 面积：25

总结????

到此这篇关于c# 最基础知识介绍--多态的文章就介绍到这了,更多相关c# 多态内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！