学习笔记
第一章：
一、回顾数组
1、变量 : 只能存储一个数据
2、数组 ：存储固定大小的相同类型的数据
3、对象 : 存储多个相同/不同类型的数据
4、集合 : 特殊的容器，存储N个相同/不同类型的数据
注意：容器中存储的数据是我们要即将处理的数据（内存）
课堂练习 -> 查看笔记
定义一个数组，初始化10个整数，计算最大值和总和！
二、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() : 查找集合中是否包含某个元素
课堂练习：
创建一个集合，用于存储5个字符串
1)输出其长度和所有的内容
2)判断这个字符串中，是否包含"好好学习"
创建一个集合，用于存储3个学生对象(姓名、年龄)
1)输出集合中所有学生的信息（姓名、年龄）
2)计算集合中所有学生的平均年龄
使用集合，实现手机通讯录功能
联系人 : 姓名、电话、地址
手机 :
添加联系人
删除联系人
修改联系人
查找全部联系人
查找联系人
注：
手机 : 联系人 -> 1:N
2、存储键值对的元素
1）语法
Dictionary<K,V> 集合名=new Dictionary<K,V>();
2）常用的属性和方法
Count
Add()
Remove()
Clear()
ContainsKey()/ContainsValue()
第二章：
一、面向对象的三大特征
封装、继承、多态
二、继承
1、什么是继承
继承是描述的是类与类之间的父子关系。
表示父亲的类，叫父类（基类、超类）
表示儿子的类，叫子类（派生类）
课堂练习：创建三个类，分别是人、学生、老师
在三个类中分别定义两个属性：姓名、年龄
在三个类中分别定义两个方法：吃、拉
创建对象，测试
学生 is-a 人
老师 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 : 密封
三、继承的优缺点
1、优点：
1）因为大部分是继承而来的，实现代码重用，减少代码书写量；
2）很容易修改和扩展已有的实现
2、缺点：
1）父类变，子类不得不变
2）继承破坏了封装，父类实现细节暴露给子类
3）继承是一种类与类之间强耦合的关系
第三章：
一、面向对象的三大特征
封装、继承、多态
二、多态
1、定义
多态：同一操作用于不同的对象（类的实例），
可以有不同的解释，
产生不同的执行结果。
2、分类
1）编译时多态：通过重载方法来实现，
系统在编译时，根据传递的参数、
返回的类型等信息决定实现何种操作。
特点：运行速度快
2)运行时多态:通过虚方法来实现，系统在运行时，才根据实际情况（重写方法）决定实现何种操作。
特点：高度灵活和抽象
EG:
小孩、运动员、演员 -> play
理发师、外科医生、演员 -> cut
对于同一个命令，不同的人会有不同的反应，执行不同的动作；
两个或以上不同的对象，调用同一个方法出现不同的结果。
3、运行时多态的三要素
1）继承/实现
2）重写方法：各子类以自己的方式来实现
3）子类实例化父类对象或实现类实例化接口对象
类名 对象名 = new 类名() ;
父类 对象名 = new 子类() ;
三、实现
第一：定义一个父类，在父类中，定义一个虚方法
[访问修饰符] class 父类名称
{
//定义虚方法
[访问修饰符] virtual 返回值类型 方法名称([形参列表])
{
....
}
}
第二：定义相关的子类，在子类中，重写父类的虚方法
[访问修饰符] class 子类名称 : 父类名称
{
//重写父类的虚方法
访问修饰符 override 返回值类型 方法名称([形参列表])
{
....
}
}
第三：子类实例化父类对象
父类 对象名称 = new 子类([实参列表]) ;
说明：
1）使用virtual关键字声明的方法叫虚方法,不能与static、abstract或override修饰符一起使用
2）子类可以使用base重用父类功能，同时扩展新的功能
3）编译时是父类对象，运行时是子类对象
A）可以访问父类非私有的成员
B）不可以访问子类特有的成员
C）必定能访问子类重写父类的虚方法
课堂练习
英语老师、体育老师、DotNet老师 ： 教
教务老师 : 分配老师上课
public void FenPei(英语老师 t)
{
Console.WriteLine("安排上课") ;
t.教() ;
}
乐器：小提琴、钢琴、二胡...,不同乐器发出不同的声音
音乐家：演奏时，使用各种乐器
獵物 : 鳥、土猪、老虎... -> 跑
獵人 : 打獵
四、作用
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、as : 把一个类型转换为指定的引用类型，如果不能转换，则返回null
2、is :
检查对象是否是给定类型;
检查对象是否可以转换为给定类型;
而不是对象是某种类型。