《深入.NET平台和C#编程》内部测试题-笔试试卷答案

1)      以下关于序列化和反序列化的描述错误的是（ C）。

a)      序列化是将对象的状态存储到特定存储介质中的过程

b)      二进制格式化器的Serialize()和Deserialize()方法可以分别用来实现序列化和反序列

化过程

解析：BinaryFormatter

c)      如果一个类可序列化，则它的子类和包含的各成员对象也一定可序列化

问题出在了子类，如果子类压根不能进行序列化操作，则会抛出异常

d)      标识一个类可以序列化要使用[Serializable]

2)      在C#中，下列关于简单工厂设计模式的说法不正确的是（ A ）。

a)      简单工厂产生的对象都是静态对象

对象没有静态和动态之分

b)      创建产品的方法返回类型都是父类

c)      使用该模式解决了代码中大量使用new 的问题

工厂模式：

单例模式

3个：

简单工厂

工厂模式

抽象工厂模式

Public  class Factory

{

Public static Animal CreateProduct(string type)

{

Animal animal=null;

Return animal;

}

}

原则：开闭原则（对修改关闭，对添加开放）

d)      简单工厂的缺点是对修改不封闭，新增加产品就需要修改工厂

3)      下列关于虚方法（virtual）和抽象方法（abstract）的描述中错误的是（ C）。

a)      虚方法必须有方法体，可以被子类重写

b)      抽象方法不允许有方法体，且必须被子类重写

c)      抽象方法必须在抽象类中，而虚方法可以在所有类中

密封类和静态类中不能书写

d)      在子类中重写抽象方法或虚方法，都需要用override关键字

4)   在UML类图中使用（B ）符号表示私有成员。

a)      +

b)      -

c)      *  ~：package

d)      #  受保护类型

5) 分析以下使用抽象类的C＃代码，其最终的运行结果是（D ）。

public abstract class Class1

{

public void F()

{

Console.Write("1");

}

abstract public void ABS();

}

public class Class2 : Class1

{

public override void ABS()

{

Console.Write("3");

}

public Class2()

{

Console.Write("2");

}

static void Main()

{

Class2 objB = new Class2();

objB.ABS();

}

}

//先调用构造，然后调用自身的ABS方法()

a)      12

b)      21

c)      13

d)      23

6)      下列代码的运行结果是（ A）。

class Test

{

Public  void F()

{

Console.Write("A");

}

}

class B : Test

{

Public  new  void F()

{

Console.Write("B");

}

Public  void Say()

{

}

static void Main()

{

Test objA = new B();

objA.F();

}

}

注意：这里不是多态，所以用父类变量保存子类对象，取的是父类的方法。哪怕父类方法使用Virtual关键字，子类没有Override就不会实现多态。

以后我们碰到通过父类变量保存在对象的题目时，应该具备以下理解能力：

01.当new一个子类的时候，可以看成在子类对象中已经完全包含一个父类对象，所以我们可以在子类中通过this点出来父类的非私有成员。

02.父类变量只能调用到父类的方法，而不能调用子类的方法，即使该父类变量存储是子类。

程序员;编码能力   打字能力。

打字员：打字能力

a)      A

b)      B

c)      BA

d)      AB

7)   关于C#中的虚方法，以下说法正确的是（C ）。

a)      使用static修饰

b)      可以没有方法体

c)      可以被子类重写

d)      使用abstract修饰

8)   分析如下C#代码，如果输出结果是“Dog Eating......”，下划线需要填写的代码是(B )

    abstract class Animal

{

public __________ void Eat();

}

class Dog:Animal

{

public __________ void Eat()

{

Console.WriteLine("Dog Eating......");

}

static void Main(string[] args)

{

Animal animal = new Dog();

animal.Eat();

}

}

a)      abstract，不填

b)      abstract，override

c)      virtual，不填

d)      virtual，override

9)   在开发C#程序过程中，会大量地使用类和对象，其使用方法不包括（ BC）。

a)      将类实例化为对象

b)      将对象实例化为类

c)      通过类访问非静态属性或方法

d)      通过对象访问非静态属性或方法

10) 运行下面C#代码将会出现编译错误，出现错误的位置是（ D）。

class Teacher

{

public Teacher(string name)

{

this.Name = name;                          //1

}

private string name;

public string Name

{

set { name = value; }                        //2

}

static void Main(string[] args)

{

Teacher teacher = new Teacher("Jason");       //3

Console.WriteLine(teacher.Name);             //4

}

}

a)      1

b)      2

c)      3

d)      4

只有set访问器，证明只能赋值，不能获取值

11) 现有类“c1”，它所在的命名空间为“a.b”，则下列说法中错误的是（D ）。

a)      不同命名空间下仍可存在名称为c1的类

b)      不同命名空间下使用c1时，可以通过“using a.b”引入命名空间

c)      同一命名空间下的类，使用c1时不需要引入c1的命名空间

d)      不同命名空间下使用c1时，不可以直接通过“a.b.c1”的方式使用

D选项可以但是麻烦

12) 下面关于泛型集合Dictionary<String, Person> dict = new Dictionary<String,Person>()的操作代码正确的是（C ）。

a)      dict.Remove(dict[0])   //dict[0]不对，dict只能通过key访问，不可通过下标访问。

b)      dict.RemoveAt(0)  //没有RemoveAt方法

c)      foreach(Person per in dict.Values){}

d)      foreach(Person per in dict.Keys){}

13)   已知Company.xml文件节点代码如下：

<Company>

<Name>一汽大众</Name><价格>10万</价格>

<Name>日本丰田Toyota</Name> <价格>20万</价格>

</Company>

现有如下C#代码片段:

XmlDocument myXml = new XmlDocument();

myXml.Load("Company.xml");

XmlNode company = myXml.DocumentElement;

foreach(XmlNode node in company.ChildNodes )

{

switch (node.Name)

{

case "一汽大众":   不是标签名

Console.WriteLine("车名:{0}", node.InnerText);

break;

case "价格":

Console.WriteLine("价格为:{0}", node.InnerText);

break;

}

}

则正确的输出结果为（D）。

a)      车名：一汽大众

价格为：10万

b)      车名：一汽大众

价格为：20万

c)      车名：一汽大众

车名为：日本丰田

d)      价格为：10万

价格为：20万

14)   已知Animal、Cat、Tiger三个类，其继承关系为Cat: Animal，Tiger: Animal，

已知Animal中成员color的访问修饰符为protected，Cat中成员height的访问修饰符为private，Tiger中成员weight的访问修饰符为public，则下面描述中错误的是（ D）。

a)      Cat可以访问Animal中的成员color

b)      Cat可以访问Tiger中的成员weight

c)      Tiger可以访问Animal中的成员color

d)      Tiger可以访问Cat中的成员height

15) 在C#中，（ C）关键字用于子类的构造函数明确指明调用的父类的构造函数。

a)      new  创建对象时使用

b)      this   代表当前类的实例

c)      base  显示调用父类的构造方法和父类属性和常规方法

d)      is

16) C#中的多态不能通过（D ）实现。

a)      方法重载

方法重载多态的体现！

b)      抽象类

c)      虚方法

d)      密封类 密封类都无法被继承，何来多态呢？因为我们知道多态的前提是继承。

17)   分析如下C#代码片断，运行后输出的结果是（ C）。

ArrayList list = new ArrayList();

list.Add("Sina");

list.Add("Yahoo");

list.Add("Google");

list.RemoveAt(1);

Console.WriteLine(list[1]);

a)      Yahoo

b)      Sina

c)      Google

d)      代码出现运行错误

List集合会自动调整（维护）索引。

18) 在C#语言中，以下关于集合的说法错误的是（A,C）。

a)      ArrayList只能通过索引来访问和删除值     也可以直接删除某个对象

b)      Hashtable可以直接通过键名来获取值 table[key]

c)      使用List<T>添加、读取元素时不需要拆箱和装箱，这一点和ArrayList相同

d)      使用Dictionary<K,V>可以通过Key获取Value，这一点和Hashtable相同

19)     分析如下C#程序，运行输出的结果是（ B）。

   注意是结构体

public struct Size

{

public int x;

public int y;

public Size(int x, int y)

{

this.x = x;

this.y = y;

}

}

class Test

{

static void Main()

{

Size size1 = new Size(8,10);

Size size2 = size1;

size1.y = 200;

Console.WriteLine("{0} | {1}",size1.y,size2.y);

}

}

a)      200 | 200

b)      200 | 10

c)      10 | 10

d)      10 | 200

20) 假设要使用C#设计一个日志系统，要求程序运行时，检查 system.log 文件是否存在，如果已经存在则直接打开，如果不存在则创建一个，为了实现这个目的，应该以FileMode的（C）方式创建文件流。

a)      CreateNew

b)      Open

c)      OpenOrCreate

d)      Create

21) 下面关于单例模式说法错误的是（A）。

a)      在单例模式中，允许通过new 构造实例

b)      单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例

c)      在C# 中，static 是实现单例模式的重要关键字

d)      单例模式可以确保所有对象都访问唯一的实例

22) 下面不是C#中类的访问修饰符的是（AD）。

a)      protected

b)      internal

c)      public

d)      internal protected

Public在任何位置都可以访问，甚至是跨程序集都可以访问，

Internal只能在当前程序集中的任何位置访问，出了当前程序集，就无法访问。

在定义内部类的时候可以使用A和D作为类的访问修饰符

23) 在C#中，下面关于结构的说法中，正确的是（C）。

a)      结构和类都是引用类型

b)      定义结构的变量必须用new

c)      不能在定义结构时给结构的成员设置初始值

d)      结构中的整型成员被自动初始化为1    自动初始化为0

课本上原话

24) 关于如下C#的代码，说法正确的是（C）；

public class A

{

string S1;

protected string S2;

protected void M1()

{

}

}

public class B : A

{

protected string S3;

}

a)      在A中可以访问S3  解析（父类中不可以访问子类受保护成员）

b)      在B中可以访问S1  解析( 如果类中变量没哟访问修饰符修饰，默认访问修饰符是private)

c)      在B中可以访问S2   解析（可以：因为其访问修饰符是protected类型）

d)      在M1( ) 中可以访问S3   解析(不可以在父类方法中访问子类字段)

25) 关于如下C#代码的说法中，正确的是（D）。

public class Test    //⑴

{

private static int Max = 100;    //⑵ 成员变量：

public Test(int max)

{

Max = max;    //⑶

}

public int GetMax()

{

return Max;    //⑷

}

}

a)         在⑴行中必须将Test类定义为静态类

静态变量可以不出现在静态类中

b)      在⑵中不能将静态成员Max定义为private的

c)      在⑶中不能给静态成员Max赋值

d)      在⑷中可以使用静态成员Max

26) 在C#中，下面是方法的重载的是（C）。

a)      public string Test(int x, int y){ …}和public string Test(int a, int b){ …}同一个方法

b)      public string Test1(int x, int y){ …}和public string Test2(int x, int y){ …}

c)      public string Test(int x, int y){ …}和public string Test(int a){ …}

d)      public string Test(int x, int y){ …}和public int Test(int x, int y){ …}同一个方法

和返回值类型没有半毛钱关系

27) 下面C#代码执行的结果是（A）。

public class A{ }

public class B : A

{

static void Main()

{

A a = new A();

B b = a as B;

if (b == null)

Console.WriteLine("null");

else

Console.WriteLine(b is A);

}

}

a)      null

b)      True

c)      False

d)      出现异常

28) 如下C#代码的执行结果是（C）。

public class Test

{

public int i = 1;

public Test(int i)

{

this.i += i;

}

static void Main()

{

Test t = new Test(2);

Console.WriteLine(t.i);

}

}

a)      1

b)      2

c)      3

d)      4

29)有如下C# 代码，则下面选项中说法正确的是（BC）。

public class A { }   Person

public class B : A { }  Student

A a = new A();

B b = new B();

a)      表达式a is B的值为true

b)      表达式b is A的值为true

c)      表达式a as B的值为null

d)      表达式b as A的值为null

30)     在C#中，下面类型中是引用类型的是（CD）。

a)      DialogResult枚举

b)      System.Int64

c)      string

d)      StringBuilder

二 简答题：

1．请简述泛型集合List<T>中“T”的含义和作用。并说明List<T>与ArrayList的异同。

2．面向对象的三大特性是什么？并简述每个原则的基本功能。

《深入.NET平台和C#编程》内部测试题-笔试试卷答案

答案

一、选择题

1、c                            2、a                            3、c                            4、b                   5、d

6、a                            7、c                            8、b                   9、bc                 10、d

11、d                12、c                 13、d                14、d                15、c

16、d                17、c                 18、ac              19、b                20、c

21、a                22、ad              23、c                 24、c                 25、d

26、c                 27、a                28、c                 29、bc              30、cd

二 简答题

1、要点：

n 
List<T>中的T可以对集合中的元素类型进行约束；

n 
T表明集合中管理的元素类型；

n 
ArrayList与List<T>都使用索引访问元素；

n 
ArrayList与List<T>可以通过索引删除、也可以直接删除对象；

n 
ArrayList与List<T>遍历时直接遍历元素对象；

n 
ArrayList获取元素时需要类型转换，List<T>不需要类型转换；

n 
同一个ArrayList可以保存不同类型的元素，List<T>只能保存T允许的类型。

2、要点：

n 
封装：保证对象自身数据的完整性、安全性；

n 
继承：建立类之间的关系，实现代码复用，方便系统的扩展；

n 
多态：相同的方法调用可实现不同的实现方式。