C#面向对象程序设计知识点汇集

.

C#面向对象程序设计知识点汇集

第一章：C#入门

1．namespace关键字

namespace即命名空间，是定义命名空间的关键字，命名空间包含类，是类的组织方式。

namespace 命名空间名

{

…//类的定义

}

2．using关键字

using关键字用于导入命名空间

using命名空间名；

3．class关键字

class即类，是定义类的关键字。C#中必须用类来组织程序的变量和方法。

4．Main()方法

C#程序必须且只能包含一个Main()方法，它是程序的入口点。

static void Main(string[] args){}

static void Main(){}

static int Main(string[] args){}

static int Main(){}

5．行输出方法

语句“ine("Hello .NET!");”的功能是向显示屏输出双引号之间的字符串。语

句“ne();”的功能是输入一个字符串

6．C#程序结构

C#程序的组成要素如下：

1) 命名空间：命名空间包含一个或多个类。

2) 类。

3) 方法：方法必须包含在某一个类中，作为类的一个成员，每个程序有且仅有一个Main()

方法。

4) 语句：语句是C#应用程序中执行操作的命令。C#中的语句必须用分号“;”结束。

5) 关键字：关键字也叫保留字，是对C#有特定意义的字符串。

6) 大括号：在C#中，括号“{”和“}”是一种范围标志，表示代码层次的一种方式。

7．C#程序书写格式

1)缩进

2) 字母大小写

C#是大小写敏感的语言，它把同一字母的大小写当 作两个不同的字符对待 。

3) 程序注释

(1) 单行注释，以双斜线“//”开始，一直到本行尾部，均为注释内容。

(2) 多行注释，以“/*”开始，以“*/”结束，可以注释多行，也可以注释一行代码中间

的一部分，比较灵活。

(3) 文档注释，使用“///”，若有多行文档注释，每一行都用“///”开头。

8．Console类

Console类是System命名空间中预定义的一个类，用于实现控制台的基本输入输出。

.

.

方法名称

Read()

ReadLine()

接受参数

无

无

返回值类型

int

string

功能

从输入流读入下一个字符

从输入流读入一行文本，直到换行符

结束

输出一行文本Write()stringvoid

WriteLine()stringvoid输出一行文本，并在结尾处自动换行

 编写一个控制台应用程序，输入字符串“I love this game!”,在屏幕上输出。

using System;

 using c;

 using ;

 namespace

 {

 class Program

 { static void Main(string[] args)

 {

 ine("I love this Game!");

 }

 }

 }

相关知识及注意事项

1．对象、类、属性和方法

1) 类和对象

2) 属性

每个对象都有自己的特征和行为，对象的静态特征称为对象的属性

3) 方法

方法是对象的行为特征，是一段可以完成特定功能的代码

2．事件和事件驱动

事件就是预先定义好的、能被对象识别的动作。

通过随时响应用户或系统触发的事件，并做出相应响应的机制就叫做事件驱动机制。

3．窗体对象

4．控件对象

1) 按钮控件

按钮(Button)控件用于接收用户的操作信息，激发相应的事件，按钮是用户与程序交互

的主要方法之一。

2) 文本框控件

文本框(TextBox)控件用于获取用户输入的信息或向用户显示文本信息，图1.17用于显

示信息的白色框就是文本框

.

.

5．控件的基本操作

有两种方法：第一种是按住Shift键或Ctrl键不放，然后单击每个要选择的控件；第二种

是把光标移到窗体中的适当位置，然后拖动鼠标画出一个矩形，选中矩形内的控件(包括边

线所经过的控件)。

1．填空题

(1) .NET 框架具有两个主要组件：____________________和____________________ 。

(2) 使用开发的每一个应用程序称为__________ ，它可以包括一个或多个

__________ 。

(3) 命名空间是类的组织方式，C#提供了关键字__________来声明命名空间，提供了关键字

____________________来导入命名空间；如果要使用某个命名空间中的类，还需要添加对该

命名空间所在__________ 的引用。

(4) C#语言程序必须包含并且只能包含一个的方法(函数)是__________，它是程序的入 口

点。

(5) C#程序中的语句必须以__________作为语句结束符。

(6) Console 类是System 命名空间中的一个类，用于实现控制台的基本输入输出，该类中有

两个常用的方法，一个是功能为“输出一行文本”的方法____________________，另一个是功

能为“输入一行文本”的方法____________________ 。

2.选择题

(1) 下面__________是C#中的单行注释。

A．/*注释内容*/ B．//注释内容

C．///注释内容 D ．Note 注释内容

(2) C#中以__________作为源文件的扩展名。

A．.c B．.cpp C．.cs D．.exe

(3) 关于C#程序书写格式，以下说法错误的是___.

A．缩进在程序中是必须的

B．C#是大小写敏感的语言，它把同一字母的大小写当作两个不同的字符对待

C．注释是给程序员看的，不会被编译，也不会生成可执行代码

D．在C#中，大括号“{”和“}”是一种范围标志，大括号可以嵌套

3.简答题

(1) 简述C#程序的组成要素。

答：C#程序的组成要素如下：命名空间、类、方法、语句、关键字、大括号 “{”和“}”。

(2) 简述Windows应用程序编程步骤。

答：在中开发Windows窗体应用程序的步骤如下：

新建项目；

设计程序界面，包括添加控件和设置控件属性；

编写代码；

保存程序；

运行调试程序。

(3) 简述对事件驱动机制的理解。

答：当用户或系统触发事件时，对象就会响应事件，实现特定的功能，这种通过随时响

应用户或系统触发的事件，并做出相应响应的机制就叫做事件驱动机制。响应事件时执行的

代码称为事件处理程序。开发应用程序时编程人员的主要工作之一就是针对控件可能被触发

的事件设计适当的事件处理程序。

.

.

第二章：C#语法基础

1．常量与变量

有的量在过程中不起变化，就把其称为常量；

有的量在过程中是变化的，也就是可以取不同的数值，就把其称为变量。

在C#中程序设计人员可以根据程序设计的需要，给存放常量和变量的内存地址取一个有

意义的名字，分别叫做常量名和变量名。

可以通过const关键字来定义常量，语法如下：

const 数据类型标识符 常量名=数值或表达式；

说明

(1) 一旦定义常量，就要赋初值，且这个常量的值在程序运行过程中是不允许改变的。

(2) 定义常量时，表达式中的运算符对象只允许出项常量和常数，不允许出现变量。

（3）不论常量和变量，都必须先定义后使用。

变量的定义和赋值语法如下：

数据类型标识符 变量名[=数值或表达式]；

说明：

(1) 语法中的[ ]表示可选，就是说[ ]中的内容写或不写都不会导致语法错误。

(2) 在对变量进行赋值时，数值或表达式的值类型必须同变量的类型相同。

2．C#变量命名规则

为变量起名时要遵守C#语言的规定。

(1) 变量名必须以字母开头。

(2) 变量名只能由字母、数字和下划线组成，而不能包含空格、标点符号、运算符等其他符

号。

(3) 变量名不能与C#中的关键字名称相同。

(4) 变量名不能与C#中的库函数名称相同。

(5) 允许在变量名前加前缀“@”。

说明：可以使用前缀“@”加上关键字作为变量的名称。这主要是为了与其他语言进行交

互时避免冲突。因为前缀“@”实际上并不是名称的一部分，其他的编程语言就会把它作为一

个普通的变量名。在其他情况下，不推荐使用前缀“@”作为变量名的一部分。

3．变量的定义和赋值语法如下：

数据类型标识符 变量名[=数值或表达式]；

说明：

(1) 语法中的[ ]表示可选，就是说[ ]中的内容写或不写都不会导致语法错误。

(2) 在对变量进行赋值时，数值或表达式的值类型必须同变量的类型相同。

如果数值或表达式的值类型与变量的类型不相同，但数值或表达式的值类型所表示

的数值范围比被赋值变量的类型所表示的范围要小，是允许赋值的。事实上C#在内部进行

了一次数值类型的转换，这种转换叫隐式转换。关于数据类型和隐式转换将在后面讲述。

数值类型包括：

整数类型、字符类型、浮点数类型、布尔类型、结构类型、枚举类型。

引用类型包括：

类类型(如string类)、数组类型、接口类型、代理类型。

.

.

C#的数据类型体系如图所示。

整

数值类型

简单类型

其它类型

4．整数类型

C#有8种整数类型：

(1)短字节型(sbyte)有符号8位整数

(2)字节型(byte)无符号8位整数

(3)短整型(short)有符号16位整数

(4)无符号短整型(ushort)无符号16位整数

(5)整型(int)有符号32位整数

(6)无符号整型(uint) 无符号32位整数

(7)长整型(long)有符号64位整数

(8)无符号长整型(ulong)无符号64位整数

型

sbyte, byte

short, ushort

int, uint

long, ulong

float

double

decimal

浮点型

char

string

bool

.

.

5．浮点数类型

C#支持3种基本浮点数：

(1)表示单精度的float,精度7位

(2)表示双精度的double，精度15-16位

(3)表示财务计算用途的decimal，精度29位

在程序中书写一个十进制的数值常数时，C#默认按照如下方法判断一个数值常数属于哪种

C#数值类型。

(1) 如果一个数值常数不带小数点，如3456，则这个常数的类型是个整数。

(2) 对于一个属于整型的数值常数，C#按如下顺序判断该数的类型：int，uint，long，ulong。

(3) 如果一个数值常数带小数点，如1.2，则该常数的类型是浮点型中的double类型。

可以通过在数值常数后加后缀的方法来指定数值常数的类型。

(1) u(或U)后缀：加在整型常数后面，代表该常数是uint类型或ulong类型，具 体哪种，

由常数的实际值决定。C#优先匹配uint类型。

(2) l(或L)后缀：加在整型常数后面，代表该常数是long类型或ulong类型， 具体哪种，

由常数的实际值决定。C#优先匹配long类型。

(3) ul(或uL、Ul、UL、lu、lU、LU)后缀：加在整型常数后面，代表该常数是ulong类

型。

(4) f(或F)后缀：加在任何一个数值常数后面，代表该常数是float类型。

(5) d(或D)后缀：加在任何一个数值常数后面，代表该常数是double类型。

(6) m(或M)后缀：加在任何一个数值常数后面，代表该常数是decimal类型。

如果所指定的数据符号不能用指定类型表示，在编译时会产生错误。

当用两种浮点型执行运算时，可以产生以下的值：正零和负零、+Infinity和-Infinity(正

无穷大或负无穷大)、NaN(非数字值Not-a-Number)。

6．字符类型

用来表示字符数据常量时，共有以下几种不同的表示方式。

(1) 用单引号将单一个字符包括起来，例如：'A'、'n'、'u'。

(2) 用原来的数值编码来表示字符数据常量，例如：'a'是97，'v'是118。

(3) 还可以直接通过十进制转义符(前缀x)或Unicode表示法(前缀u)表示字符数据常量，

例如：'x0032'、'u5495'。

(4) C#提供了转义符，用来在程序中指代特殊的控制字符 ：(见p36）

’ r

’’ 0 t

7．字符串类型

字符串类型是一个char类型的序列。

定义一个字符串的语法如下：

string 变量名[="字符串值"];

例： string str;

string str=“c#”;

string str=ne( );

8．布尔类型

布尔类型数据用于表示逻辑真和逻辑假，布尔类型的类型标识符是bool。

布尔类型只有两个值：true和false。

通常占用1个字节的存储空间

布尔类型还有一个特点：不能进行数据类型转换。

.

.

9．枚举类型

枚举类型是一种用户自定义的数值类型，它提供了一种简便可以创建一组有结构的符号

来表示常量值，有助于程序设计人员更好地调试和维护程序。

1) 枚举类型的定义

枚举定义用于定义新的枚举类型。枚举声明以关键字enum开始，然后定义枚举的名称、

可访问性、基类型和成员。

语法如下：

[访问修饰符] enum 枚举标识名[:枚举基类型]默认的基类型为int

{枚举成员[=整型常数]，[枚举成员[=整型常数],…]}[；] 枚举成员不能同名

2) 枚举成员的赋值

在定义的枚举类型中，每一个枚举成员都有一个常量值与其对应，默认情况下枚举的基

类型为int，而且规定第一个枚举成员的取值为0，它后面的每一个枚举成员的值加1递增。

(1) 如果某一枚举成员赋值了，那么枚举成员的值就以赋的值为准。在它后面的每一个

枚举成员的值加1递增，直到下一个赋值枚举成员出现为止。

(2) 每个枚举成员都有一个关联的常量值。该值的类型是包含该值的枚举的基类型。每

个枚举成员的常量值必须在该枚举的基类型的范围内。

(3) 多个枚举成员可以共享相同的常量值。

3) 枚举成员的访问

在C#中可以通过枚举名和枚举变量这两种方式来访问枚举成员。

(1) 通过枚举名访问枚举成员的形式如下：

枚举名. 枚举成员；

(2) 在通过枚举变量访问枚举成员之前，首先要定义一个枚举类型变量。语法如下：

枚举类型名 变量名；

然后再通过枚举变量访问枚举成员，语法如下：

枚举变量名.枚举成员

10．结构类型

结构类型也是一种用户自定义的数值类型，它是指一组由各种不同数据类型的相关数据

信息组合在一起而形成的组合类型。把一系列相关的变量组织成为一个单一实体的过程，称

为生成结构的过程。这个单一实体的类型就叫做结构类型。

1) 结构的定义

结构的定义语法如下：

[访问修饰符] struct 结构标识名 [：基接口名列表]

{

//结构成员定义

}

说明：

(1) 结构成员包括各种数据类型的变量、构造函数、方法、属性、索引器。

(2) 结构可以实现接口。

 举例1：结构的定义

 struct judge

 { string name;

 float score;

 }

.

.

2) 结构类型成员的访问

用结构变量访问结构成员。在通过结构变量访问结构成员之前首先要定义一个结构类型变

量。语法如下：

结构类型名 变量名；

然后再通过结构变量访问结构成员，语法如下：

结构变量名.结构成员；

 举例2：结构类型变量的定义

 judge judge1;

 judge1. name=ne( );

3) 结构与类的区别

(1) 两者的类型不同，结构是数值类型，类是引用类型。

(2) 结构的静态字段可以初始化，结构实例字段声明还是不能使用初始值设定项，而类

都可以。

(3) 结构不能声明默认构造函数(没有参数的构造函数)或析构函数，也就是说结构可以声

明构造函数，但它们必须带参数，而类都可以。

(4) 结构的实例化可以不使用new运算符，而类都不可以而类的实例化都必须使用new

运算符 。

(5) 一个结构不能从另一个结构或类继承，而且不能作为一个类的基。所有结构都直接

继承自 ype，而类继承自。(ValueType派生自Object，最终基类

都是Object。)

如何选择使用结构还是类，可以参照以下几点。

(1) 堆栈的空间有限，对于大量的逻辑的对象，创建类要比创建结构好一些 。

(2) 结构表示如点、矩形和颜色这样的轻量对象，例如

(3) 在表现抽象和多级别的对象层次时，类是最好的选择。

(4) 大多数情况下该类型只是一些数据时，结构是最佳的选择 。

11．类型转换

在程序设计中，有时要进行数据类型的相互转换，如被赋值的变量或方法的形式参数的

类型与实际的对象类型不同，就需要进行类型转换。 C#中有两种转化方式：隐式转换和显

示转换。当发生类型转换时，被赋值的变量或方法的形参的类型称为目标类型，而实际对象

的类型称为源类型。

1)隐式转换

当发生类型转换时，如果在代码中没有明确指定目标类型，则称为隐式转换。也就是说隐

式转换是系统默认的、不需要加以声明就可以进行的转换。在隐式转换过程中，编译器不需

要对转换进行详细的检查就能安全地执行转换。

小类型->大类型

安全的转换（不会丢失数据）

系统自动完成

注意：

(1)从 int、uint 或 long 到 float 的转换以及从 long 到 double 的转换的精度可能会降低，

但数值大小不受影响。

(2)不存在到 char 类型的隐式转换。

(3)不存在浮点型与 decimal 类型之间的隐式转换。

.

.

2) 显式转换

当发生类型转换时，如果在代码中明确指定目标类型，则称为显式转换。显式转换也称

为强制型转换，一般在不存在该类型的隐式转换时才使用。

语法格式如下：

(类型标识符)表达式

这样就可以将表达式的值的数据类型转换为类型标识符的类型。

例如：(int)6.143 //把float类型的6.143转换为int类型

大类型->小类型

不安全的转换（可能丢失数据）

显式声明

.

.

3) 负责数据类型转换的Convert类

Convert类用于将一个基本数据类型转换为另一个基本数据类型，返回与指定类型的值等

效的类型；

受支持的源类型是Boolean、Char、SByte、Byte、Int16、Int32、Int64、UInt16、UInt32、

UInt64、Single、Double、Decimal、DateTime和String。。

属于显示转换

常用于不同类型之间的数据转换

(1) 从某数据类型到它本身的转换只返回该数据类型，不实际执行任何转换。

(2) 无法产生有意义的结果的转换引发InvalidCastException(指定的转换无效)的异常，不

实际执行任何转换。下列转换会引发异常：从Char转换为Boolean、Single、Double、Decimal

或DateTime，以及从这些类型转换为Char；还有从DateTime转换为除String之外的任何类

型，以及从任何类型(String除外)转换为DateTime。

(3) 任何数据类型(上面描述的数据类型除外)都可以与任何其他数据类型进行相互转换。

4) 数据类型转换的Parse()方法

每个数值数据类型都包含一个Parse()方法，它允许将字符串转换成对应的数值类型。

例如：

string s1=9，s2=9.423;

int m=(s1); //将s1转换成整数类型

Float n=(s2);//将s2转换成浮点类型

 Random类中next方法的使用

例子：

Random rd=new Random();

int n=(100,500)

这样N就是一个100到500之间的一个随机数。

Math类中sqrt方法的使用

（ 常量、变量或表达式 ）；

返回指定数字的平方根。

运算符是表示各种不同运算的符号。表达式是由变量、常量、数值和运算符组成的，是用运

算符将运算对象连接起来的运算式。表达式在经过一系列运算后得到的结果就是表达式的结

果，结果的类型是由参加运算的操作数据的数据类型决定的。

C#语言中有丰富的运算符。在C#中运算符的种类分为以下几类。

1．算术运算符

算术运算符用于各类数值运算，包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、

自增(++)、自减(--)共7种。

其中%是求余运算，例如：“x=7%3”，则x的值为1，因为7/3的余数为1。

由算术运算符将运算对象连接起来的式子叫做算术表达式。有一些特殊的运算，例如开

方、平方，C#没有提供相应的算术运算符。但在System命名空间里的Math类提供了这样

的运算。

常用的方法有以下几种。

(1) (数据类型 x)：返回x的绝对值。

(2) (double x，double y)：返回x的y次方。

(3) (double x)：返回x的开根号值。

还有一种产生随机数的Random类，它的方法要用Random类的对象来调用。

.

.

常用的方法有以下几种。

(1) Next()：返回一个整数的随机数。

(2) Next(int maxvalue)：返回小于指定最大值的正随机数。

(3) Next(int minvalue，int maxvalue)：返回一个大于等于minvalue且小于 maxvalue的整数

随机数。

(4) NextDouble()：返回一个0.0～1.0之间的double精度的浮点随机数。

2．关系运算符

关系运算符用于比较运算，比较两个值的大小。关系运算符包括大于(>)、小于(<)、等于

(= =)、大于等于(>=)、小于等于(<=)和不等于(!=)6种。

关系运算的结果类型是布尔类型。如果关系运算两边的运算对象是布尔类型的对象，那

么true等于true，false等于false，而true是大于false的。

由关系运算符将运算对象(表达式)连接起来的式子叫做关系表达式。

3．逻辑运算符

逻辑运算符用于逻辑运算，包括与(&&)、或(||)、非(!)共3种。

逻辑运算的结果类型是布尔类型，而且逻辑运算两边的运算对象的数据类型都为布尔类

型。

与运算的结果为：只有两个运算对象都为true时，结果才为true；只要有一个是false，

结果就为false。

或运算的结果为：两个运算对象中只要有一个为true时，结果就为true；只有两个运算

对象都是false，结果才为false。

非运算的结果是原运算对象的逆：如果原运算对象是true，则运算结果为false；如果原

运算对象是false，则运算结果为true。

由逻辑运算符将运算对象(逻辑值或表达式)连接起来的式子叫做逻辑表达式。

4．位操作运算符

参与位操作运算的量，按二进制位进行运算。位操作运算符包括位非(

～)、位与(&)、位或(|)、位异或(^)、左移(<<)、右移(>>)共6种。

1) 位逻辑非运算

位逻辑非运算是单目的，只有一个运算对象。位逻辑非运算按位对运算

对象的值进行非运算，即：如果某一位等于0，就将其转变为1；如果某一位

等于1，就将其转变为0。

例如，对二进制的10010001进行位逻辑非运算，结果等于01101110，

用十进制表示就是～145等于110；对二进制的01010101进行位逻辑非运算

，结果等于10101010。用十进制表示就是～85等于176。

2) 位逻辑与运算

位逻辑与运算是将两个运算对象按位进行与运算。与运算的规则是：1

与1等于1，1与0等于0。例如，10010001(二进制)&11110000等于

10010000(二进制)。

3) 位逻辑或运算

位逻辑或运算是将两个运算对象按位进行或运算。或运算的规则是：1或1等1，1

或0等于1，0或0等于0。例如，10010001(二进)|11110000(二进制)等于11110001(二进制)。

4) 位逻辑异或运算

位逻辑异或运算是将两个运算对象按位进行异或运算。异或运算的规则是：1异或1

等于0，1异或0等于1，0异或0等于0。即：相同得0，相异得1。

例如，10010001(二进制)^11110000(二进制)等于01100001(二进制)。

.

.

5) 位左移运算

位左移运算是将整个数按位左移若干位，左移后空出的部分填0。例如，8位的byte型

变量byte a=0x65(即二进制的01100101)，将其左移3位(a<<3)的结果是0x27(即二进制的

00101000)

6) 位右移运算

位右移运算将整个数按位右移若干位，右移后空出的部分填0。

例如，8位的byte型变量byte a= 0x65(即二进制的01100101)将

其右移3位(a>>3)的结果是0x0c(即二进制的00001100)。

5．赋值运算符

赋值运算符用于赋值运算，就是将一个数据赋予一个变量，它分为3类:

(1)简单赋值(=)、

(2)复合算术赋值(+=，-=，*=，/=，%=)

(3)复合位运算赋值(&=，|=，^=，>>=，<<= )共11种。

算术表达式:由赋值运算符将运算对象(变量和表达式)连接起来的式子。

6．条件运算符

条件运算符是一个三目运算符，用于条件求值(?:)。语法如下：

逻辑表达式？ 语句1：语句2；

说明：上述表达式先判断逻辑表达式是true，还是false。如果是true，则执行语句1；如

果是false，则执行语句2。

由条件运算符和表达式组成的式子叫做条件表达式。

7．逗号运算符

用于把若干表达式组合成一个表达式(，)。

8．特殊运算符

有括号( )、下标[ ]等几种。

9．其他转换用运算符

1) as

as运算符用于执行引用类型的显式类型转换。 如果要转换的类型与指定类型兼容，

转换就会成功；如果类型不兼容，则返回null。

语法如下：

表达式as类型

例如：

object o1=”SomeString”;

object o2=5;

string s1=o1 as string; //类型兼容 s1=”SomeString”

string s2=o2 as string; //s2=null

2) is

is运算符用于检查对象的类型是否与给定类型兼容(对象是该类型，或是派生于该类

型)。语法如下：

表达式is类型

例如：

int i=10;

bool x=i is int； //x=true

.

.

3) sizeof

sizeof运算符用于获得值类型的大小(以字节为单位)。语法如下：

sizeof(类型标识符)

说明：sizeof运算符仅适用于值类型，而不适用于引用类型。sizeof运算符仅可用于unsafe

模式。

例如：

unsafe

{ine(“{0}”,sizeof(int));

//结果是4，每个int类型变量占4个字节

}

4) checked和unchecked

checked和unchecked运算符用来控制整数类型算术运算和相互转换的溢出检查。语法

如下：

checked(表达式)

unchecked(表达式)

说明：

checked运算符用来强制编译器检查是否溢出的问题；

unchecked运算符用来强制编译器不检查这方面的问题。

10．运算符的优先级

一个表达式中往往包含多种运算符，那么哪个运算符先执行，哪个运算符后执行呢？

在 C#中，把每个运算符设置成不同的级别来决定运算符执行的先后顺序，这个级别就叫做

运算符的优先级。运算符的优先级高的就优先执行，运算符的优先级低的就后执行。

第3章：c#程序设计

C#程序设计中有三大程序结构，分别为：

顺序结构 选择结构 循环结构

这3种程序结构都是可以嵌套、组合使用的。

顺序结构是由一系列的语句所构成的，其中任何一条语句都会被执行一次，而且执行

的顺序是由程序的第一行一直执行到结束为止。

选择结构可以让程序在执行时能够选择不同的操作，那么选择的标准是根据指定的条

件是否成立而确定的。

C#中有以下几种语句来实现选择结构。

1．if语句

if语句根据条件判断该执行哪个选择，可提供一种、两种或多种选择，但每次只会执行

一个选择。

(1) 简单的if语句，提供一种选择，语法如下：

if (条件) {语句序列}

//当满足条件，就执行{语句序列}，否则跳过if语句，执行if语句后面的程序.

(2) if-else语句，提供两种选择，语法如下：

if (条件)

{语句序列1} //当满足条件时执行

else

{语句序列2} //当不满足条件时执行

.

.

(3) else if语句，提供多种选择，语法如下：

if(条件1)

{语句序列1} //当满足条件1时执行，然后执行else if语句块后面的程序

else if(条件2)

{语句序列2} //当满足条件2时执行，然后执行else if语句块后面的程序

else if(条件3)

{语句序列3} //当满足条件3时执行，然后执行else if语句块后面的程序

… //还可以加任意个“else if(条件){语句序列}”

else

{语句序列n+1} //当所有条件都不满足时执行

2．switch语句

switch语句也是提供多种选择的语句。语法如下：

switch(表达式) if (score >= 90)

{ ine("优秀!");

case 可能性的值1： else if (score >= 80)

语句序列1[break;] ine("良好!");

case可能性的值2： else if (score >= 70)

语句序列2[break;] ine("一般!");

...; else if (score >= 60)

[default: ine("及格!");

语句序列n+1 else

break;] } ine("不合格!");

if (score >= 90) c=‘a’;

else if(score>=80) c=‘b’;

else if(score>=70) c=‘c’;

else if(score>=60) c=‘d’;

else c=‘e’;

switch(c)

{case ‘a’:

ine("优秀!");break;

case ‘b’:

ine("良好!");break;

case ‘c’:

ine("一般!");break;

case ‘d’:

ine("一般!");break;

case ‘e’:

ine("一般!");break;

执行switch语句的步骤为：

（1）当代码执行到此语句时，先执行switch后面( )中的表达式。

（2）然后将表达式的运算结果与{ }中case后面“可能性的值”逐个匹配，如果与某个“可

能性的值”匹配成功，则进入相对应的case代码段，如果匹配都不成功，则进入default语句，

执行默认代码段。

（3）如果没有default语句，则跳出switch语句。

.

.

其中，每个case代码段内都应该带有一个break语句，用来从当前选择中跳出，如果

没有break语句，则不跳出选择，执行case后面的语句。

1．Checked属性

Checked属性是单选按钮、复选框的一个属性，它表示单选按钮、复选框是否被选中。true

表示单选按钮、复选框被选中，false表示未被选中。

2．Enabled属性

Enabled属性允许在运行时使窗体和控件成为有效或无效。有效为true，无效为false。

3．CheckedChanged事件

当Checked属性值改变时，触发CheckedChanged事件。当选中“普通会员”单选按钮时，

就触发了它的CheckedChanged事件，普通会员是不可选择“赠送礼品”的，所以设置“赠送礼

品”复选框的Enabled属性为false。同理当选中“VIP”单选按钮时, 就触发了它的

CheckedChanged事件，VIP是可以选择“赠送礼品”的，所以设置“赠送礼品”复选框的Enabled

属性为true。

循环结构是在给定条件成立时，反复执行某程序段，直到条件不成立为止。给定的条件

称为循环条件，反复执行的程序段称为循环体。

1．while语句

while语句先计算表达式的值，值为true则执行循环体；反复执行上述操作，直到表达式

的值为false时止。

语法如下：

while (表达式)

{

循环体

}

开始

条件表达式

true

循环语句

结束

执行while语句的步骤为：

(1) 执行while后面( )中的表达式；

(2) 当表达式的运算结果为true，则执行循环体，否则跳过步骤(3)，直接执行步骤(4)；

(3) 反复执行(1)、(2)步骤，直到表达式的运算结果为false时止；

(4) 执行while语句块后面的代码。

说明：

(1) while语句中的表达式一般是关系表达式或逻辑表达式，只要表达式的值为true即

可继续循环；

.

.

(2) 应注意循环条件的选择以避免死循环；

(3) 若循环体中又含有“循环语句”，则称为嵌套的循环语句，也称多重循环。

2．do-while语句

do-while语句先执行循环体语句一次，再判别表达式的值，若为true则继续循环，否则

终止循环。

语法如下：

do{

循环体

}while(表达式)；

开始

表达式1

循环语句

true

表达式3

循环体语句

条件表达式

false

结束

非0

表达式2

0

说明：

(1) do-while语句和while语句的区别在于do-while是先执行后判断，因此do-while至

少要执行一次循环体，而while是先判断后执行，如果条件不满足，则一次循环体语句也不

执行；

(2) 在if语句、while语句中，表达式后面都不能加分号，而在 do-while语句的表达式

后面则必须加分号；

(3) do-while语句也可以组成多重循环，而且也可以和while语句相互嵌套。

for语句和while语句一样，也是一种循环语句，用来重复执行一段代码。

两个循环语句的区别就是使用方法不同。

for语句的使用语法如下：

for (表达式1；表达式2；表达式3)

{

循环体

}

执行for语句的步骤为：

(1) 计算表达式1的值；

(2) 计算表达式2的值，若值为true，则执行循环体一次，否则跳出循环；

(3) 计算表达式3的值，转回第(2)步重复执行。

说明：

(1) 表达式1通常用来给循环变量赋初值，一般是赋值表达式。也允许在for语句外给

循环变量赋初值，此时可以省略该表达式。

(2) 表达式2通常是循环条件，一般为关系表达式或逻辑表达式。

.

.

(3) 表达式3通常可用来修改循环变量的值，一般是赋值语句。

(4) 这3个表达式都可以是逗号表达式，即每个表达式都可由多个表达式组成。3个表

达式都是任选项，都可以省略但分号间隔符不能少。

如for(；表达式；表达式)省去了表达式1，for(表达式；；表达式)省去了表达式2，for(表

达式；表达式；)省去了表达式3，for(；；)省去了全部表达式。

(5) 在整个for循环过程中，表达式1只计算一次，表达式2和表达式3则可能计算多

次。循环体可能执行多次，也可能一次都不执行。

2．使用break/continue控制循环

在while和for循环语句中，如果满足条件，则循环会一直继续下去，那么该如何自动控

制循环的中断和继续呢？C#提供了break/continue语句，用来控制循环的执行。

break可以中断当前正在执行的循环，并跳出整个循环。

continue表示中断当前本次的循环，而后面的代码无需执行，并进行下一次表达式的计

算与判断，以决定是否重新开始下一次循环。

break 语句还可以和switch语句配合使用，以在达到某种条件时从switch语句跳出。

break语句语法如下：

break;

continue语句语法如下：

continue;

例：

int n=0,m=0;

for(i=1;i<=10;i++)

{if (i%2==0) continue;

n++;}

for(i=1;i<=10;i++)

{if (i%2==0) continue;

n++;}

第4章： 方法

采用两种方法解决本案例提出的问题。

（1）从现有知识出发解决输出圣诞树问题，不使用方法，把所有的代码都编写在Main中。

（2）使用方法来解决输出圣诞树问题。将使得“打印等腰三角形”这个基本操作一次编写，

多次使用，提高了代码复用率也提高了程序的可读性。

1．使用方法的意义

将一个复杂的程序分解成若干个相对独立的方法，使得程序变得简练并且结构清晰。方

法可以被多次调用，反复执行，这样大大地提高了代码的复用率。另外，程序的分块设计也

便于开发人员的分工合作、便于调试和维护，从而大大提高了编程效率。

2．方法的定义

方法也称为函数，是一组程序代码的有机集合，可以实现一个独立的功能。可以把程序

中多次用到的某个任务定义为方法。

1) 方法的定义

方法的定义格式为：

[修饰符] 返回值类型 方法名([参数列表])

{

.

.

方法体；

[ return(z) ]; //返回结果z

}

2) 方法名

方法名是用户给方法取的名字，可以是任何一个有效的C#标识符。作为编程的良好

习惯，方法的命名应尽量符合以下规则。

[修饰符] 返回值类型 方法名([参数列表])

{

方法体；

[ return(z) ]; //返回结果z

}

3) 方法的参数列表

方法可以接收参数，这实际上是方法与外界“通信”的方式。方法定义时参数列表由

0个、1个或多个参数组成。

4) 方法的返回值类型

方法的返回值就是方法的输出，是一个方法执行完毕后返回给调用者的数据，它可

以是各种数据类型。如果方法没有返回值，应定义为void类型。

[修饰符] 返回值类型 方法名([参数列表])

{

方法体；

[ return(z) ]; //返回结果z

}

5) return语句

方法的返回值由return语句带回，return语句在赋予方法的调用者返回值的同时退

出方法。

6) 方法的修饰符

修饰符用于指定方法的访问权限，有public、private、static等，默认为private。

用static修饰的方法是静态方法。

7) 方法体

用“{”和“}”括起来的若干语句组成方法体。方法体中可以没有任何语句，但大括号

不可以省略。

[修饰符] 返回值类型 方法名([参数列表])

{

方法体；

[ return(z) ]; //返回结果z

}

例：

static int Max(int a,int b)

{int c;

c=a+b;

return c;

}

.

.

3.方法的调用

1) 方法调用时参数的传递

A 主调方法的参数称为实际参数(简称实参)。

B 被调方法的参数称为形式参数(简称形参)。

C 方法调用时实参被传递给对应位置的形参，完成方法的输入。相应地，方法执行结

束时，通过return语句把“产品”返回给主调方法，完成方法的产出。

注意：（1）参数传递时实参与形参必须个数相等，类型一致，按顺序一一对应。

（2）实参可以是常量、变量或表达式子，形参必须是变量。

2) 方法的调用方式

方法有以下3种调用方式。

（1）方法语句。如：printMax(x,y);

(2) 方法表达式。如：z=max(x,y);

(3) 方法参数。如： Max(9,Max(5,11));

3) 方法的调用过程

例：

static void main()

{int x,y,z;

x=(ne());

y=(ne());

z=Max(x,y);

ine(“max={0}”,z);

}

使用进阶

1．方法的嵌套调用

嵌套调用，就是指在调用一个方法的过程中又调用另一个方法

2．求最大公约数的数学方法

3．求最小公倍数的数学方法

.

.

 例：求5！

 using System;

 using c;

 using ;

 namespace Example4_3

 { class Program

 { static int Fact(int n) //求阶乘的方法

 { int f;

 if (n == 1 || n == 0)

 return (1);

 else

 f = Fact(n - 1) * n;

 return f; }

 static void Main() //主方法

 {

 ("请输入n：");

 int n = 32(ne());

 ine("{0}!={1}", n, Fact(n));

 ne(); }

1．方法的递归调用

一个方法直接或者间接调用自己称为递归，同时将该方法称为递归方法。

2．使用递归的条件

一个问题要用递归的方法来解决，需满足以下条件。

(1) 原问题可转化为一个新问题，而这个新问题与原问题有相同的解决方法。

(2) 新问题可继续这种转化，在转化过程中问题有规律地递增或递减。

(3) 在有限次转化后，问题得到解决，即具备递归结束的条件。

3．递归调用的过程

递归调用的过程可分为如下两个阶段。

(1) 第一个阶段称为“回推”。

(2) 第二个阶段称为“递推”。

比较前后两段代码可以看出，区别主要有如下两点。

(1) 定义Swap()方法时，方法头的设计有区别，修改后的代码使用了ref关键字，而修

改前的代码没有使用。

修改前的代码：static void Swap(int a, int b)

修改后的代码：static void Swap(ref int a, ref int b)

(2) 调用Swap()方法时，调用语句有区别，修改后的代码使用了ref关键字，而修改前

的代码没有使用。

修改前的代码：Swap( x, y);

修改后的代码：Swap(ref x, ref y);

1．参数的传值方式

参数以传值方式传递，被调用的方法将接受实参的一个副本，参数传递后，形参和实

参各占不同的内存单元。如果对被调用方法中的实参副本进行修改，不会影响原始实参的值。

.

.

2．参数的传引用方式

1) ref引用参数

参数以传引用方式传递时，形参将不创建新的存储位置，形参和实参共用存储单元，

这时形参相当于它所对应的实参的一个别名，如果在被调用的方法中对形参进行修改，实际

上就是对实参进行了修改，因此当方法调用完毕时，方法中对形参的修改直接影响了实参。

2) out输出参数

除了ref关键字外，C#还提供了out关键字用于参数的引用传递。ref参数必须在方

法被调用前进行赋值，但在实际的应用中，有时仅仅需要调用方法计算出某个结果返回给调

用者，而不需要调用者对这个参数进行初始化。在这种情况下可以使用out参数，out参数

仅用于输出方法的某个结果。

ref参数和out参数比较：ref参数和out参数都可以将参数的更改保留，但ref侧重于修

改，out侧重于输出。

1．为什么需要重载

C#提供了重载机制，允许给多个功能相似的方法取相同的名字，在调用时由系统决定应

该调用哪个方法。

2．什么是方法重载

两个或两个以上的一组方法，如果方法名相同，使用不同的参数列表（参数的个数或类

型或顺序不同）来定义，称为方法重载。

3．系统如何确定该调用哪个方法

调用具有重载的方法时，系统会根据参数个数或者参数类型的不同来区分。具体调用时，

由编译器根据实参和形参的类型及个数的最佳匹配，自动确定调用哪个方法。

第5章 ：类与对象

对象包括：

对象名

一组属性

一组操作(行为）

属性描述对象的静态特征，表示对象的状态，是类的数据成员；

操作(或称方法)描述对象的行为，是对象的动态特征，通常是对数据成员进行操作的方

法，称为成员函数。

现实生活中的对象往往可以根据共性进行归类，一组具有共同特征和行为的相似对象归

为一类。

程序设计中，把一组相似对象的共同特征抽象出来并存储在一起，就形成了类。

从具体对象到类实际上是一个概括的过程，把对象的共同特征抽取出来，形成了类，

如果再对这个类用计算机语言加以描述，就形成了程序中的类，这个过程称为抽象。

.

.

1．封装

封装实际上是在类的设计过程中完成的，类对外部提供统一的接口方法，类的内部相当

于一个黑盒，类的使用者并不知道类的内部实现细节，只要知道怎么调用这些接口方法就够

了。

2．继承

一个类从另一个类获得了已有的基本特征，并在此基础上增加了自身的一些特殊特征。

3．多态

概念：

在面向对象程序设计中，多态是指用户对一个对象进行一个操作，但具体的动作

却取决于这个对象的类型，即对不同的对象执行相同的操作会产生不同的结果。

分类：

分为编译时多态和运行时多态两种。

4．消息通信

对象具有一定的独立性和自治性，但对象和对象之间不是彼此独立的，它们通过消

息进行通信，一个程序可以被看作是对象之间相互作用的结果。

1．类的定义

类定义的一般格式如下：

class <类名>

{

private <私有的字段、方法、属性>

protected <保护的字段、方法、属性>

public <公有的字段、方法、属性>

}

类体中包含字段、方法、属性等成员。其中字段是“存储信息”的成员；方法是用于描述

某类对象共同行为的成员，是“做事情”的成员

 例：定义一个车辆类（有三个变量）

.

.

class Vehicle

 {

 public int passengers; //乘客数

 public int fuelcap; //所耗燃料

public int mpg; //每公里耗油量

 }

2．对象的定义与使用

1) 对象的声明与实例化

类名 对象名； //声明对象

对象名＝ new类名()； //实例化对象

例如，创建一个名为catBobi的猫类对象：

(1) Cat catBobi; catBobi ＝new Cat();

(2) Cat catBobi = new Cat();

2. 对象的定义与使用

2) 对象的使用

一个对象被创建后，就可以通过对象本身来获取对象状态或调用对象行为。

调用对象成员的格式为：

对象名.对象成员

3．类成员的访问修饰符

表5-1 类的成员的访问修饰符及其含义

修

public

private

protected

internal

internal protected

饰符说明

该成员可以被本类及本类以外的所有类访问

该成员只能在本类内部被访问

该成员只能被本类及本类的派生类访问

该成员只能在所在的程序集内部访问

该成员可以在所在的程序集内部或本类的派生

类中被访问

4．类的属性

1) 为什么使用属性

C#提供了一种更有效的访问形式，既能读写字段，同时又保证数据成员能被更好地

隐藏和保护起来呢？那就是使用属性。

.

.

属性是类的一种特殊成员，它具有字段的形式，又具有方法的本质 。

2)怎样定义属性

属性的定义格式为：

修饰符 类型 属性名

{

set { … //写入数据}

get {… //读取数据 }

}

get与set是 C#特有的访问器。

get： 读取访问器，用于从对象读取数据（只读）。

set: 写入访问器，用于向对象写入数据（只写）。

3) 属性的读写控制

属性的get和set访问器并非都是必须的.

如果只有get访问器，该属性只可以读取，不可以写入；

如果只有set访问器，该属性只能写入，不能读取；

如果对只读属性进行赋值，或者读取只写属性的值，都会产生编译错误。

4) 在属性中完成更多的功能

5． IDE使用进阶：

如果已经定义好了字段，想要为字段写一个属性，可以利用的重构功能很方便

地实现。

具体做法：选中要封装的字段定义代码，例如选中“string variety;”，单击鼠标右键，

在弹出的快捷菜单中选择【重构】|【封装字段】命令，在弹出的“封装字段”对话框的“属

性名”文本中已存在一个属性名“Variety”，读者可以默认也可以修改它，单击“确定”按

钮，可以在弹出的“预览引用更改一封装字段”对话框内浏览代码更改，单击“应用”按钮，

一个完整的“Variety”属性定义便出现在对应字段的下一行。

类的成员有实例成员和静态成员之分。

类的实例成员和静态成员最简单的区分方法就是看定义这些成员时是否使用了static修

饰符。

1．静态字段

如果在声明字段时添加了static修饰符，该字段就成为静态字段。静态字段用于存储一

些属于某个类的全部对象的信息，它是被类的全体对象共享的数据。

例如：为Cat类添加一个静态字段count，用于表示当前存在的猫对象总数。

.

.

2．静态属性

为了对外界隐藏数据的同时方便对静态字段的访问，往往需要使用静态属性。

静态属性与静态字段一样不属于任何对象，因此它们不能被对象所调用，而是由类名直

接调用：

类名.静态字段名；

类名.静态属性名；

class Cat

{ …

private static int count;

public static int Count

{

set { count = value; }

get { return count; }

}

…}

3．静态方法

如果在声明方法时添加了static修饰符，该方法就成为静态方法。静态方法属于类，只

能通过类名调用，不能由对象调用。注意：静态方法只能访问静态字段或属性，不能访问实

例字段或属性。而实例方法既可以访问实例字段也可以访问静态字段。

静态方法由类名直接调用：

public static int GetCount() //静态方法

{ return count;}

ine("目前有{0}只猫", nt());

1．构造函数

1) 什么是构造函数

对象在实例化的时候，可以进行数据成员的设置，称为对象的初始化；另外，类有

时也需要做一些初始化工作，这些工作都由构造函数完成。构造函数也称构造方法。

 格式：

 public 构造函数名（参数列表）

 {

 构造函数体

}

 如：









基本特点是：

(1) 构造函数名与类名相同；

(2) 构造函数没有返回值，且函数头部不用写“void”；

(3) 除了在实例化对象时由系统调用以及派生类构造函数调用基类构造函数之外，

其他任何函数都不能调用它。

.

.

2）构造函数的声明与调用

public Cat(string myVariety,string myColor,float myWeight)

{ variety = myVariety;

hairColor = myColor;

weight = myWeight;

birthday = ;

}

用new运算符创建一个对象时，构造函数名后所跟的参数列表就是对象的初始化列

表。

Cat catBobi = new Cat("波斯猫", "白色", 2.3F);

3）构造函数的重载

构造函数可以重载，以方便程序员初始化对象。

public Cat(string myVariety,string myColor, float myWeight)

{ …}

public Cat (float myWeight, string myVariety, string myColor )

{ …}

添加了这些构造函数后，可以在Main()方法中按照如下所示的多种方式创建并初始化

对象：

Cat catBobi = new Cat("波斯猫", "白色", 2.3F);

Cat catBobi = new Cat("波斯猫", 2.3F, "白色");

Cat catBobi = new Cat(2.3F,"波斯猫", "白色");

4）静态构造函数

静态构造函数通常用于对类的静态字段进行初始化。

为Cat类添加静态构造函数对count字段进行初始化。

static Cat()//静态构造函数

{

count = 0;

}

静态构造函数有如下特点：

(1) 仅有一个static修饰符。

(2) 只对静态字段赋初值。

(3) 由系统自动调用，一个类仅调用一次，与创建对象操作无关。

5．析构函数

1) 什么是析构函数

在对象使用结束时，可以进行一些相关的清理工作并释放所占用的内存空间，这个工

作由析构函数完成。析构函数的特点如下：

(1) 析构函数的名称与类名相同，在类名前加“~”；

(2) 析构函数没有返回值，也不能声明为void；

(3) 析构函数只有一个，不能重载；

(4) 析构函数也是类的成员函数。

~Cat()

{

ine("执行了析构函数！");

}

.

.

1．方法的返回值为对象

方法的返回值可以是int、double等系统标准类型，也可以是用户自定义的类型，两

者的用法没什么两样。

2．值类型变量与引用类型变量

C#的数据类型分为两大类：值类型和引用类型。

1) 值类型

简单地说，值类型变量就是一个包含实际数据的量。当定义一个值类型变量时，C#

会根据变量所声明的类型分配一块堆栈存储区域给这个变量，然后对这个变量的读写就直接

在这块内存区域进行。

2) 引用类型

引用类型变量存储的不是它所代表的实际数据，而是该实际数据的引用(地址)。

引用类型变量的赋值只赋值对象的引用，而不复制对象本身。变量num1和num2

共同引用一个对象，对其中任何一个做修改，另一个都会随之改变

3) 对象做方法参数

因为C#的数据类型分为值类型和引用类型，传递参数的方式有传值方式和传引用

方式，组合一下，C#传递参数有4种情况：值类型按传值方式传递，值类型按传引用方式

传递，引用类型按传值方式传递，引用类型按传引用方式传递。

课后习题答案：

1．填空题

(1)类 (3)static ，一个，类名，对象名

(2)读取，写入，写入，读取 (4)构造函数，析构函数

2．选择题

(1)D (2)A (3)B (4)D

3．简答题

(1) 简述类与对象的关系。

答：类是对事物的概括性定义，而对象是事物本身，是类的一个实例(instance)，对象具

有类所规定的特征，只能执行类所规定的操作。打个比方，类就相当于一个模板，而对

象则是由这个模板产生出来的具体产品，一个模板可以生产很多产品，一个类可以产生

很多对象。

(2) 简述属性与字段的区别，属性与方法的区别。

答：属性与字段的区别：属性可用于完成一些控制和计算，程序员可以通过在get和set

访问器中编写适当的代码，实现所需的功能，而字段不能完成计算，只能用于存放数据，

属性不一定和字段一一对应。

属性与方法的区别：方法和属性都能完成计算，属性可以作为一个特殊的方法使用，

但是两者调用方式不同，属性像字段一样被调用，属性名后面没有参数和括号（例如

lor），而方法被调用时方法名后面必须有括号，根据需要还可以有参数列

表。（例如：o("波斯猫", "白色", 2.3F);）

(3) 值类型与引用类型在一般赋值时有什么不同？值类型与引用类型在做函数参数时有

什么不同？在传值方式下(即没有使用ref或out时)，它们默认传递的分别是什么，变量

值还是引用(地址)？

答：值类型与引用类型在一般赋值时的不同：值类型变量间的赋值，赋的是变量值，当

num1和num2是值类型变量时，执行语句“num1=num2;”时，赋值运算符两边的num1

.

.

和num2是两个不同的存储区域，改变num2的值不会影响num1；引用类型变量的赋值

只赋值对象的引用，而不复制对象本身。当num1和num2是引用类型变量时，语句

“num1=num2;”使变量num1和num2共同引用一个对象，对其中任何一个做修改，另一

个都会随之改变。

值类型与引用类型在做函数参数时的不同：值类型变量以传值方式传递时，传递的

是变量的值，形参和实参是不同的内存单元，形参的改变不会影响实参；对象以传值方

式传递，相当于两个引用类型变量进行赋值，传递的是对象的引用(地址)，形参和实参

共同引用一个对象，对形参做修改，实参会随之改变。

在传值方式下(即没有使用ref或out时)，值类型默认传递的是变量值，引用类型默

认传递的是引用(地址)。

第6章 ：数组

数组是值的列表，每个值存储在数组中特定编号的位置。每个位置对应的编号称为索引

(index)或者下标(subscript)。

在C#中数组的索引通常从0开始，所以存储在索引5的值实际上是数组中第６个值。

1．数组的声明

在C#中，声明数组的形式为：

类型[] 数组名；

例如：

double[ ] Score; //声明double型数组引用

int[ ] arr1,arr2; //声明int型数组arr1,arr2

注意：

(1) int []是类型，变量名放在方括号后面，不可放在方括号前面； 例：double Score[ ]; Ⅹ(2)

声明一个数组变量不可指定数组长度。 例： double[ 6] Score; Ⅹ

2．创建数组对象

创建数组就是给数组对象分配内存。

当声明一个数组时，实际上没有创建该数组，与一个类相同，必须在使用它之前创建数

组对象，使用new运算符来创建数组实例，有以下3种方式。

(1) 声明数组，然后创建数组对象。

类型[ ] 数组名;

数组名＝new 类型[元素个数];

例如：

double[ ] Score; //声明数组引用

Score=new double[10]; //创建具有10个元素的数组

(2) 声明数组的同时创建数组对象。

类型[ ] 数组名=new 类型[元素个数]；

类型可以是C#中的各种数据类型。

注意：若创建数组对象时没有对数组进行初始化，C#自动为数组元素进行初始化赋值。

例如：int[] arr=new int [8];所有元素被初始化为0。

（3）使用new创建数组对象的同时，初始化数组所有元素。

类型[ ] 数组名=new 类型[ ]{初值表}；

或

类型[ ] 数组名= {初值表}；

例如：int [] arr=new int []{1,2,3,4};

或

.

.

int [] arr= {1,2,3,4};

3．访问数组元素

(1) 访问方式。为获取在一个数组中保存的一个值，必须提供数组名和元素的序号(序号

称为索引或是下标)，形式为：

数组名[下标]；

如上面arr中的元素分别为：arr[0]，arr[1]，arr[2]， arr[3]。

(2) 注意：

① 数组下标从零开始，最大下标为数组长度减1；

② 所有数组需在编译时检查是否在边界之内，在上例中，若有arr[5]将不能访

问；

③ 可在用户程序中使用Length数据成员来测试数组长度，即数组名.Length。

4．改变数组元素

为把一个值赋给一个特定的数组元素，形式为：

数组名[下标]＝值；

例如：

arr[1]=8; //此时数组中的值为1,8,3,4

5．数组常用的方法

类提供了许多方法，常用的方法有：

(1) Sort()：用于数组元素的排序方法；

(2) Clear()：将数组中某一范围的元素设置为 0或null；

(3) Clone()：将数组的内容复制到一个新数组的实体；

(4) GetLength()：返回某一维数组的长度；

(5) IndexOf()：返回数组值中符合指定的参数值，且是第一次出现。

两层循环结构

▪ 外层循环每次把操作范围内最大的数放到最后位置

▪ 内层循环每次把较大的数放到靠后的位置

确定每层循环的边界

外层循环n-1次

内层循环n-1-i次

C#专门提供了一种用于遍历数组的foreach循环语句。foreach循环语句的格式为：

foreach(类型 变量名 in 表达式)

嵌入语句

其中，in为关键字，类型和变量名用于说明循环变量，表达式对应集合，每执行一

次嵌入语句，循环变量就依次取出集合中的一个元素代入其中。

 如：

 int [ ]arr1=new int [ ]{1,2,3,4,5,6};

 foreach (int i in arr1)

 {

 ine(“Value is {0}”,i);

 }

多维数组就是维数大于1的数组，它把相关的数据存储在一起。例如，存储矩阵，

可以同时存储人名和年龄。

多维数组也必须先创建再使用。其声明、创建方式和一维数组类似。

1．声明多维数组

.

.

声明形式为：

类型[，，…] 数组名；

C#数组的维数是计算逗号的个数再加1来确定的，即一个逗号就是二维数组，两个逗

号就是三维数组。其余类推。

例如：

int[,] arr; //声明一个二维数组arr

int[,,] arr1; //声明一个三维数组arr1

2．创建多维数组

(1) 声明时创建。

类型[，，…] 数组名＝new 类型[表达式1,表达式2,…]；

例如：int[,] arr = new int[2,3];

int[,,]arr1 = new int[2,3,2];

(2) 先声明后创建。

类型[，，…] 数组名；

数组名＝ new类型[表达式1,表达式2,…]；

例如： int[,] arr;

arr=new int[5,6];

3 ．多维数组的初始化

多维数组的初始化与一维数组类似，可用下列任意一种形式进行初始化。

(1) 声明时创建数组对象，同时进行初始化。

类型[，，…] 数组名＝new 类型[表达式1,表达式2,…]{初值表}；

(2) 先声明多维数组，然后在创建对象时初始化。

类型[，，…] 数组名；

数组名＝new 类型[表达式1,表达式2,…]{初值表}；

4．访问多维数组

访问多维数组的形式为：

数组名[下标1,下标2,…]；

如 :访问的是二维数组就为：数组名[下标1,下标2]；

例如:案例中的矩阵第三行第三列，即为：Array[2,2];

索引器(indexer)是C#引入的一个新的类成员，是C#特有的，可像数组那样使用下标，

对对象可以像使用数组那样方便而又直观地引用，通过索引方式能更方便地访问类的数据信

息。

前面学习的属性通常称为“灵巧域(smart fields)”，并把索引器称为“灵巧数组”，因此，

属性和索引器可共同使用同一语法。

[属性信息] 索引修饰符 返回类型 this[类型 变量名]

{ get

{ return value;}

set

{//设置所需的数据，一般必须在类中

//设置一个基于变量名的值

}

}

索引修饰符：new,public,protected ,internal,private,vietual,sealed,override,abstract.

练习：

.

.

1、对 4, 5, 6, 0, 8, 2, 1, 4, 9, 7 用冒泡法进行排序

using System;

using c;

using ;

namespace ConsoleApplication1

{

class Program

{

static void Main(string[] args)

{

double[] score = new double[] { 4, 5, 6, 0, 8, 2, 1, 4, 9, 7 };

double temp;

int i, j;

for (i = 0; i < ; i++) //返回数组的长度

for (j = 0; j < - i - 1; j++)

{

if (score[j] > score[j + 1])

{

temp = score[j];

score[j] = score[j + 1];

score[j + 1] = temp;

}

}

for (j = 0; j < ; j++)

(score[j]);

ne();

}

}

}

2、对4, 5, 10, 7, 8, 2, 1, 9, 6, 7 进行选择法排序

using System;

using c;

using ;

namespace ConsoleApplication2

{

class Program

{

static void Main(string[] args)

{

double[] score = new double[] { 4, 5, 10, 7, 8, 2, 1, 9, 6, 7 };

double temp;

.

.

int i, j, sub_temp;

for (i = 0; i < ; i++)

{

sub_temp = i;

for (j = i + 1; j < ; j++) //让sub_temp保存待排序中最小元素的下

标

{ if (score[sub_temp] > score[j]) sub_temp = j; }

if (sub_temp != i)

{

temp = score[sub_temp];

score[sub_temp] = score[i];

score[i] = temp;

}

}

for (j = 0; j < ; j++)

(score[j]);

ne();

}

}

}

第7章 继承

.