学习C#多态性

C#多态性

以下均为在菜鸟教程中学习的笔记

---

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

在C#中，每一个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自Object。

在C#中，多态就是同一个接口，使用不同实例而执行不同的操作。

静态多态性

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

1、函数重载

2、运算符重载

下期讨论运算符重载，这期只讨论函数重载。

函数重载

允许在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是函数列表中的参数不同，也可以是参数的个数不同。

不能重载只有返回类型不同的函数声明。

实例：

//using和namespace不写了
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);
        }
    }

结果：

add1 ：3
add2 ：6

动态多态性

抽象类

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

以下是一些关于抽象类的规则：

1、你不能创建一个抽象类的实例。

2、你不能在一个抽象类外部声明一个抽象方法。

3、通过在类定义前面放置关键字sealed，可以将类声明为密封类.当一个类被声明为sealed时，它不能被继承。抽象类不能声明为sealed。

（“我”的理解：抽象类就是专门用来继承的，所以不能实例化。且因为绝种类（密封类）不能被继承，所以抽象类不能被声明为sealed。抽象方法只能在抽象类里面定义）

实例：

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.Write("Rectangle 类的面积：");
            return (width * length);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle(10, 7);
            Console.WriteLine("{0}", r.area());
            Console.ReadKey();
        }
    }

结果：

Rectangle 类的面积：70

虚方法

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

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

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

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

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

实例：

public 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,int b) : base(a, b)
        {

        }
        public override int area()
        {
            Console.WriteLine("Rectangle 类的面积：");
            return (width * height);
        }
    }
    class Triangle : Shape
    {
        public Triangle(int a, int b) : base(a, b)
        {

        }
        public override int area()
        {
            Console.WriteLine("Triangle 类的面积：");
            return (width * height/2);
        }
    }
    

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("{0}", new Rectangle(10, 7).area());
            Console.WriteLine("{0}", new Triangle(10, 5).area());
            Console.ReadLine();
        }
    }

结果：

Rectangle 类的面积：
70
Triangle 类的面积：
25