1.抽象类与抽象方法：
（1）使用关键字abstract修饰的类，称为抽象类.
（2）抽象类只是用到一个类所具有的行为，不能单独通过创建对象来使用.使用new是错误的.可以通过派生类来实现其函数成员的具体逻辑。
（3）抽象类中可以有抽象方法，也可以没有任何抽象方法.只要类中存在一个抽象方法，这个类就是抽象类。
（4）抽象类不能是静态的（static）或者密封的（sealed）
下面就是一个简单的抽象类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
abstract class Vehicle { public abstract void test(); public void VehicleTest() { } } class Car : Vehicle { public override void test() { } } |
2.开闭原则
如果不是为了修改bug，或者是添加新的功能，不要随便更改类的代码。
换句话说，我们应该封装那些确定的，不变的，稳定的，固定的。把不确定的，有可能会改变的成员声明为抽象类，留给子类去实现。
3.我们简单实现了一个继承
|
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
34
35
36
37
38
39
40
41
42
43
44
45
46
|
class Program { static void Main(string[] args) { Vehicle raceCar = new RaceCar(); Console.ReadKey(); } } /// <summary> /// 交通工具类 /// </summary> class Vehicle { /// <summary> /// 停车 /// </summary> public void Stop() { Console.WriteLine("Stopped"); } /// <summary> /// 加油 /// </summary> public void Fill() { Console.WriteLine("Fill"); } } class Car : Vehicle { public void Run() { Console.WriteLine("Car is running"); } } class RaceCar : Car { public void Run() { Console.WriteLine("RaceCar is running"); } } |
从上面的代码我们可以看出这是一个继承链，其中Run方法是根据不同种类的车来区别的，所以我们如果想实现多态，比如 Vehicle raceCar = new RaceCar();此时raceCar 对象是调不到Run方法的，因为Vehicle类中没有这个方法，以前对于这种情况的解决方法是在Vehicle中加上Run方法，并且判断有什么类型：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public void Run(string type) { if (type == "Car") { Console.WriteLine("Car is running"); } else if (type == "RaceCar") { Console.WriteLine("RaceCar is running"); } else { } } |
如上代码，这样的话，当增加新类型的时候还要再改这个基类中的方法，违反了开闭原则（ 如果不是为了修改bug，或者是添加新的功能，不要随便更改类的代码），所以需要做一下修改：
|
1
2
3
4
5
6
|
public virtual void Run() { Console.WriteLine("RaceCar is running"); } |
派生类来重写这个方法，这样增加新类型的时候重写就可以，就不用再更改基类的代码了。但是，如果你觉得这个类中基本不会调用这个Run方法，那我们可以去掉方法体，改成抽象方法，相应的类也变成抽象类，Run完全由派生类来重写。
|
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
class Program { static void Main(string[] args) { Vehicle raceCar = new RaceCar(); Console.ReadKey(); } } /// <summary> /// 交通工具类 /// </summary> abstract class Vehicle { /// <summary> /// 停车 /// </summary> public void Stop() { Console.WriteLine("Stopped"); } /// <summary> /// 加油 /// </summary> public void Fill() { Console.WriteLine("Fill"); } public abstractvoid Run() { Console.WriteLine("RaceCar is running"); } } class Car : Vehicle { public override void Run() { Console.WriteLine("Car is running"); } } class RaceCar : Car { public override void Run() { Console.WriteLine("RaceCar is running"); } } |
4.接口与抽象类
（1）具体类-》抽象类-》接口，越来越抽象，内部实现的类越来越少。
（2）抽象类为复用而生：专门作为基类来使用，也具有解耦功能。
（3）封装确定，开放不确定的，推迟到子类实现。
（4）接口为解耦而生，高内聚，低耦合，方便单元测试。
（5）都不能实例化，只能声明变量，引用具体类的实例。
到此这篇关于浅谈C# 抽象类与开闭原则的文章就介绍到这了,更多相关C# 抽象类与开闭原则内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.cnblogs.com/anjingdian/p/13138430.html
