C# OOP编程

1. 1:面向对象的概念：什么是类、对象。以及类与对象的关系。
2.  
   面向对象三大特征： 封装/继承/多台
3.  
    
4.  
   2:封装性：
5.  
   用访问修饰符来体现封装性。
6.  
   Public 公共的/ private 私有的/Protected 受保护的/Internal 本程序集的
7.  
    
8.  
   3:构造函数。
9.  
   功能：是维护一个类的完整性。可以通过类的构造函数，使得一个类构造出不同（型号/类别）的对象实体。
10.  
    特征： 1）构造函数名称与类名相同。
11.  
    2）构造函数没有返回数值，也不加void 关键字。
12.  
    3）构造函数不需要调用，可以直接运行。
13.  
     
14.  
    4:方法的定义。
15.  
    方法的构成：4部分
16.  
    1） 方法的名称。
17.  
    2） 方法的参数列表
18.  
    3） 方法的返回类型，如果没有返回数值，要加“void” 关键字。
19.  
    4） 方法体（方法的内容）
20.  
     
21.  
    5:学习static 关键字。
22.  
    特点：
23.  
    5.1： 用static 修饰的方法，叫静态方法。
24.  
    5.2： 在实例方法中，调用静态方法，需要使用类名称调用。
25.  
    在静态方法中，调用静态方法，可以直接调用。
26.  
    用途： 是简化编写，为了更容易被访问。
27.  
     
28.  
    6:继承的概念。
29.  
    继承使用符号“:”来表示继承。
30.  
     
31.  
    7:在继承关系下，构造函数的规则。
32.  
    规则： 实例化子类，系统先自动调用父类的构造函数，然后调用子类构造函数。
33.  
     
34.  
    8:学习关键字。
35.  
    base, this.
36.  
    Base: 代表父类对象。
37.  
    This： 代表本类对象。
38.  
    适用范围：
39.  
    在子类与父类发生“方法覆盖”时候，为了能够调用被覆盖（或者“隐藏”）的方法，必须使用base .
40.  
     
41.  
    9:base 关键字在构造函数中的应用，即：显示调用父类构造函数。
42.  
     
43.  
    10:析构函数。
44.  
    定义“~”定义析构函数。 作用是在本对象需要销毁之前，做一些清理工作。
45.  
    比如在需要进行数据库连接，Socket 数据通信的时候，需要关闭对应的连接等。
46.  
     
47.  
    11:命名空间。
48.  
    使用关键字： NameSpace 定义。
49.  
    目的是：为了一个项目中，可以使用重名的类。（相当于是操作系统中的“虚拟目录”的概念）。
50.  
     
51.  
    12:访问修饰符：
52.  
    Public: 最大访问级别。
53.  
    Internal: 局部的。 在一个“程序集”中，都可以访问。
54.  
    Protected: 受保护的类型。 除了自己能够访问，本类的子类也可以访问。（“继承链”）
55.  
    Private : 只能自己访问。
56.  
     
57.  
    13:学习面向对象中的“多态性”的概念。
58.  
     
59.  
    14:多态性—方法重载。（静态多态性）
60.  
    同一个类中，有多个方法名相同，但是方法的参数不同，这种现象叫~。
61.  
    多态性-方法的重写(动态多态性)
62.  
    在继承关系的类中，父类中定义了“虚方法”（关键字：Virtual）， 子类使用关键字override 进行方法重写。这种机制叫~。
63.  
    方法重写的目的： 就是可以不断优化代码的一种机制。
64.  
     
65.  
    15:学习Sealed 关键字。
66.  
    密封关键字。
67.  
    类/ 方法。
68.  
     
69.  
    16:抽象类/抽象方法。
70.  
    关键字： Abstract
71.  
    规则1： 一个抽象方法，必须存在于抽象类中。但是一个抽象类可以没有抽象方法。
72.  
    规则2： 一个类继承抽象类，则必须“重写”抽象父类中的抽象方法。
73.  
     
74.  
    17:接口/多重接口。
75.  
    关键字： Interface
76.  
    接口是与“类”相同的编程单位，相互之间不“隶属”。
77.  
    规则1： 接口中只能定义抽象方法，不能有public , abstract 关键字。
78.  
    规则2： 接口可以多种继承。
79.  
    规则3： 一个类继承接口，则必须“实现”接口中所有的方法。
80.  
     
81.  
    18:值类型与引用类型。
82.  
    值类型在方法传递的时候，是传递的自身的“拷贝”。
83.  
    引用类型在方法传递的时候，是传递的自身的“地址”。
84.  
    常用值类型与引用类型转换的关键字如下：
85.  
    Ref / out 关键字。
86.  
    Ref 关键字可以把值类型转变为引用类型。
87.  
    Out 关键字目的是可以让方法有多个输出参数。
88.  
     
89.  
    19:属性。
90.  
    规则1： 属性是方法的简化，目的是控制类的“字段”的可访问性。
91.  
     
92.  
    20:动态多态性。
93.  
    目的是为了更好的开发出灵活，功能强大的程序。
94.  
    可以使用“虚函数”，“抽象方法”，“接口”来实现动态多态性。
95.  
    建议使用“接口”来实现动态多态性，即：面向接口编程。
96.  
     
97.  
    21:面向接口编程。
98.  
    接口最好功能单一。
99.  
    接口可以通过继承关系实现功能强大的复合接口。
100.  
      
101.  
     C#的OOP即面向对象开发三大特性： 封装、继承、多态，是非常核心的OOP开发思想。现就这部分总结部分知识点如下:
102.  
      
103.  
     1: 概念
104.  
     类与对象的关系.
105.  
     创建类
106.  
     类与对象的本质区别：
107.  
     类是建筑蓝图、对象是按照这份蓝图来建造的房子。
108.  
      
109.  
     2: 访问区分符(修饰符)
110.  
     访问修饰符是C#实现类的封装的最核心手段。
111.  
     private: 私有的，只能本类访问，包括子类也不能访问，是最严格的控制访问。
112.  
     public: 公有的，所有类都可以访问，是最松散的控制访问。
113.  
     protected: 受保护的，也就是除了本类之外，只有自己的子类可以访问。
114.  
     internal: 本程序集的，也就是说一个程序集内部都可以访问，外部不行。
115.  
      
116.  
     3:构造函数
117.  
     1） 与类名同名。2） 自动运行。 3） 不能返回任何数值，也不能加VOID.
118.  
     4） 每个类都必须有一个构造函数，用户不提供则系统会提供自己默认的构造函数。
119.  
     5） 构造函数的默认访问是private，但这样就不能在类的外部创建实例。
120.  
     6） 创建了带参数的构造函数，系统不会再创建默认构造函数。
121.  
      
122.  
      
123.  
     4: 特殊方法学习
124.  
     4.1> 使用static 定义静态字段与方法.
125.  
     规则1：static 方法中，需用对象访问类中定义的任何实例字段与方法。
126.  
     规则2：static 方法中，可以直接访问static字段与static方法。
127.  
      
128.  
     4.2>Main 方法
129.  
     Main() 方法是一个项目中唯一的入口程序，也就是程序开始执行的地方。
130.  
     5: 命名空间
131.  
     使用NameSpace 关键字来规定一个“虚拟的目录”使得大型项目中，允许有重复的类名称存在。（这个技术类似操作系统中的“目录”的作用）

      

      

     转载自 https://blog.csdn.net/ldy597321444/article/details/52955035

来源：https://www.cnblogs.com/LeeMicroShake/p/11847955.html