C# 理解面向对象的基本特征——封装、继承、多态_c#构造函数 封装继承多态

——
声明：本文内容系互联网整理收集，内容有改动。
https://www.runoob.com/csharp/csharp-tutorial.html 菜鸟教程
https://docs.microsoft.com/zh-cn/dotnet/csharp/ Microsoft C#文档
零散的资料在每章节末尾给出。

0什么是面向对象

又名：类和对象的关系
面向对象 ( Object Oriented ) 是将现实问题构建关系，然后抽象成 类 ( class )，即对象是对客观事物的抽象，类是对对象的抽象。因此对象是类的具体，当没有为类创建任何对象时，类本身不存在于内存空间中，对象是真实存在的。给类定义属性和方法后，再将类实例化成 实例 ( instance，可以说类的实例是对象，new关键字来创建 ) ，通过访问实例的属性和调用方法来进行使用。

类描述了一组有相同特性（属性）和相同方法的对象。

这里给出一个创建类并实例化的例子：

 class Shape//定义类
   {
      public void setWidth(int w)//定义方法
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;//定义成员变量
      protected int height;
   }
   class ShapeTester
   {
      static void Main(string[] args)//string[] args 指的就是你在命令窗口输入的参数，也就是命令行参数。
      {
         Shape sha = new Shape();//类的实例化（创建对象）【类 实例名 = new   类（）；】

         sha.setWidth(5);//【实例名.属性/实例名.方法名();】
         sha.setHeight(7);


      }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

面向对象的三个特征：封装、继承、多态。

https://blog.csdn.net/yyp0304Devin/article/details/84619920 C#之让你彻底明白对象，类，实例化的区别及联系
https://www.cnblogs.com/mdnx/archive/2012/09/05/2672592.html C# 类(1) 创建第一个类,并且实例化.

1封装

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。
封装是将一个或多个项目集合在一个单元中，这个单元称之为类，这样可以防止对实现细节的访问（保护代码），并定义新的对象。封装既可以封装成员变量，又可以封装成员方法。
C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。
一个 访问修饰符定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自包含类的类型。
1
2
3
4
5

例： public double length;
1

如果省略了访问修饰符,即为 internal。
具体步骤：

class Shape //新建类
   {
      public void setWidth(int w)//方法封装
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;//成员变量封装
      protected int height;
   } //类定义完成，下一步就是将类实例化
1
2
3
4
5
6
7
8
9
10
11
12
13

2继承

继承是面向对象程序设计中最重要的概念之一。当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为基类，这个新的类被称为派生类。派生类必须继承父类的方法。
继承仅适用于类和接口，其他各种类型（结构、委托和枚举）均不支持继承。

<访问修饰符符> class <基类>
{
 ...
}
class <派生类> : <基类>
{
 ...
}
——
例：
// 基类
class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 派生类
   class Rectangle: Shape
   {
      public int getArea()
      {
         return (width * height);
      }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

并非所有基类成员都可供派生类继承，如构造函数和析构函数。
注意：

1. C# 只支持单一继承，即类只能继承自一个类，但可以使用接口来实现多重继承。
2. 继承是可传递的，类型 D 可继承自类型 C，其中类型 C 继承自类型 B，类型 B 又继承自基类类型 A。 由于继承是可传递的，因此类型 D 继承了类型 A 的成员。

3多态

多态是指同一个接口，使用不同的实例而执行不同操作。在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

继承是子类可以调父类的方法，多态是父类可以调子类的方法。

与多态有关的概念:重载、重写、虚方法、抽象方法以及隐藏方法。

1. 重载（overload）：在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载。

void print(int i)
      {
         Console.WriteLine("输出整型: {0}", i );
      }

void print(double f)
      {
         Console.WriteLine("输出浮点型: {0}" , f);
      }
1
2
3
4
5
6
7
8
9

3. 重写（overwrite）：子类中为满足自己的需要来重复定义某个方法的不同实现，需要用 override 关键字，被重写的方法必须是虚方法，用的是 virtual 关键字。

virtual void print()
      {
         Console.WriteLine("输出整型: {0}" );
      }
      
override  void print()
      {
         Console.WriteLine("输出浮点型: {0}");
      }
1
2
3
4
5
6
7
8
9

——
4. 虚方法：即为基类中定义的允许在派生类中重写的方法，使用virtual关键字定义。
——
5. 抽象方法：在基类中定义的并且必须在派生类中重写的方法，使用abstract关键字定义。抽象方法只能在抽象类中定义。
6. 隐藏方法：在派生类中定义的和基类中的某个方法同名的方法，使用new关键字定义。

接口是多态的体现形式：

[访问修饰符] interface 接口名
			{
				//接口成员定义
			}
1
2
3
4

https://www.cnblogs.com/zhangkai2237/archive/2012/12/20/2826734.html C#中的多态性