面向对象
面向对象三大特征：封装、继承、多态
封装：类对外部提供public方法，调用者不用关心类内部的运行机制
继承：子类继承自父类，子类可以继承父类所有非private成员，实现代码重用；
多态：子类中可以覆盖（override）父类中的virtual方法；父类类型的变量可以指向子类类型的对象，调用的方法如果子类override了，则调用的是子类的实现（一个方法在不同环境下不同的表现形态）。
一、封装
1.封装的具体表现
（1）属性封装字段
public class Person { private int _id = -1; public int Id { get { return _id; } set { _id = value; } } }
对内部使用的字段是_id，外部使用的是Id属性。对属性名称进行修改，不需要修改_id名称。
（2）方法的多个参数封装成一个对象
（3）将一堆代码封装到一个方法中
（4）将一些功能封装到一个类中
（5）将一些具有相同功能的代码封装到一个程序集中（dll、exe），并且对外提供统一的访问接口（方法名、属性名等）
二、继承（类与类之间的关系）：一个类继承另一个类，那么这个类也就有了另一个类的非private成员
1.判断一个继承是否合理？（子类 is a 父类）
比如：香蕉是水果吗？是。香蕉类继承水果类
2.继承的好处
（1）代码重用
（2）多态
里氏替换原则：需要一个父类类型时，给一个子类对象是可以的。
里氏替换原则就是为了多态=>多态就是为了增加程序的可扩展性，灵活性。
public class Person { public int Id { get; set; } public string Name { get; set; } } public class Student:Person { public string StuId { get; set; } } 调用部分： Person p1 = new Student();
因为有了继承，便有了里氏替换原则，有了里氏替换原则，便有了多态
3.继承中的构造函数问题
public class Person { public Person(int id,string name) { this.Id = id; this.Name = name; } public int Id { get; set; } public string Name { get; set; } } public class Student:Person { public string StuId { get; set; } public Student(int id, string name, string stuid) { this.Id = id; this.Name = name; this.StuId = stuid; } }
当一个子类继承父类以后，该子类中的所有构造函数默认情况下，在自己被调用之前都会先调用一次父类的无参构造函数，如果此时父类中没有无参的构造函数，则提示报错！
解决方法一：在父类中添加一个无参构造函数
解决方法二：在子类的构造函数后面通过:base()的方式，明确指定要调用父类中的那个构造函数。
public class Person { public Person(int id,string name) { this.Id = id; this.Name = name; } public int Id { get; set; } public string Name { get; set; } } public class Student:Person { public string StuId { get; set; } public Student(int id, string name, string stuid):base(id,name) { this.StuId = stuid; } }
:base()表示调用父类的构造函数
三、多态
1.多态的三种表现形态
（1）虚方法
（2）继承
（3）接口
2.多态实行开放封闭原则：对修改封闭，对扩展开放
3.多态的作用：把不同的子类对象当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
4.实现多态的三种方法的区别：
（1）虚方法是实例类，具有默认实现
（2）抽象方法没有默认实现，除非子类也是一个抽象类
（3）接口存在是为了解决：
1.类的多继承问题
2.类继承以后体积庞大的问题
四、接口
接口是一种规范、协议。约定好遵守某种规范就可以写通用的代码了。
接口存在的意义就是为了多态
接口的存在解决了：
（1）类的单继承问题
（2）类继承以后体积庞大的问题
1.接口里面只能包含方法：
（1）方法
（2）属性
（3）索引器
（4）事件
因为属性，索引器，事件本质上都是方法。【字段不能定义在接口中】
2.接口中的所有成员都不能显示的写任何访问修饰符，默认是public的访问修饰符
3.方法，属性，索引器在接口中的定义方式
public interface DefinitionInterface { /// <summary> /// 定义方法 /// </summary> void SayHello(); /// <summary> /// 定义返回值是string类型的方法 /// </summary> /// <returns></returns> string Eat(); /// <summary> /// 定义属性 /// </summary> string Name { get; set; } /// <summary> /// 定义索引器 /// </summary> /// <param name="index"></param> /// <returns></returns> string this[int index] { get; set; } }
4.接口不能被实例化，就是为了让子类来实现的
5.接口中的成员，子类必须实现
五、虚方法与抽象方法
1.虚方法
（1）具有父子类关系
（2）父类需要重写的方法添加virtual
（3）子类重写的方法添加override
class Program { static void Main(string[] args) { Person p1 = new Student(); p1.SayHello(); Console.ReadKey(); } } public class Person { public string Name { get; set; } public virtual void SayHello() { Console.WriteLine("人类说Hello"); } } public class Student:Person { public override void SayHello() { Console.WriteLine("学生说Hello"); } }
Student类重写了子类的SayHello方法，那么在调用p1.SayHello();方法时就会调用重写的方法
2.抽象方法
（1）抽象类中可以有实例成员，也可以有抽象成员
（2）抽象成员必须包含在抽象类中
（3）抽象成员不能有任何实现
（4）抽象类不能用来实例化对象，只能被继承
（5）抽象成员子类继承以后必须重写override，除非子类也是一个抽象类
public abstract class Person { public string Name { get; set; } public abstract void SayHello(); } public class Student:Person { public override void SayHello() { Console.WriteLine("Student类重写Person类"); } }
虚方法和抽象方法的区别：
（1）虚方法有默认实现，抽象方法没有默认实现。
（2）如果虚方法不重写，那么就调用父类的方法；抽象方法中子类必须实现抽象方法，除非子类也是一个抽象方法。
六、静态类
1.静态类的特点
（1）静态类中只能有静态成员。
（2）静态成员不是必须写在静态类中。
（3）在程序中的任何一个地方访问该静态成员，其实都访问的是同一块内存。
（4）静态成员的数据直到程序退出以后才释放资源；实例对象只要使用完毕就可以执行垃圾回收了。
2.静态类和静态成员要使用static修饰
3.静态构造函数
（1）类中的静态成员，在第一次使用静态成员的时候进行初始化
（2）静态构造函数不能手动来调用，而是在第一次使用静态
七、访问修饰符
1.访问修饰符
（1）private 只能在当前类的内部可以访问
（2）protected 只能在当前类内部以及所有子类的内部可以访问
（3）internal 在当前程序集内部访问
（4）public 任何地方都可以访问
2.命名空间中的访问修饰符只能是public或internal，不能是其他访问修饰符（类不加访问修饰符默认是internal）
3.类的成员变量，如果不写访问修饰符默认是private
4.访问级别约束：
（1）子类的访问级别不能比父类的高（会暴露父类的成员）
（2）类中属性或字段的访问级别不能比所对应的类型访问级别高
（3）方法的访问级别不能比方法的参数和返回值的访问级别高