c#复习资料

1.面向对象编程（oop）的三个特性：封装，继承，多态

2.C#程序的入口方法名：Main

3.小数类型（decimal）比浮点数类型精度高

4.默认情况下，基础类型为int，第一个枚举数的值为0，后面每个枚举型的值依次递增1.

5．Continue不是用来终止并跳出循环结构的，而是忽略continue后面的语句，直接进入本循环结构的下一次循环操作。

6.定义初始化一维数组：int[] a = new int[] { 1, 2, 3, 4, 5 };

7．定义初始化一个2行3列的二维数组：int[,] a = new int[2, 3] { { 1, 2, 3 }, { 4,

5, 6 } };

8. int[][] myArray = new int[3][] { new int[3] { 1, 2, 3 }, new int[5] { 4, 5, 6,

7, 8 }, new int[2] { 9, 10 } };则myArray[1][1]的值是5。数组从a[0][0]开始的。

占四个字节。

10. double[, ,] a = new double[2, 3, 4];是一个三维数组，元素有2*3*4=24个

11.在.Net中一些数据类型为引用类型，当引用类型的值为null时，表明没有引用任何对象。

12.C#的数据类型有值类型和引用类型。值类型包括:基本值类型（int，bool，char,float，double,decimal），结构类型（struct），枚举类型（enum），引用类型包括:数组，字符串（string），类（class），接口，委托。对于方法，按性质参数传递分为按值类型和按引用类型传递。

13.数据改变只是临时转变，不改变数据说明时对该变量定义的类型。数据转换的类：convert

14.装箱：值类型到引用类型，拆箱：引用类型到值类型。

15.按值传参传的只是形参，按引用传参传的是实参。Ref修饰的参数在传参前要求先初始化实参，out修饰的参数，在传参前不需要赋初值，但在方法内部必须赋值后才可以使用，在方法结束前必须对该参数赋值。

16.方法的重载：允许用同一方法名定义多个方法，这些方法的参数个数或参数类型不同，不同的参数传递方式。

17.对类进行实例化时，系统自动调用构造函数，构造函数的名称必须和类名相同，不允许有返回值类型，包括void。一个类可以声明多个构造函数，构造函数在创建对象时调用。默认构造函数不包含任何参数和语句。销毁一个实例化对象时，系统会调用析构函数。

18.C#中，internal访问修饰符修饰的变量只能由当前程序集访问。

19.一个类中的私有实例方法的调用可以在同一个类中的某一个方法中直接调用。

20．C#中导入某一命名空间的关键字：using，命名空间使得代码更加有条理，结构更清晰。

21.在类作用域中能够通过直接使用该类的任何成员名进行访问。

22.静态成员关键字：static，在内存中只有一份，要等到引用程序结束时才会消失。静态成员属于类，而不属于类的实例，因此需要通过类，而不是通过类的实例来访问。

23.一个类可以实现多个接口，只能从一个基类派生，即类不可以多重继承而接口可以，子类能添加新方法。抽象类是一种不能实例化的类，抽象类可以包含抽象成员，也可以包含非抽象成员，可以封装所有派生类的通用功能。接口像是一个完全没有实现的只包含抽象成员的抽象类，无法使用接口来封装所有派生类的通用功能。

24. ClassA obj = new ClassA(); ClassA.M1(); 则修饰M1方法时一定使用了static修饰符。

25.已知类B是由类A继承而来，类A中有一个为M的非虚方法，现在希望在类B中也定义一个名为M的方法，若希望编译时不出现警告信息，则在类B中声明该方法时，应使用new方法。

26.要在派生类中重新定义基类的虚函数必须在前面加override关键字。

27.类的特性中，用于方便的重用已有的代码和数据的是继承

class myClass{……private int var1,……}则可以访问var1的有：myClass中包含的类。

29.要实现继承的多态性，在类定义时，首先在基类中用virtual关键字标识虚拟成员，然后在派生类中用override关键字将基类的虚拟成员覆盖掉。使用virtual修饰符后，不允许再使用static，abstract或override修饰符。派生类对象即使被强制转化为基类对象时，所用的仍然是派生类的成员，基类与派生类中的方法名称与参数列表必须完全一致。

l关键字：定义虚方法时使用，可以与override一起使用（virtual在基类中定义虚方法，override在派生类中覆盖基类），虚方法是实现多态的一种应用形式。

31.抽象方法：没有方法体，重载抽象类的方法和属性必须使用override关键字，其中方法名称和参数列表必须与抽象类中的抽象方法完全一致。

32. 定义抽象类时使用的关键字abstract。抽象类可以包括抽象方法和抽象属性，可以引用派生类的实例。

32.继承时，基类必须在所有的接口之前。接口可以是属性，方法，索引器和事件，不能包括字段，构造函数，接口成员隐式的具有public访问修饰符，所以接口成员不能添加任何访问修饰符。接口中的方法默认为public且方法不实现。定义接口时，使用的关键字是interface。

33.防止一个类被其他类继承，使用关键字sealed。

1. 可以标识不同的对象属性是Name;需在菜单中添加分隔符，应输入的符号是-；建立访问键时，需在菜单标题的字母前添加的符号是&；在C#.Net中，用来创建主菜单的对象是MenuStrip;Textbox控件可以用来代替密码输入框；改变窗体的名称，需改变窗体的Name；改变窗体的标题，需改的窗体属性是Text；在设计阶段，双单击窗体时进入到的窗体的Load事件；加载窗体时的触发事件是Load；StreamReader和StreamWriter类用于按文本方式读写文件；BinaryReader和BinaryWriter类用于二进制方式读写文件；StreamWriter对象的方法，可以向文本文件写入一行带回车和换行的文本的是WriteLine();StreamWriter对象的方法，可以向文本文件写入一行不带回车和换行的文本的是Write()

2. 异常类均为ion类的对象

3. Array的下限可以自定义，而ArrayList的下线始终为1. 错

4. 哈希表可以像数组一样，通过索引的方式访问其中的元素。 错

5. 在.Net中，ArrayList的对象位于tions命名空间内。

6. 在.Net中，Hashtable类所在的命名空间是System.I0

7. 定义索引器可以使用this关键字

8. 在C#中，索引器一般用来访问类中的数组元素或者集合元素。 对

9. 为索引器指定一个或多个索引器参数

第六次作业

1.一个委托在某一时刻可以指向多个方法

2.将事件通知其他对象的对象称为发布方

3.声明一个委托public delegate int myCallBack（int x）；则用该委托产生的回调方法的原型应该是int receive（int num）

4.在C#中，假如有一个名为” MessageDelegate”的委托，下列能够正确定义一个事件的是public event MessageDelegate messageEvent

第五次作业

1.异常类均为ion类的对象

2.无论异常是否抛出，finally子句中的内容都会被执行

…catch…finally

4. C#程序：编译和运行时，将编译时将报告错误信息，提示变量x未赋值

5.请问代码运行结果是try finally

6. ion类是C#中其他所有异常类的基础

7.查阅以下的C#代码，请问代码运行结果是try catch finally

8.程序运行过程中发生的错误叫做异常

9.C#中应用程序企图执行无法实施的操作时，会引发运行时错误

10.在.NET中程序员编写了如下代码，请问这代码会出现逻辑错误（18岁以下不得进入）

11.在C#程序中，下列用来处理异常结构，错误的是catch{}finally{}

12.在C#中，程序使用throw语句抛出系统异常或自定义异常

补充：

1. 隐式转换：隐式转换一般在不同类型的数据进行混合运算时发生，由C#语言编译器自动完成。转换时按数据长度增加的方向进行，以保证精度不降低，例如int型和long型运算时，先把int数据转换成long型后再进行运算。显式转换：在C#中，为了避免隐式转换可能带来的错误，需要使用强制转换来执行显式转换。无论是隐式转换或强制转换，都只是为了本次运算的需要而对变量的数据长度进行临时性转换，而不改变数据说明时对该变量定义的类型。

2. 类是抽象的，不占用内存，而对象是具体的，占用存储空间。

3. 类是C#程序的基本组成单位。类的成员包括：常量，字段，属性，索引器，方法，事件，构造函数等

4. 属性是只读时，省略set访问器，属性是只写时，省略get访问器；但不能同时省略这两个访问器。

简答题：

1. 如何理解程序的多态？

答：c#支持两种类型的多态

1）编译时多态：一个类的对象调用若干个同名方法，系统在编译的时候，根据调用方法的实参类型及实参的个个数来决定调用哪个同名方法，实现何种操作。

2）运行时多态：在系统运行时，不同对象调用一个名字相同、参数类型及个数完全一样的方法，会完成不同的操作。

2. 什么是抽象类？抽象类有什么特点？

答：用Abstract关键字定义的类为抽象类

抽象类的特点：

1） 抽象类不能被实例化，抽象类可以包含抽象成员，也可以包含非抽象成员。

2） 不能用sealed关键字声明抽象类

3） 抽象类可以包含抽象方法和抽象访问器

4） 从抽象类派生的非抽象类必须包括继承的所有抽象费和抽象访问器的实现

3.分布类和命名空间在应用程序设计中有何意义？

答：分布类允许将类、结构或接口的定义拆分到两个或多个原文件中，让每个源文件只包含类型定义的一部分，编译时编译器自动把所有部分组合起来进行编译。有了分部类，一个类的源代码可以分布于多个独立文件中，在处理大型项目时，过去很多只能由一个人进行的编程任务，现在可以由多个人同时进行，这样将大大加快了程序设计的工作进度。

命名空间可以将相互关联的类组织起来，形成一个逻辑上相互关联的层次结构，命名空间既可以对内组织应用程序，也可以对外避免命名冲突。

4. 类的继承有什么好处?

答：当一个类从另一个类派生出来时，派生类就具有了基类中的所有成员，这样，基类中定义这些成员的代码，不需要在派生类定义中重写，在派生类定义中，只需要定义派生类自己的成员即可。这样，既提高了代码的重用性，从而提高了程序设计的效率，有提供了已有程序设计的可扩展性。

5. 简述抽象类和接口之间的主要区别？

答：1）抽象类可以包括抽象成员，也可以包含非抽象的成员，即抽象类可以是完全实现的，也可以是部分实现的，或者完全不实现，而接口完全没有实现；

2）抽象类中可以包含字段构造函数等，而接口不可以；

3）接口成员不能有任何访问修饰符，而抽象类的成员可以有访问修饰符。

6.什么是泛型?泛型在面向对象程序设计中有什么意义？

答：泛型是通过“参数化类型”来实现在同一段代码中操作多种数据类型。泛型类型是一种编程范式，它利用“参数化类型”将类抽象化，从而实现更为灵活的复用。泛型赋予了代码更强的安全性、更好的复用、更高的效率和更清晰的约束。

编程题：

1. 定义一个名为Add的类，用构造函数实现两个整数和两个双精度类型数据求和，写一个名为Result的方法，把结果返回。

class Program

{

static void Main(string[] args)

{

ine("整型数据相加：");

Add intadd = new Add(1,2);

();

ine("双精度类型数据相加：");

Add doubleadd = new Add(1.5, 2);

();

}

}

class Add

{

public double add = 0;

public Add(double x, double y)

{

add = x + y;

}

public Add(int x, int y)

{

add = x + y;

}

public void Result()

{

ine(add);

}

}

2定义一个人员学生抽象类Student，再分别构造小学生派生类Pupil：

1） 每个学生都有的字段为姓名（string name）、年龄（int age）

2） 小学生的字段还有语文（int chinese）、数学（int math）这两门课的成绩

3） 学生类提供抽象方法Average（）来统计自己的平均成绩并输出

class Program

{

static void Main(string[] args)

{

Pupil p = new Pupil("张三", 20, 90, 100);

ine(e());

}

}

public abstract class Student

{

string name;

int age;

public Student(string name, int age)

{

= name;

= age;

}

public abstract double Average();

}

public class Pupil : Student

{

int chinese;

int math;

public Pupil(string name, int age, int chinese, int math)

: base(name, age)

{

e = chinese;

= math;

}

public override double Average()

{

return (chinese + math) / 2;

}

}

3定义一个泛型的方法，用于实现两个整型数据和双精度类型的交换。

class Program

{

static void Main(string[] args)

{

int x=10;

int y=20;

ine("交换前：{0},{1}",x,y);

Demo demo=new Demo();

(ref x, ref y);

ine("交换后：{0},{1}",x,y);

Double a=10.5;

Double b=5;

ine("交换前：{0},{1}",a,b);

Demo demo1 = new Demo();

(ref a, ref b);

ine("交换后：{0},{1}",a,b);

}

}

class Demo

{

public void Swap(ref T a, ref T b)

{

T temp;

temp = a;

a = b;

b = temp;

}

}