C面向对象编程习题.doc

C#面向对象编程-多态

1．C#中的方法重写使用关键字（）。
a) override
b) overload
c) static
d) inherit

2．以下的C#代码，试图用来定义一个接口：
public interface IFile{
int A;
int delFile() {
A = 3;
}
void disFile();
}
关于以上的代码，以下描述错误的是（）。（选择一项）
a) 以上的代码中存在的错误包括：不能在接口中定义变量，所以int A代码行将出现错误
b) 以上的代码中存在的错误包括：接口方法delFile是不允许实现的，所以不能编写具体的实现函数
c) 代码void disFile();定义无错误，接口可以没有返回值
d) 代码void disFile();应该编写为void disFile(){};

3．在C#中，接口与抽象基类的区别在于（）。
a) 抽象基类可以包含非抽象方法，而接口只能包含抽象方法
b) 抽象基类可以被实例化，而接口不能被实例化
c) 抽象基类不能被实例化，而接口可以被实例化
d) 抽象基类就是接口，它们之间无差别

4．在开发某图书馆的图书信息管理系统的过程中，开始为教材类图书建立一个TextBook类；现在又增加了杂志类图书，于是需要改变设计，则下面最好的设计应该是（）。
a) 建立一个新的杂志类Journal。
b) 建立一个新的杂志类Journal，并继承TextBoook类。
c) 建立一个基类Book和一个新的杂志类Journal，并让Journal类和TextBoook类都继承于Book类。
d) 不建立任何类，把杂志图书的某些特殊属性加到TextBoook类中。

5．可以使用（）关键字重写方法。
a) Override
b) New

6．（）可以看作类的模具。
A. 抽象类
B. 接口
C. 虚方法

7．以下叙述正确的是：()
A．接口中可以有虚方法。 B.一个类可以实现多个接口。
C．接口不能被实例化。 D.接口中可以包含已实现的方法。

8.下列代码输出为（ ）：
class Father{
public void F() { Console.WriteLine("A.F"); }
public virtual void G() { Console.WriteLine("A.G"); }
}
class Son: Father{
new public void F() { Console.WriteLine("B.F"); }
public override void G() { Console.WriteLine("B.G"); }
}
class override_new{
static void Main() {
Son b = new Son();
Father a = b;
a.F();
b.F();
a.G();
b.G();
}
}
A. A.FB.F A.GB.G
B. A.FB.FB.GB.G
C. A.F A.FB.GB.G
D. B.FB.FB.GB.G

9．写出程序的输出结果：
public class A
{
public virtual void Fun1(int i)
{
Console.WriteLine(i);
}
public void Fun2(A a)
{
a.Fun1(1);
Fun1(5);
}
}
public class B:A {
public override void Fun1(int i)
{
base.Fun1(i+1);
}
public static void Main() {
B b=new B();
A a=new A();
a.Fun2(b);
b.Fun2(a);
}
}

10．在C＃中，允许多接口继承，从多个接口时，使用“：”后跟继承的接口的名字，多个接口名称之间使用（）符号进行分割。（选择一项）
a)”.’
b)”->”
c)”,”
d)”::”

11．在.NET中，关于组件多态性的陈述，下面除了( )都是正确的。(选择一项)
a可以通过接口实现多态性
b可以通过抽象类实现多态性
c多态性不只是重载或重写，而是智能重写
d在多态性中，需要调用哪个方法的决定是在设计时做出的

12．多态性允许对类的某个方法进行调用而无需考虑该方法所提供的特定实现，例如，可能有名为了Road的类，它调用另一个类的Drive方法，另一个类可能是SportsCar 或SmallCar,
但二者都提供Drive方法，虽然Drive 方法的实现因类的不同而异，但Road 类仍可以调用它，并且它提供的结果可由Road 类使用和解释。在 .NET 中，可以由以下的方式来实现组件中多态性，除了（）。（选择一项）
a) 通过接口实现多态性
b) 通过多个不同的子类从单个基类继承实现多态
c) 通过抽象类实现多态性
d) 通过受保护的成员函数来实现多态性

13．阅读以下的C#代码：
class A
{
public abstract void printStr(string str)
{
Console.WriteLine(str);
}
}
class B:A
{
public override void printStr(string str)
{
str=str+"(重写的方法)";
Console.WriteLine(str);
}
}
class DefaultInitializerApp
{
public static void Main()
{
B b=new B();
A a=b;
a.printStr("打印");
b.printStr("打印");
Console.ReadLine();
}
}
运行程序后将在控制台窗口打印( )。(选择一项)
a. 打印 重写的方法
b. 打印 打印 重写的方法
c. 打印
d. 程序有误，不能运行

14．在C#的语法中，（）关键字可以实现在派生类中对基类的虚函数进行重载（选一项）
a> override
b> new
c> static
d> virtual

15．对下面的C # 程序:
using System;
publicinterface IAccount
{
void PosInterest();
void DeductFees(int feeSchedule);
}
class BusinessAccount : IAccount
{
int A;
publicstaticvoidMain()
{
BusinessAccount B = new BusinessAccount();
Console.WriteLine(B.A);
Console.ReadLine();
}
publicvoid IAccount.PostInterest()
{
A = A+1;
}
publicvoid IAccount.DeductFees(int feeSchedule)
{
A = A + feeSchedule;
}
}
以下的说法正确的是 ( ) (选择一项)
a) 程序将出现编译错误,指示不能在实现接口BusinessAccount的类中定义成员 A.
b) 程序将出现编译错误,指示Public关键字对接口项无效
c) 程序编译正常,但是出现运行时错误,指示变量A没有初始化
d) 程序将正常运行,输出为0

16.可以使用（）关键字重写方法。
A. Override
B. new

17.（）可以看作类的模具。
A. 抽象类
B. 接口
C. 虚方法

18.请问，此程序输出结果是()
abstract class BaseClass{
public virtual void MethodA(){Console.WriteLine("BaseClass");}
public virtual void MethodB(){}
}
class Class1: BaseClass{
public void MethodA(){Console.WriteLine("Class1");}
public override void MethodB(){}
}
class Class2: Class1{
new public void MethodB(){}
}
class MainClass{
public static void Main(string[] args){Class2 o = new Class2();o.MethodA(); }
}
A. BaseClass
B. BassClass Class1
C. Class1
D. Class1 BassClass

19.请问，此程序输出结果是()
public abstract class A { public A() { Console.WriteLine('A'); }
public virtual void Fun() { Console.WriteLine("A.Fun()"); } }
public class B: A { public B() { Console.WriteLine('B'); }
public new void Fun() { Console.WriteLine("B.Fun()"); }
public static void Main() { A a = new B();a.Fun(); } }
A. A B A.Fun()
　　　B. A B B.Fun()
　　　C. B A A.Fun()
　　　D. B A B.Fun()

20.以下叙述正确的是()：A. 接口中可以有虚方法。   
B. 一个类可以实现多个接口。C. 接口不能被实例化。      
D. 接口中可以包含已实现的方法。

21．以下关于C#代码的说法正确的是（）。（选择一项）
Public abstract Animal
{
Public abstract void Eat();
Public void Sleep()
{
}
}

a. 该段代码正确
b. 代码错误，因为类中存在非抽象方法
c. 代码错误，因为类中的方法没有实现
d. 通过代码“Animal an = new Animal();”可以创建一个Animal对象

22.在c#中，关于继承和接口，以下说法正确的是() （单选）
a. c#允许许多接口实现,也允许多重继承
b.c#允许多接口实现，但不允许多重继承
c.c#不允许多接口实现，但允许多重继承
d.c#不允许多重接口实现，也不允许多重继承

23) 在C#中，已知下列代码的运行结果是“老虎吃动物”，请问在空白处1和空白处2
分别应该填写的代码是()
Public class Animal
{
Public 空白处1 void Eat()
{
Consone.WriteLine(“我要吃”)；
}
}
Public class Tiger:Animal
{
Public 空白处2 void Eat()
{
Consone.WriteLine(“老虎吃动物”)；
}
Public calssTest
{
Static void Main()
{
Animal an = new Tiger();
an.Eat;
}
}
}
a) Virtual , new
b) override , virtual
c) virtual , override
d) new , virtual

24) 在C#中，下列关于抽象类和接口的说法，正确的是）()（选择一项）
a) 在抽象类中，所以的方法都是抽象方法
b) 继承自抽象类的子类必须实现起父类（抽象类）中的所以抽象方法
c) 在接口中，可以有方法实现，在抽象类中不能有方法实现
d) 一个类可以从多个接口继承，也可以从多个抽象类继承

25) 关于以下C#代码的说法正确的是()
Public abstract class Animal{
Public abstract void Eat();
}
Public class Tiger:Animal{
Public override void Eat(){
Console.WriteLine(“老虎吃动物”);
}
}
Public class Tigress:Tiger{
Static void main(){
Tigress tiger=new Tigress();
Tiger.Eat();
}

}
a) 代码正确,但没有输出
b) 代码正确,并且输出为”老虎吃动物”;
c) 代码错误,因为Tigress类没有实现抽象基类Animal中的抽象方法
d) 代码错误,因为抽象基类Animal的Eat方法没有实现

26) 在c#中 某程序员定义了一个IDataBase接口，以与实现该接口的类CDataBase ,下列关于该段代码说法正确的是（）（选择一项）
publicinterface IDataBase
{
void OpenTable(string tableName);
void UpDataTable(string tableName);
}
publicclass CDataBase:IDataBase
{
publicvoid OpenTable(string tableName)
{
Console.WriteLine("打开数据表");

}
publicvoid UpdataTable(string tableName)
{
Console.WriteLine("更新数据表");

}
staticvoidMain()
{
CDataBase db = new CDataBase();
db.OpenTable("Customers");
}
}

a)该段代码错误，因为在定义接口时，接口中的方法没有提供实现
b)该段代码错误，因为接口中声明的方法不是公有的，应此在CDataBase类中不能访问接口中的方法
c)该段代码正确，同时由于客户没有调用UpdataTable方法，可以把CDataTable类中的UpdataTable去掉，代码仍然正确
d)该段代码正确，但是如果在IDataBase 接口中声明一个方法void Execute(string sql); 则必须在CDataBase中实现该方法

27.C#中 下列代码运行结果是（）（选择一项）
publicclass Student{
publicvirtualvoid Exam(){
Console.WriteLine("学生都要考试");
}
}
publicclass Undergraduate:Student{
publicnewvoid Exam(){
base.Exam();
Console.WriteLine("大学生有选择考试科目的权利");
}
}
publicclass Test{
staticvoidMain() {
Student stu = new Undergraduate();
stu.Exam();
}
}
a)学生都要考试
b)大学生有选择考试科目的权利
c)大学生都要考试
大学生有选择考试科目的权利
d)学生都要考试
学生都要考试

28）c#中 下列代码的运行结果是（）（选择一项）
struct Student{
publicint age;
publicstring name;
public Student(int age,string name){
this.age=age;
this.name=name;
}
}
publicclass Test{
staticvoid Mian(){
Student stu1= new Student(18,"小方");
Student stu2= new Student(24,"小刚");
stu2=stu1;
stu1.age=30;
stu1.name="小燕";
Console.WriteLine(stu2.age);
Console.WriteLine(st2.name);
}
}
a)18 小方
b)18 小燕
c)30 小燕
d)30 小方

29）在C#中，下列（）关键字用于重写基类的虚拟方法。（选择一项）
a)override
b)new
c)base
d)virtual

委托和事件
C#面向对象编程-委托和事件 

1．阅读以下C#代码
 Namespace tevent
 { 
public delegate void notify5();  
class eventTest  
{  
  public void Raise5(int I)   
{   
   if(I%3==1)         Got5();
}
public event notify5 Got5;
}
 class Handlers  
{    
  public static void Method1()  
 {   
    Console.WriteLine("时间处理完成");   
}  
} 
 class class10  
{    
  static void Main(String[] args)   
{    
   eventTest eObj=new eventTest();  
   eObj.Got5+=new notify5(Handlers.Method1);      
for(int t=0;t<5;t++)    
{    
    int y=t*2+1;       eObj.Raise5(y);    
} 
   Console.WriteLine();   }  
} 
代码允许的结果为（）。
 A）控制台窗口不能出任何信息。 
B）在控制台窗口输出“时间处理完成”1次 
C）在控制台窗口输出“时间处理完成”2次 
D）在控制台窗口输出“时间处理完成”5次
2.声明一个委托public delegate int myCallBack(int x); 则用该委托产生的回调方法的原型应该是() 
A. void myCallBack(int x) 
B. int receive(int num)
 C. string receive(int x) 
D. 不确定的
3.C#中，关于事件的定义正确的是（）。
 a)private event OnClick();   
b)private event OnClick; 
c)public delegate void Click();public event Click void OnClick();   
d)public delegate void Click();public event Click OnClick

4. 在C#中，下列代码的运行结果是(). 
Public delegate void BuyTicketDelegate(string num);
 Public class Student 
{ 
Public event BuyTicketDelegate btEvent;
 Public Student(string num) 
{ 
btEvent+= new BuyTicketDelegate(this.BuyTicket); 
}
Public void ShowNum(string num) 
{ 
btEvent(num); 
} 
Private void BuyTicket(string num) 
{ 
Console.WriteLine(“我要买”+num+”次车票”); 
}
}
Static void Main() 
{ 
Console.WriteLine(“创建学生对象”); 
Student stu = new Student(“TI”);
 Console.WriteLine(“创建完毕”); 
Stu.ShowNum(“TI”); 
}
a) 创建学生对象   创建完毕 
b) 创建学生对象   我要买TI次车票  创建完毕
 c) 创建学生对象   创建完毕     我要买TI次车票 
d) 我要买TI次车票     创建学生对象     创建完毕

C#面向对象编程-封装
1．C#语言使用（）来引入名称空间。
a) Import
b) Using
c) Include
d) Lib

2．在.NET中,以下关于命名空间的描述,正确的是().(选择一项)
a) 命名空间不可以进行嵌套
b) 在一个.cs文件中,只能存在一个命名空间
c) 使用private修饰的命名空间,其内部的类也不允许访问
d) 命名空间使得代码更加有条理、结构更清晰

3．在C#类中( ) 选一项
a) 允许有多个一样名称的构造函数
b) 允许有多个不同名称的构造函数
c) 至少要有一个构造函数
d) 只能有一个构造函数

4．在C#中，可以直接在名称空间内声明如下类型，除了（）
A）数组
B）接口
C）结构
D）委托

5．C#程序中的类myClass中的成员变量var1如下：
public class myClass { … private int var1；…
则可以访问var1的有（）。（选择一项）
a) myClass中包含的类
b) myClass的继承类
c) myClass的父类
d) 和myClass在同一命名空间下的类

6．下列关于类方法的声明，正确的是（）（选择两项）
a) 方法定义类所许可的行动
b) 从一个类创建的所有对象可以使用同一组属性和方法
c) 每个方法应该有一个参数
d) 如果在不同类中定义了类似的操作，刚他们的行为不应该是类似的

7．析构函数的语法是（）
semester(){ //析构函数的实现}
A.对
B.错
8．C#类中的构造函数的特点是（ ）选一项
a) 一个类中，只能有一个构造函数
b) 构造函数的名称与类名一样
c) 构造函数在对象销毁时自动执行
d) 要求构造函数至少有两个参数

9．针对以下C#代码
Using System;
Public class Teacher
{
Public string teacherName;
Public string teacherSubject;
Public Teacher(String name){
This.teacherName=name;
}
Public Teacher(String subject){
This.teacherSubject = subject;
}
Public Teacher(String name, String subject){
This.teacherName=name;
This.teacherSubject = subject;
}
}
以下说法正确的是（）（选择一项）
A）上述代码编译无错误，类中存在三个构造函数
B）上述代码编译有错误，因为类中只能有一个构造函数
C）上述代码编译有错误，因为类中有两个具有一样参数类型的构造函数
D）上述代码编译有错误，以为类中没有不带参数的构造函数

10．阅读以下的C#代码：
Namespace t3_6{
Namespace Ford {
Public class Mustang {
Public void printMust() {
Console.WritleLine(“In namespace Ford”);
}
}
}
}
class Class1{
static void Main(string[] args) {
Mustang must1=new Mustang();
must1.printMust();
Console.ReadLine();
}
}
代码运行结果为(D)。(选择一项)
a. 什么都不显示
b. 在控制台打印”In namespace Ford”，用户输入任何数据退出
c. 在控制台打印”In namespace Ford”，立即退出
d. 提示代码有错误，不能执行

11．以下的C#代码段，使用了using别名指令：
Using T(1) A.B.C; //A.B.C为某类的完全限定名
Class MyClass
{
Static void Main() { T M=new T(); }
}
则代码段中（1）处应填写的操作符或者关键字（）（选一项）
a> As
b> =
c> ==
d> Instead

12．C#语言使用（）来引入名称空间。
a) Import
b) Using
c) Include
d) Lib

13.()关键字是类型和类型成员的访问修饰符。(D)内部成员只有在同一程序集中的文件内才是可访问的。
A. publicB.privateC.protectedD.internalE.sealed

14.下列哪些说法是错误的()
A. 抽象类可以实例化。
B. 不可以改变常量的值.
C. 可以使用 this 引用静态方法或属性访问器.
D. readonly 变量只能在构造函数中赋值.
E. 一个父类的private 成员可以在子类中直接调用.

15.请问，Class1.Count的值是多少？()
class Class1{public static int Count = 0;
static Class1(){Count++;}
public Class1(){Count++;}
}
public static void Main() {
Class1 o1 = new Class1();//1
Class1 o2 = new Class1();//5
Console.WriteLine(Class1.Count); }
A. 1
B. 2
C. 3
D. 4

16.下面的代码实现了设计模式中的（）模式
　　public class A {　　private A instance;　　private A() {　}
　　public static A Instance {　get　{　　if ( A == null )　　A = new A();　　return instance;}　　}　　}
A. Factory
　　　B. Abstract Factory
　　　C. Singleton
　　　D. Builder

17.下面的代码实现了设计模式中的（）模式
public sealed class SampleSingleton1{private int m_Counter = 0;　　
private SampleSingleton1(){Console.WriteLine(""初始化SampleSingleton1。"");}
public static readonly SampleSingleton1 Singleton = new SampleSingleton1();
public void Counter(){m_Counter ++;}}
A. 原型
　　　B. 抽象工厂
　　　C. 单例D. 生成器

18）在c＃中，()访问修饰符修饰的变量只能由当前程序集访问。（选择一项）
A）public
B)protected
C)indernal
D)private

19)在C#中，关于以下C#代码的说法正确的是()
Namespace Microsoft{
Class Student{
string type=”北大青鸟学员”;
Internal string name =”李明”;
}
Public class Test{
Static void Main(){
Student stu=new Student()//1
Console.WriteLine(stu.type);//2
Console.WriteLine(stu.name);//3
}
}
}
a) 代码1错误
b) 代码2错误
c) 代码3错误
d) 代码都正确

20）在C#中，下列关于构造函数的特点的说话，正确的是（）（选择一项）
a) 一个类中，只能有一个构造函数
b) 构造函数的名称与类名称一样，并且没有返回类型
c) 构造函数在对象销毁时自动执行
d) 一个类中至少要有一个构造函数

21) 在C#中，关于构造函数的说法正确的是（）（选择一项）
a) 在一个类中允许有多个构造函数，构造函数在创建对象是调用
b) 在一个类中允许有多个不同名称的构造函数
c) 一个类至少声明有一个构造函数
d) 一个类中只能有一个构造函数

17 / 17