首页 > 编程语言> > 夜光带你走进C#语言基础版本（49）

夜光带你走进C#语言基础版本（49）

2019-08-04 09:03:07 作者：互联网

夜光序言：

理想的书籍是智慧的铜匙。

一切节省，归根到底都归结为时间的节省。

今天所做之事勿候明天，自己所做之事勿候他人。

坚强的信心，能使平凡的人做出惊人的事业。

正文：

C# 多态性

多态：一个接口多个功能。

静态多态性：编译时发生函数响应（调用）；

动态多态性：运行时发生函数响应。

静态绑定（早期绑定）：编译时函数和对象的连接机制。两种技术实现静态多态性：函数重载/运算符重载。

函数重载：在同一范围内对相同函数名有多个定义，可以是参数类型或参数个数的不同，但不许只有返回值类型不同。

运算符重载：

关键字 abstract 声明抽象类：用于接口部分类的实现（派生类继承抽象类时，实现完成）。抽象类包含抽象方法，抽象方法可被派生类实现。

抽象类规则：

1.不能创建抽象类的实例
2.不能在抽象类外定义抽象方法
3.不能把抽象类声明为sealed（类前带关键字sealed代表该类是密封类，不能被继承）

关键字virtual声明虚方法:用于方法在继承类中的实现（在不同的继承类中有不同的实现）。

抽象类和虚方法共同实现动态多态性。

注：继承类中的重写虚函数需要声明关键字 override，在方法参数传入中写（类名形参名）例如 public void CallArea(Shape sh)，意思是传入一个 shape 类型的类。

静态多态性

在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。

C# 提供了两种技术来实现静态多态性。分别为：

函数重载
运算符重载

运算符重载将在之后聊一聊，接下来我们将讨论函数重载。

函数重载

您可以在同一个范围内对相同的函数名有多个定义。

函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。

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

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

实例

using System;
namespace GeniusTest01
{
    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;  
        }  
    }  
    
    public class Class81
    {
         // 夜光
        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 GeniusTest01
{
    public class Class82
    {
        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("come GENIUS");
                Console.ReadKey();
            }
        }
    }
}

动态多态性

C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。

当一个派生类继承自该抽象类时，实现即完成。

抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

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

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

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

实例

using System;
namespace GeniusTest01
{  
    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);
             }
         }

    public class Class83
    {
      
        class RectangleTester
        {
            static void Main(string[] args)
            {
                Rectangle r = new Rectangle(10, 7);
                double a = r.area();
                Console.WriteLine("面积： {0}", a);
                Console.ReadKey();
            }
        }
    }
}

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

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

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

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

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

以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。

实例

using System;
using System.Collections.Generic;

namespace GeniusTest01
{
    
    
    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();
        }
    }
    
    public class Class84
    {
        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 GeniusTest01
{
    //夜光：en
    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);
        }
    }

    public class Class85
    {
        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();
        }
    }
}

标签：Console,49,C#,class,int,WriteLine,抽象类,public,夜光
来源： https://blog.csdn.net/weixin_41987706/article/details/98361932

夜光带你走进C#语言 基础版本（49）