C#-多态（十二）

继承概念
　　多态：即一个接口，多个功能
　　同一种操作作用于不同的对象，可以有不同的解释，产生不同的执行结果
　　多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的

静态多态性
　　在静态多态性中，函数的响应是在编译时发生的
　　父类中如果有方法需要子类重写，可以将该方法标记为虚方法
　　虚方法必须在父类中有实现，空实现也可以
　　虚方法子类可以重写，也可以不重写
　　实现静态多态性有两种方法;
　　　　函数重载
　　　　运算符重载

　　函数重载
　　　　即在同一范围中对同一函数名的多重定义
　　　　通过定义函数的传参的不同类型或数量进行区分
　　　　在调用函数时，根据传的参数类型和数量判断调用名字相同的那个方法　

 using System;

 namespace 函数重载
 {
     class printdata
     {
         void print(int i)
         {
             Console.WriteLine("printing int: {0}", i);
         }

         void print(double f)
         {
             Console.WriteLine("printing folat: {0}", f);
         }

         void print(string s)
         {
             Console.WriteLine("printing string: {0}", s);
         }

         static void Main(string[] args)
         {
             printdata p = new printdata();

             // 调用 print 来打印整数
             p.print();

             // 调用 print 来打印浮点数
             p.print(234.643);

             // 调用 print 来打印字符串
             p.print("Hello Tynam");

             Console.ReadKey();

         }
     }
 }

　　　　运行结果

·　　　　

　　运算符重载
　　　　重定义或重载C#中内置的运算符
　　　　通过关键字operator加运算符的符号来定义
　　　　与其他函数一样，重载运算符有返回类型和参数列表　　　　

 using System;

 namespace 运算符重载
 {
     class Complex
     {
         public int x;
         public int y;
         public int z;
         public Complex(int x, int y, int z)
         {
             this.x = x;
             this.y = y;
             this.z = z;
         }

         public static Complex operator+(Complex v1,Complex v2)
         {
             return new Complex(v1.x + v2.x,v1.y + v2.y,v1.z + v2.z);
         }

         public static Complex operator /(Complex v1, Complex v2)
         {
             return new Complex(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z);
         }
     }

     class Program
     {
         static void Main(string[] args)
         {
             Complex v1 = new Complex(,,);
             Complex v2 = new Complex(,,);
             Complex v3 = v1 + v2;
             Complex v4 = v1 / v2;
             Console.WriteLine("x is {0} ; y is {1} ; z is {2}", v3.x, v3.y, v3.z);
             Console.WriteLine("x is {0} ; y is {1} ; z is {2}", v4.x, v4.y, v4.z);
             Console.ReadKey();
         }
     }
 }

　　运行结果

　　

　　　　可重载和不可重载运算符
　　　　　　可以被重载的一元运算符：+、 -、 !、~、++、--
　　　　　　可以被重载的二元运算符：+、 -、 *、 /、 %
　　　　　　可以被重载的比较运算符：==、!=、<、>、<=、>=
　　　　　　不能被直接重载的条件逻辑运算符：&&、||
　　　　　　不能被重载的赋值运算符：+=、-=、*=、/=、 %=
　　　　　　不能被重载的其他运算符：=、 .、 ?:, ->、 new、 is、sizeof、typeof

动态多态性
　　在动态多态性中，函数的响应是在运行时发生的
　　使用关键字abstract创建抽象类，用于提供接口的部分类的实现
　　当一个派生类继承自该抽象类时，实现即完成
　　抽象类包含抽象方法，抽象方法可被派生类实现
　　抽象方法不允许有方法体的
　　当一个子类继承抽象类时，必须把父类的所有抽象成员都重写；若子类也是一个抽象类，可以不写
　　子类重写父类的方法，参数和返回值必须跟父类一样
　　抽象方法不能用static修饰
　　抽象类是有构造函数的，虽然不能被实例化
　　抽象类标记abstract，不能有任何实现，不能有方法体

 using System;

 namespace 动态多态性
 {
     abstract class Shape
     {
         public abstract int area();
     }

     class Rectangle : Shape
     {
         private int length;
         private int width;

         public Rectangle(int a = , int b = )
         {
             length = a;
             width = b;
         }

         public override int area()
         {
             return (width * length);
         }
     }

     class RectangleTester
     {
         static void Main(string[] args)
         {
             Rectangle r = new Rectangle(, );
             double a = r.area();
             Console.WriteLine("RectangleArea is: {0}",a);
             Console.ReadKey();
         }
     }

 }

　　运行结果