c#oop继承-封装-多态_c#oop多态-优快云博客

本文介绍了C#中的面向对象特性，包括封装的概念和Public、Private访问修饰符的使用，解释了继承的原理和基类与派生类的关系，以及多态性的静态和动态表现，如函数重载和抽象类的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C# 封装
封装被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。

一个访问修饰符定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：Public 访问修饰符

Public 访问修饰符

Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。

using System;
 
namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        public double length;
        public double width;
 
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }// Rectangle 结束
 
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

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

Private 访问修饰符

Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

using System;
 
namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        private double length;
        private double width;
 
        public void Acceptdetails()
        {
            Console.WriteLine("请输入长度：");
            length = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入宽度：");
            width = Convert.ToDouble(Console.ReadLine());
        }
        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 ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

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

C# 继承

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数。

C# 中创建派生类的语法如下：

 
<访问修饰符符> class <基类>
 
{
 
 ...
 
}
 
class <派生类> : <基类>
 
{
 
 ...
 
}

基类的初始化

派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。您可以在成员初始化列表中进行父类的初始化。

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

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

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

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

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

下面的实例演示了几个相同的函数 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);  
        }  
    }  
}

动态多态性

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

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

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

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