OOP

POP（Procedure Oriented Programming），面向过程是一种程序设计思想。
OOP（Object Oriented Programming），面向对象是一种程序设计思想。
AOP（Aspect Oriented Programming），面向切面编程与面向对象编程的延续。
->什么是面向过程？
面向过程是基于 ‘过程’ 的，这个 ‘过程’ 在程序语言当中就是一个个的函数。

说你今天起床前干了什么事？ 睁眼》看手机》睡觉》睁眼》看手机》起床

面向过程编程就是对事物的处理有严格的过程顺序。在程序的处理里面就是，我处理一件事情的程序就只能处理这一件事情。
->什么是面向对象？
面向对象是基于 ‘对象’ 的，这个 ‘对象’ 在程序语言当中就时一个个的类。

说你今天起床前干了什么事？ ‘我’ 就是一个类，‘我’ 这个类中包含了很多的方法，比如有（看手机，睁眼，睡觉，起床）这些方法，这写方法没有严格的执行顺序，比如看手机不一定是睁眼之后看手机。 但是面向对象是可以基于过程编程的。

->什么是AOP？
面向切面编程与面向对象编程的延续，也就是在面向对象的基础上提出了面向过程这种编程思想，这种编程思想在web领域极为受用。
如果说面向对象是对一个业务的方法属性封装，那么面向过程就是在不破坏原有业务的逻辑之上对业务进行扩展。

我想起床，但是在起床需要叫人把我衣服拿过来？ 如果在原有的逻辑上添加，则会破坏原有类的逻辑，还会增加耦合，所以这里就需要用到AOP的技术。

面向对象的三大特性和五大原则

01_C#之OOP - 图1
可以说，凡是基于面向对象编程的设计语言都会有这些特性和遵守这些原则，否则很难说这个语言是面型对象的程序设计语言。

三大特性

封装

我认为：封装就是将面向过程中的方法、属性、字段有一定逻辑的写在一个整体中，这个整体叫做类，这些封装在类内部的数据与函数叫做类的成员。外部在使用的时候，不需要知道方法的具体实现，只需要调用类中的公共接口（方法）就能实现对类的简单调用。对象就是类的实例化，就是对类内部的数据进行初始化的一种操作。

继承

我认为：继承是为了代码的复用。x继承了y，x（子类），y（父类），子类具有父类的方法个属性，子类还可以有自己的方法和属性，所以子类比父类更具体。
当然了，不是所有的类都可以为父类，也不说所有的属性与方法都可以被继承。

多态

1、什么是多态？：多态顾名思义就是有很多种状态，具体表现为一种事务在不同人员访问时可以根据成员 的类型，动态的进行响应，这种动态的响应就称为多态。
2、怎么实现多态？：一般实现多态可以有三种方法：抽象（abstract），虚拟（virtual），接口（interface）
3、怎么选择？:其实这几种方法都用到了继承/实现，然后由父类指向子类对象，然后由子类完成对父类的抽象（类/方法）或 虚拟方法完成重写，来实现在调用父类的对象时，执行的是子类方法。选择时应该按照具体情况，如父类是真实的实体，可以 实现的，就可以用虚拟方法，而如果父类是抽象的，不可实现的，就不应改用虚拟，而是用抽象的类来解决。这里的抽象和虚拟都有一些区别和注意事项，在实际情况下要注意，具体可以参照笔记来完成书写，

  1. class Program
  2.     {
  3.         static void Main(string[] args)
  4.         {
  5.             // 这种方法是用抽象的形式完成多态的，
  6.             animal dog = new dog("小狗") ;
  7.             animal cat = new cat("小猫") ;
  8.             cat.shout();
  9.             dog.shout();
  10.         }
  11.     }
  13.     abstract class animal
  14.     {
  15.         private string _name;
  16.         public string Name
  17.         {
  18.             get { return _name; }
  19.             set { _name = value; }
  20.         }
  21.         public abstract void shout();
  22.     }
  24.     class dog : animal
  25.     {
  26.         public dog(string name){
  27.             Name = name;
  28.         }
  29.         public override void shout()
  30.         {
  31.             Console.WriteLine($"{Name}:一giao窝里giao");
  32.         }
  33.     }
  35.     class cat : animal
  36.     {
  37.         public cat(string name){
  38.             Name = name;
  39.         }
  40.         public override void shout()
  41.         {
  42.             Console.WriteLine($"{Name}:一giao窝里giao");
  43.         }
  44.     }
  45. using System;
  46. using System.Collections.Generic;
  47. using System.Data.SqlClient;
  48. using System.Linq;
  49. using System.Threading.Tasks;
  50. using System.Windows.Forms;
  52. namespace LaozhangForm
  53. {
  54.     static class Program
  55.     {
  56.         public static SqlConnection conn ;
  58.         /// <summary>
  59.         /// 应用程序的主入口点。
  60.         /// </summary>
  61.         [STAThread]
  62.         static void Main()
  63.         {
  64.             conn = LaoZhang.Program.conn;
  65.             LaoZhang.Program.conn.Open();
  66.             Application.EnableVisualStyles();
  67.             Application.SetCompatibleTextRenderingDefault(false);
  68.             Application.Run(new Form1());
  69.             LaoZhang.Program.conn.Close();
  70.         }
  71.     }
  72. }

五大原则

单一职责原则（类）

单一职责原则（Single Responsibility Principle，SRP）又称单一功能原则，由罗伯特·C.马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中提出的。这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one reason for a class to change）。
单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。

我的理解：有点类似于数据库中的原子性质，但是不完全一样。也就是说，一个类只负责一种职责，比如一个教师类，可能有辅导员，也有普通教师，所以教师类应当被拆分。

开放封闭原则（类）

开闭原则（Open Closed Principle，OCP）由勃兰特·梅耶（Bertrand Meyer）提出，他在 1988 年的著作《面向对象软件构造》（Object Oriented Software Construction）中提出：软件实体应当对扩展开放，对修改关闭（Software entities should be open for extension，but closed for modification），这就是开闭原则的经典定义。
开闭原则的含义是：当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。

我的理解：一个实体类中，只开放应当开放的属性和方法。在类中就是体现为权限修饰符。在C#中还有类的修饰，方法的修饰，属性的修饰。

里式替换原则（继承）

里氏替换原则（Liskov Substitution Principle，LSP）由麻省理工学院计算机科学实验室的里斯科夫（Liskov）女士在 1987 年的“面向对象技术的高峰会议”（OOPSLA）上发表的一篇文章《数据抽象和层次》（Data Abstraction and Hierarchy）里提出来的，她提出：继承必须确保超类所拥有的性质在子类中仍然成立（Inheritance should ensure that any property proved about supertype objects also holds for subtype objects）。
里氏替换原则主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中蕴含的原理。里氏替换原是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范。

我的理解：我继承了父类，但是尽量不要重写父类原有已经实现的方法。

依赖倒置原则（接口）

依赖倒置原则（Dependence Inversion Principle，DIP）是 Object Mentor 公司总裁罗伯特·马丁（Robert C.Martin）于 1996 年在 C++ Report 上发表的文章。
依赖倒置原则的原始定义为：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。其核心思想是：要面向接口编程，不要面向实现编程。

我的理解：高层模块不依赖低层模块，都应该依赖其抽象（接口），其实就是面向接口编程。

接口隔离原则（接口）

2002 年罗伯特·C.马丁给“接口隔离原则”的定义是：客户端不应该被迫依赖于它不使用的方法（Clients should not be forced to depend on methods they do not use）。该原则还有另外一个定义：一个类对另一个类的依赖应该建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）。
要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

我的理解：与单一职责类似（但是完全不同），单一职责是约束类的，接口隔离是约束接口的，也就是说一个接口要针对固定的一类功能，不要所有的功能都写在一个接口中冗余。