C#进阶学习笔记（个人整理）

学习笔记

第一章：

一、回顾数组

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 :

检查对象是否是给定类型;

检查对象是否可以转换为给定类型;

而不是对象是某种类型。