c#网络应用编程基础练习题与答案（四）_全国等级考试

　1. 与结构化编程方法相比，面向对象编程有哪些优点?

　　【解答】

　　(1) 以过程为中心和对象为中心的比较

　　结构化编程方法是以过程为中心的，当面对一个问题时，该方法侧重于问题解决过程的层次结构。面向对象的分析和设计方法侧重于对象。对象具有特定的行为和属性，行为和属性决定了对象与其他对象的交互作用方式，以及对象本身的行为方式。

　　(2) 公开数据和隐藏数据的比较

　　结构化编程方法对数据和过程仅仅进行简单的包装，这些数据和过程是公开的，或者说程序中的其他代码可以访问这些数据和过程。面向对象的实现隐藏了特定的数据，并且只把对象的特定行为公开给用户。实现这些特定行为的代码对用户来说是不可见的，用户只能访问这些公开的行为。

　　(3) 单一单元和标准单元的比较

　　结构化编程方法是基于单一代码单元的。面向对象的编程方法允许对象是独立的。

　　(4) 一次性使用和可重用的比较

　　根据不同的实现，结构化过程可能无法重用。而面向对象的方法，对象是一个模块单元。具有完备的实体，因此可以具有高度的可重用性。

　　(5) 有序算法和无序算法的比较

　　结构化编程方法所开发的程序，其结构往往是线性的(或者说是自顶向下的)。而面向对象的应用程序是一种基于消息或者事件驱动的程序类型。每个对象都可以向其他对象发送消息。Windows操作系统就是这样的程序。

　　2. 简要回答下列问题。

　　1) 举例说明new关键字可用于那些方面?

　　2) sealed关键字的作用是什么?什么情况下需要使用sealed关键字?

　　3) 哪些关键字可以用于版本控制?

　　【解答】

　　1) 在C#中，new关键字可用作运算符或修饰符。作为运算符用于在堆上创建对象和调用构造函数。作为修饰符用于隐藏基类成员的继承成员。

　　2) 在类声明中使用sealed修饰符可防止其它类继承此类。在方法声明中使用sealed修饰符可防止扩充类重写此方法。

　　sealed修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化。具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数成员的调用可以转换为非虚拟调用来处理。

　　3) override关键字和new关键字均可用于版本控制。

　　在C#中，默认情况下方法不是虚拟的。若要使方法成为虚拟方法，必须在基类的方法声明中使用virtual修饰符。然后，派生类可以使用override关键字重写基类中的虚拟方法，或使用new关键字隐藏基类中的虚拟方法。如果override关键字和new关键字均未指定，编译器将发出警告，并且派生类中的方法将隐藏基类中的方法。

　　3. 简要回答抽象类和接口的主要区别。

　　【解答】

　　抽象类和接口的一个主要差别是：类可以实现多个接口，但仅能从一个抽象类或任何其它类型的类继承。

　　4. 使用委托的优点是什么?委托和事件有什么区别和联系?

　　【解答】

　　C#中的委托类似于C或C++中的函数指针。使用委托使程序员可以将方法引用封装在委托对象内。然后可以将该委托对象传递给可调用所引用方法的代码，而不必在编译时知道将调用哪个方法。与C或C++中的函数指针不同，委托是面向对象，而且是类型安全的。

　　C#中的“事件”是当对象发生某些事情时，类向该类的客户提供通知的一种方法。事件最常见的用途是用于图形用户界面;通常，表示界面中的控件的类具有一些事件，当用户对控件进行某些操作(如单击某个按钮)时，将通知这些事件。

　　使用委托来声明事件。委托对象封装一个方法，以便可以匿名调用该方法。事件是类允许客户为其提供方法(事件发生时应调用这些方法)的委托的一种方法。事件发生时，将调用其客户提供给它的委托。
　　5. 编写一个控制台应用程序，完成下列功能，并回答提出的问题。

　　1) 创建一个类A，在构造函数中输出“A”，再创建一个类B，在构造函数中输出“B”。

　　2) 从A继承一个名为C的新类，并在C内创建一个成员B。不要为C创建构造函数。

　　3) 在Main方法中创建类C的一个对象，写出运行程序后输出的结果。

　　4) 如果在C中也创建一个构造函数输出“C”，整个程序运行的结果又是什么?

　　【解答】

以下是引用片段：
　　using System;
　　public class A
　　{
　　public A()
　　{
　　Console.WriteLine(“A”);
　　}
　　}
　　public class B
　　{
　　public B()
　　{
　　Console.WriteLine(“B”);
　　}
　　}
　　public class C : A
　　{
　　B newb = new B();
　　}
　　class MainClass
　　{
　　public static void Main()
　　{
　　C newc = new C();
　　Console.ReadLine();
　　}
　　}

　　输出结果：

　　B

　　A

　　如果在C中也创建一个构造函数输出“C”，即添加：

以下是引用片段：
　　public C()
　　{
　　Console.WriteLine(“C”);
　　}

　　则整个程序运行的结果为：

　　B

　　A

　　C

　　6. 编写一个控制台应用程序，完成下列功能，并写出运行程序后输出的结果。

　　1) 创建一个类A，在A中编写一个可以被重写的带int类型参数的方法MyMethod，

　　并在该方法中输出传递的整型值加10后的结果。

　　2) 再创建一个类B，使其继承自类A，然后重写A中的MyMethod方法，将A中接

　　收的整型值加50，并输出结果。

　　3) 在Main方法中分别创建类A和类B的对象，并分别调用MyMethod方法。

　　【解答】

以下是引用片段：
　　using System;
　　public class A
　　{
　　public virtual void MyMethod(int num)
　　{
　　num += 10;
　　Console.WriteLine(num);
　　}
　　}
　　public class B : A
　　{
　　public override void MyMethod(int num)
　　{
　　num += 50;
　　Console.WriteLine(num);
　　}
　　}
　　class MainClass
　　{
　　public static void Main()
　　{
　　A newa = new A();
　　newa.MyMethod(2);
　　B newb = new B();
　　newb.MyMethod(2);
　　Console.ReadLine();
　　}
　　}

　　输出结果：

　　12

　　52

　　7. 假设Node类的每一个节点包括有两个字段：m_data(引用节点的数据)和m_next(引用链接列表中的下一项)。这两个字段都是由构造函数方法设置的。该类有两个功能，第一个功能是通过名为Data和Next的只读属性访问m_data和m_next字段。第二个功能是对System.Object的ToString虚拟方法进行重写。试分别用类和泛型两种方法编写程序实现上述功能。

　　【解答】

以下是引用片段：
　　using System;
　　class Node
　　{
　　Object m_data;
　　Node m_next;
　　public Node(Object data, Node next)
　　{
　　m_data = data;
　　m_next = next;
　　}
　　// 访问结点数据
　　public Object Data
　　{
　　get { return m_data; }
　　}
　　// 访问下一个结点
　　public Node Next
　　{
　　get { return m_next; }
　　}
　　// 获取结点数据描述
　　public override String ToString()
　　{
　　return m_data.ToString();
　　}
　　}
　　// 链表结点类的泛型定义
　　class Node
　　{
　　T m_data;
　　Node m_next;
　　public Node(T data, Node next)
　　{
　　m_data = data;
　　m_next = next;
　　}
　　// 访问结点数据
　　public T Data
　　{
　　get { return m_data; }
　　set { m_data = value; }
　　}
　　// 访问下一个结点
　　public Node Next
　　{
　　get { return m_next; }
　　set { m_next = value; }
　　}
　　// 获取结点数据描述
　　public override String ToString()
　　{
　　return m_data.ToString();
　　}
　　}
　　// 使用结点类型或泛型结点类型
　　class LinkedList
　　{
　　static void Main(string[] args)
　　{
　　//// 创建整数链表
　　//Node head = new Node(5, null);
　　//head = new Node(10, head);
　　//head = new Node(15, head);
　　////遍历链表求整数和
　　//Int32 sum = 0;
　　//for (Node current = head; current != null;
　　// current = current.Next)
　　//{
　　// sum += (Int32)current.Data;
　　//}
　　//// 输出结果
　　//Console.WriteLine(“Sum of nodes = {0}”, sum);
　　// 用泛型创建整数链表
　　Node head = new Node(5, null);
　　head = new Node(10, head);
　　head = new Node(15, head);
　　// 遍历求和
　　Int32 sum = 0;
　　for (Node current = head; current != null;
　　current = current.Next)
　　{
　　sum += current.Data;
　　}
　　// 输出
　　Console.WriteLine(“Sum of nodes = {0}”, sum.ToString());
　　}
　　}