C#进阶学习笔记
引言
一个程序就好比一个世界，这个世界是由各种不同的种类组成（人、动物），每种种类的每个个体就是对象......
第一章
一、回顾数组
1、变量 : 只能存储一个数据
2、数组 ：存储固定大小的相同类型的数据
3、对象 : 存储多个相同/不同类型的数据
4、集合 : 特殊的容器，存储N个相同/不同类型的数据
注意：容器中存储的数据是我们要即将处理的数据（内存）
二、工具类
System.Array类 -> 类库
Random -> 产生随机数
Array -> 对数组进行操作
注：
1）调用方法时，注意以下几点：
第一：方法名
第二：参数
第三：返回值（一般用变量接收）
2）在C#中，提供很多的类库，每个类中提供了相关的属性和方法
三、集合
1、概念
集合：特殊的容器，存储N个相同/不同类型的数据
2、分类
非泛型集合类 ：ArrayList、HashTable
泛型集合类 : List、Dictionary
3、装箱与拆箱
装箱 : 基本数据类型 -> 对象类型(object)
拆箱 : 对象类型(object) -> 基本数据类型
注：object是一个特殊的数据类型，可以接收任意类型的数据
4、is运算符
5、泛型：指定集合存放数据的种类
四、常用的集合对象（重点）
1、存储单个元素的集合
1）语法
List<T> 集合名 = new List<T>();
注：T表示的就是泛型，指定集合存储数据的种类
T表示任意的数据类型，也可以是自定义对象类型
2）常用的属性和方法
Count：获取集合大小
Add()：把元素添加到集合的最后位置
Insert(下标,元素)：在指定的下标位置添加元素
Remove(元素)/RemoveAt(下标)：移除集合中的某个元素
Clear()：清空集合中的所有元素
ToArray()：把集合转换为数组
Contains()：查找集合中是否包含某个元素
2、存储键值对的元素
1）语法
Dictionary<K,V> 集合名=new Dictionary<K,V>();
2）常用的属性和方法（作用与List类似）
Count
Add()
Remove()
Clear()
ContainsKey()/ContainsValue()
第二章
一、面向对象的三大特征之继承
1、什么是继承（is-a）
继承是描述的是类与类之间的父子关系
表示父亲的类，叫父类（基类、超类）
表示儿子的类，叫子类（派生类）
2、语法
[访问修饰符] class 子类 : 父类 { 字段 属性 方法（构造方法、静态方法、实例方法、重载方法） }
注：
1）子类也叫派生类、父类也叫基类
2）继承需要符合的关系：is-a
3）子类继承父类的成员（非私有）
同时，子类也可以具有自己特有的成员
成员指的是：属性和方法
4）访问修饰符：控制访问权限
public
private
protected
internal
5）Object类是所有类的父类
C#中所有的类（包括自定义的类），都是直接或间接继承自System.Object类，object 是所有类的父类，因此，可以接收任意类型的数据
6）this与base关键字（难点）
this：当前对象的引用 -> 在类的内部，方法之间的调用
this()：当前对象的构造方法 -> 在类的内部，构造方法之间的调用
base：是一个用来引用继承自父类的成员的引用
base()：父类对象的构造方法 -> 子类的构造方法，调用父类的构造方法
7）子类构造方法默认调用了父类的缺省构造方法
因此，当重载构造方法时，默认构造方法建议显式写出来
8）在C#中，只支持单继承（即子类只能继承一个父类）
错误：
class Student : Man,People
{
}
正确：
class Student : Man {}
class Man : People {}
9）继承具有传递性
10）sealed : 密封
3、继承的优缺点
优点：
1）因为大部分是继承而来的，实现代码重用，减少代码书写量
2）很容易修改和扩展已有的实现
缺点：
1）父类变，子类不得不变
2）继承破坏了封装，父类实现细节暴露给子类
3）继承是一种类与类之间强耦合的关系
第三章
一、面向对象的三大特征之多态
1、定义
多态：同一操作用于不同的对象（类的实例），可以有不同的解释，产生不同的执行结果。
2、分类
1）编译时多态：通过重载方法来实现，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
特点：运行速度快
2）运行时多态：通过虚方法来实现，系统在运行时，才根据实际情况（重写方法）决定实现何种操作。
特点：高度灵活和抽象
对于同一个命令，不同的人会有不同的反应，执行不同的动作；两个或以上不同的对象，调用同一个方法出现不同的结果。
3、运行时多态的三要素
1）继承/实现
2）重写方法：各子类以自己的方式来实现
3）子类实例化父类对象或实现类实例化接口对象
类名 对象名 = new 类名() ;
父类 对象名 = new 子类() ;
4、实现
第一：定义一个父类，在父类中，定义一个虚方法
[访问修饰符] class 父类名称 { //定义虚方法 [访问修饰符] virtual 返回值类型 方法名称([形参列表]) { .... } }
第二：定义相关的子类，在子类中，重写父类的虚方法
[访问修饰符] class 子类名称 : 父类名称 { //重写父类的虚方法 访问修饰符 override 返回值类型 方法名称([形参列表]) { .... } }
第三：子类实例化父类对象
父类 对象名称 = new 子类([实参列表]) ;
说明：
1）使用virtual关键字声明的方法叫虚方法,不能与static、abstract或override修饰符一起使用
2）子类可以使用base重用父类功能，同时扩展新的功能
3）编译时是父类对象，运行时是子类对象
A）可以访问父类非私有的成员
B）不可以访问子类特有的成员
C）必定能访问子类重写父类的虚方法
5、作用
1）应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可，大大提高程序的可复用性。
2）派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。
二、抽象类
1、概念
类是对象的抽象，抽象类是类的抽象
2、语法
[访问修饰符] abstract class 类名 { 1.字段 2.属性 3.方法 （构造方法、静态方法、实例方法、重载方法） 4.抽象方法 ：只有方法头，而没有方法体（没有实现）的方法 }
说明：
1）抽象类不能实例化
2）抽象类中可以包含抽象方法和抽象访问器
3）抽象类不能使用static或sealed关键字
4）抽象类的派生的非抽象类必须实现继承的所有抽象方法和抽象访问器
5）类是对象的抽象，抽象类是类的抽象
6）抽象方法的语法
[访问修饰符] abstract 返回值类型 方法名称([参数列表]) ;
3、抽象类（抽象方法）实现的多态
4、抽象方法 VS 虚方法
1）抽象方法不能有实现；而虚方法可以有实现
2）抽象方法只能在抽象类中定义；虚方法则不是
3）抽象方法所在的类不能实例化对象；而包含虚方法所在的类可以
第四章
一、接口
1、定义
1）接口是行为的抽象，用于赋于对象某些行为
2）通俗地讲，接口就是两个对象相互通信的规则或约束 -> 多态
2、实现
第一：定义一个接口，语法如下：
[访问修饰符] interface I接口名称 [：继承的接口列表] { //1.属性 数据类型 属性名 {set;get;} //2.抽象方法 返回值类型 方法名([参数列表]) ; }
说明：
1）接口可以包含事件、索引器、方法和属性
接口不能包含常量、字段、运算符、实例方法、构造方法、析构函数或类型、不能包含静态成员；接口成员一定是公共的，但不能显式使用访问修饰符。
2）接口与抽象类相同，不能实例化对象
3）实现接口的类有两个情况：
非抽象类：都必须实现接口的所有成员
抽象类：显示声明接口的抽象方法和抽象访问器
4）一个类可以实现多个接口
一个类可以继承一个父类的同时，还可实现一个或多个接口。
5）命名规则：大写并以"I"开始
第二：定义某个类，实现（继承）接口
public class 类名 : 接口[列表] { 1、属性的实现 2、抽象方法的实现 }
注意：成员的实现有显示实现和隐式实现两种方式
1）显示实现
返回值类型 接口名.方法名称([参数列表])
{
...
}
2）隐式实现
public 返回值类型 方法名称([参数列表])
{
...
}
说明：
显示实现不能指定访问修饰符；
一般情况，当类要实现的是单个接口，可以使用隐式实现，隐式实现的成员必须是公有的；
如果类继承了多个接口且接口中具有相同名称成员时，就要用到显式实现；
当显式实现方式存在时，隐式实现方式就失效了；
当显式实现该接口的成员时，实现的成员不能通过类实例访问，只能通过接口实例访问；
当隐式实现该接口的成员时，实现的成员可以通过类实例访问，也可以通过接口实例访问；
不需要override关键字；
第三：使用
1）实现类实例化实现类对象
实现类 对象名 = new 实现类() ;
2）实现类实例化接口对象 -> 多态
接口 对象名称 = new 实现类([实参列表]) ;
接口对象可以访问实现类重写的方法！
注：实现多态的三种形式：
父类 对象名称 = new 子类([实参列表]) ;
抽象类 对象名称 = new 子类([实参列表]) ;
接口 对象名称 = new 实现类([实参列表]) ;
二、抽象类 VS 接口
1）抽象类主要用作对象系统的基类，共享某些主要特性，表示对象是一个什么东西；
2）接口则主要用于类，这些类在基础水平上有所不同（即不同的、不相关的对象），但仍可以完成某些相同的任务，赋于对象具有某一个（或一些）行为；
3）接口是对动作的抽象，抽象类是对根源的抽象；
4）抽象类表示的是，这个对象是什么；接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把"吃东西"定义成一个接口，然后让这些类去实现它，所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。
5）当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
三、两个关键字
1、as
把一个类型转换为指定的引用类型，如果不能转换，则返回null
2、is
检查对象是否是给定类型；
检查对象是否可以转换为给定类型；
而不是对象是某种类型。
结语
抽象：通过一个事物共有的属性和行为抽象成一个类
封装：就是对对象的属性和行为封装起来，通过公开的方法进行访问
继承：is-a关系，子承父类，子类继承了父类的非私有方法，子类可以重写父类方法，继承一个父类是为了保证类的纯洁性
