sunny123456

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
C# 面向对象的三大特性 封装 继承 多态

C# 面向对象的三大特性
https://blog.csdn.net/yiyelanxin/article/details/94388986#封装

 目录

一、封装

二、继承

三、多态

 C# 面向对象的三大特性分别是封装、继承、多态，下面将帮助您更深一步了解并运用这三大特性。

一、封装

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

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

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

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

  • public：所有对象都可以访问；
  • private：对象本身在对象内部可以访问；
  • protected：只有该类对象及其子类对象可以访问
  • internal：同一个程序集的对象可以访问（即带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问）；
  • protected internal：访问限于当前程序集或派生自包含类的类型。（访问修饰符允许在本类,派生类或者包含该类的程序集中访问。这也被用于实现继承。）

internal示例：

  1. using System;
  2.  
  3. namespace RectangleApplication
  4. {
  5.     class Rectangle
  6.     {
  7.         //成员变量
  8.         internal double length;
  9.         internal double width;
  10.         
  11.         double GetArea()
  12.         {
  13.             return length * width;
  14.         }
  15.        public void Display()
  16.         {
  17.             Console.WriteLine("长度： {0}", length);
  18.             Console.WriteLine("宽度： {0}", width);
  19.             Console.WriteLine("面积： {0}", GetArea());
  20.         }
  21.     }//end class Rectangle    
  22.     class ExecuteRectangle
  23.     {
  24.         static void Main(string[] args)
  25.         {
  26.             Rectangle r = new Rectangle();
  27.             r.length = 4.5;
  28.             r.width = 3.5;
  29.             r.Display();
  30.             Console.ReadLine();
  31.         }
  32.     }
  33. }

二、继承

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

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了 属于（IS-A） 关系。例如，哺乳动物 属于（IS-A） 动物，狗 属于（IS-A） 哺乳动物，因此狗 属于（IS-A） 动物。

基类和派生类

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

假设，有一个基类 Shape，它的派生类是 Rectangle：

  1. using System;
  2. namespace InheritanceApplication
  3. {
  4.    class Shape 
  5.    {
  6.       public void setWidth(int w)
  7.       {
  8.          width = w;
  9.       }
  10.       public void setHeight(int h)
  11.       {
  12.          height = h;
  13.       }
  14.       protected int width;
  15.       protected int height;
  16.    }
  17.  
  18.    // 派生类
  19.    class Rectangle: Shape
  20.    {
  21.       public int getArea()
  22.       { 
  23.          return (width * height); 
  24.       }
  25.    }
  26.    
  27.    class RectangleTester
  28.    {
  29.       static void Main(string[] args)
  30.       {
  31.          Rectangle Rect = new Rectangle();
  32.  
  33.          Rect.setWidth(5);
  34.          Rect.setHeight(7);
  35.  
  36.          // 打印对象的面积
  37.          Console.WriteLine("总面积： {0}",  Rect.getArea());
  38.          Console.ReadKey();
  39.       }
  40.    }
  41. }

基类的初始化

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

示例如下：

  1. using System;
  2. namespace RectangleApplication
  3. {
  4.    class Rectangle
  5.    {
  6.       // 成员变量
  7.       protected double length;
  8.       protected double width;
  9.       public Rectangle(double l, double w)
  10.       {
  11.          length = l;
  12.          width = w;
  13.       }
  14.       public double GetArea()
  15.       {
  16.          return length * width;
  17.       }
  18.       public void Display()
  19.       {
  20.          Console.WriteLine("长度： {0}", length);
  21.          Console.WriteLine("宽度： {0}", width);
  22.          Console.WriteLine("面积： {0}", GetArea());
  23.       }
  24.    }//end class Rectangle  
  25.    class Tabletop : Rectangle
  26.    {
  27.       private double cost;
  28.       public Tabletop(double l, double w) : base(l, w)
  29.       { }
  30.       public double GetCost()
  31.       {
  32.          double cost;
  33.          cost = GetArea() * 70;
  34.          return cost;
  35.       }
  36.       public void Display()
  37.       {
  38.          base.Display();
  39.          Console.WriteLine("成本： {0}", GetCost());
  40.       }
  41.    }
  42.    class ExecuteRectangle
  43.    {
  44.       static void Main(string[] args)
  45.       {
  46.          Tabletop t = new Tabletop(4.5, 7.5);
  47.          t.Display();
  48.          Console.ReadLine();
  49.       }
  50.    }
  51. }

C# 多重继承

多重继承指的是一个类可以同时从多个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类只能继承自一个父类。

C# 不支持多重继承。但是，您可以使用接口来实现多重继承。如下：

  1. using System;
  2. namespace InheritanceApplication
  3. {
  4.    class Shape 
  5.    {
  6.       public void setWidth(int w)
  7.       {
  8.          width = w;
  9.       }
  10.       public void setHeight(int h)
  11.       {
  12.          height = h;
  13.       }
  14.       protected int width;
  15.       protected int height;
  16.    }
  17.  
  18.    // 基类 PaintCost
  19.    public interface PaintCost 
  20.    {
  21.       int getCost(int area);
  22.    }
  23.    // 派生类
  24.    class Rectangle : Shape, PaintCost
  25.    {
  26.       public int getArea()
  27.       {
  28.          return (width * height);
  29.       }
  30.       public int getCost(int area)
  31.       {
  32.          return area * 70;
  33.       }
  34.    }
  35.    class RectangleTester
  36.    {
  37.       static void Main(string[] args)
  38.       {
  39.          Rectangle Rect = new Rectangle();
  40.          int area;
  41.          Rect.setWidth(5);
  42.          Rect.setHeight(7);
  43.          area = Rect.getArea();
  44.          // 打印对象的面积
  45.          Console.WriteLine("总面积： {0}",  Rect.getArea());
  46.          Console.WriteLine("油漆总成本： ${0}" , Rect.getCost(area));
  47.          Console.ReadKey();
  48.       }
  49.    }
  50. }

三、多态

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

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

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

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

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

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

  • 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
  • 如果当前在 Word 下弹出的就是 Word 帮助；
  • 在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

1、静态多态性

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

  • 函数重载
  • 运算符重载

函数重载

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

运算符重载

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

例如：

  1. public static Box operator+ (Box b, Box c)
  2. {
  3.    Box box = new Box();
  4.    box.length = b.length + c.length;
  5.    box.breadth = b.breadth + c.breadth;
  6.    box.height = b.height + c.height;
  7.    return box;
  8. }

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

运算符重载的完整实现：

  1. using System;
  2.  
  3. namespace OperatorOvlApplication
  4. {
  5.    class Box
  6.    {
  7.       private double length;      // 长度
  8.       private double breadth;     // 宽度
  9.       private double height;      // 高度
  10.  
  11.       public double getVolume()
  12.       {
  13.          return length * breadth * height;
  14.       }
  15.       public void setLength( double len )
  16.       {
  17.          length = len;
  18.       }
  19.  
  20.       public void setBreadth( double bre )
  21.       {
  22.          breadth = bre;
  23.       }
  24.  
  25.       public void setHeight( double hei )
  26.       {
  27.          height = hei;
  28.       }
  29.       // 重载 + 运算符来把两个 Box 对象相加
  30.       public static Box operator+ (Box b, Box c)
  31.       {
  32.          Box box = new Box();
  33.          box.length = b.length + c.length;
  34.          box.breadth = b.breadth + c.breadth;
  35.          box.height = b.height + c.height;
  36.          return box;
  37.       }
  38.  
  39.    }
  40.  
  41.    class Tester
  42.    {
  43.       static void Main(string[] args)
  44.       {
  45.          Box Box1 = new Box();         // 声明 Box1，类型为 Box
  46.          Box Box2 = new Box();         // 声明 Box2，类型为 Box
  47.          Box Box3 = new Box();         // 声明 Box3，类型为 Box
  48.          double volume = 0.0;          // 体积
  49.  
  50.          // Box1 详述
  51.          Box1.setLength(6.0);
  52.          Box1.setBreadth(7.0);
  53.          Box1.setHeight(5.0);
  54.  
  55.          // Box2 详述
  56.          Box2.setLength(12.0);
  57.          Box2.setBreadth(13.0);
  58.          Box2.setHeight(10.0);
  59.  
  60.          // Box1 的体积
  61.          volume = Box1.getVolume();
  62.          Console.WriteLine("Box1 的体积： {0}", volume);
  63.  
  64.          // Box2 的体积
  65.          volume = Box2.getVolume();
  66.          Console.WriteLine("Box2 的体积： {0}", volume);
  67.  
  68.          // 把两个对象相加
  69.          Box3 = Box1 + Box2;
  70.  
  71.          // Box3 的体积
  72.          volume = Box3.getVolume();
  73.          Console.WriteLine("Box3 的体积： {0}", volume);
  74.          Console.ReadKey();
  75.       }
  76.    }
  77. }

可重载和不可重载运算符

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

运算符描述
+(正), -(负), !, ~(位非), ++, --这些一元运算符只有一个操作数，且可以被重载。
+, -, *, /, %这些二元运算符带有两个操作数，且可以被重载。
==, !=, <, >, <=, >=这些比较运算符可以被重载。
&&, ||这些条件逻辑运算符不能被直接重载。
+=, -=, *=, /=, %=这些赋值运算符不能被重载。
=, ., ?:, ->, new, is, sizeof, typeof这些运算符不能被重载。

2、动态多态性

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

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

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

抽象类示例： 

 

  1. using System;
  2. namespace PolymorphismApplication
  3. {
  4.    abstract class Shape
  5.    {
  6.        abstract public int area();
  7.    }
  8.    class Rectangle:  Shape
  9.    {
  10.       private int length;
  11.       private int width;
  12.       public Rectangle( int a=0, int b=0)
  13.       {
  14.          length = a;
  15.          width = b;
  16.       }
  17.       public override int area ()
  18.       { 
  19.          Console.WriteLine("Rectangle 类的面积：");
  20.          return (width * length); 
  21.       }
  22.    }
  23.  
  24.    class RectangleTester
  25.    {
  26.       static void Main(string[] args)
  27.       {
  28.          Rectangle r = new Rectangle(10, 7);
  29.          double a = r.area();
  30.          Console.WriteLine("面积： {0}",a);
  31.          Console.ReadKey();
  32.       }
  33.    }
  34. }

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

  • 虚方法是使用关键字 virtual 声明的。
  • 虚方法可以在不同的继承类中有不同的实现。
  • 对虚方法的调用是在运行时发生的。
  • 动态多态性是通过 抽象类 和 虚方法 实现的。

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

示例：

  1. using System;
  2. using System.Collections.Generic;
  3.  
  4. public class Shape
  5. {
  6.     public int X { get; private set; }
  7.     public int Y { get; private set; }
  8.     public int Height { get; set; }
  9.     public int Width { get; set; }
  10.    
  11.     // 虚方法
  12.     public virtual void Draw()
  13.     {
  14.         Console.WriteLine("执行基类的画图任务");
  15.     }
  16. }
  17.  
  18. class Circle : Shape
  19. {
  20.     public override void Draw()
  21.     {
  22.         Console.WriteLine("画一个圆形");
  23.         base.Draw();
  24.     }
  25. }
  26. class Rectangle : Shape
  27. {
  28.     public override void Draw()
  29.     {
  30.         Console.WriteLine("画一个长方形");
  31.         base.Draw();
  32.     }
  33. }
  34. class Triangle : Shape
  35. {
  36.     public override void Draw()
  37.     {
  38.         Console.WriteLine("画一个三角形");
  39.         base.Draw();
  40.     }
  41. }
  42.  
  43. class Program
  44. {
  45.     static void Main(string[] args)
  46.     {
  47.         // 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
  48.         var shapes = new List<Shape>
  49.         {
  50.             new Rectangle(),
  51.             new Triangle(),
  52.             new Circle()
  53.         };
  54.  
  55.         // 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法 
  56.         foreach (var shape in shapes)
  57.         {
  58.             shape.Draw();
  59.         }
  60.  
  61.         Console.WriteLine("按下任意键退出。");
  62.         Console.ReadKey();
  63.     }
  64.  
  65. }

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

  1. using System;
  2. namespace PolymorphismApplication
  3. {
  4.    class Shape 
  5.    {
  6.       protected int width, height;
  7.       public Shape( int a=0, int b=0)
  8.       {
  9.          width = a;
  10.          height = b;
  11.       }
  12.       public virtual int area()
  13.       {
  14.          Console.WriteLine("父类的面积：");
  15.          return 0;
  16.       }
  17.    }
  18.    class Rectangle: Shape
  19.    {
  20.       public Rectangle( int a=0, int b=0): base(a, b)
  21.       {
  22.  
  23.       }
  24.       public override int area ()
  25.       {
  26.          Console.WriteLine("Rectangle 类的面积：");
  27.          return (width * height); 
  28.       }
  29.    }
  30.    class Triangle: Shape
  31.    {
  32.       public Triangle(int a = 0, int b = 0): base(a, b)
  33.       {
  34.       
  35.       }
  36.       public override int area()
  37.       {
  38.          Console.WriteLine("Triangle 类的面积：");
  39.          return (width * height / 2); 
  40.       }
  41.    }
  42.    class Caller
  43.    {
  44.       public void CallArea(Shape sh)
  45.       {
  46.          int a;
  47.          a = sh.area();
  48.          Console.WriteLine("面积： {0}", a);
  49.       }
  50.    }  
  51.    class Tester
  52.    {
  53.       
  54.       static void Main(string[] args)
  55.       {
  56.          Caller c = new Caller();
  57.          Rectangle r = new Rectangle(10, 7);
  58.          Triangle t = new Triangle(10, 5);
  59.          c.CallArea(r);
  60.          c.CallArea(t);
  61.          Console.ReadKey();
  62.       }
  63.    }
  64. }

 

posted on 2021-03-30 21:07  sunny123456  阅读(374)  评论(0)    收藏  举报