面向对象程序设计题库 - (2013)

（一）面向对象程序设计（共124题，占83%）

[完成]面向对象相关概念（共7题，占5%）

1、 什么是面向对象？(知识点：面向对象的概念；难度：简单题)（5分）

面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程OOP； 通俗的解释就是万物皆对象，把所有的事物都看作一个个可以独立的对象(单元)，它们可以自己完成自己的功能。

2、 阐述面向接口、面向对象编程的区别。(知识点：面向对象的概念；难度：简单题) （5

分）

面向对象可以理解为以一切元素都是对象，在设计时以对象为单位，考虑它的属性及方法。设计中采用了封装、继承、抽象的手法

面向接口本身就是面向对象的，无所谓区别，只不过面向接口的好处是耦合性低

3、 面向对象的思想主要包括什么？(知识点：面向对象的概念；难度：简单题) （5分） 继承：子类拥有父类的所有数据和操作。

封装：用抽象的数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型内。

多态：一个程序中同名的不同方法共存的情况。有两种形式的多态–重载与重写。

4、 什么是类？(知识点：类的概念；难度：简单题) （5分） 把一些具有共性的对象归类后形成一个集合，它将数据以及这些数据上的操作封装在一起。

5、 类有哪些成员？(知识点：类的概念；难度：简单题) （5分）

字段、属性、方法、事件、运算符、索引器、构造函数、析构函数、嵌套类型。

6、 请详述类(class)与结构(struct)的异同？(知识点：类的概念；难度：简单题) （5分） Class可以被实例化,属于引用类型,是分配在内存的堆上的,Struct属于值类型,是分配在内存的栈上的.

（1、 结构的成员不能赋初值, 类可以

（2、 结构不能有继承，但可以实现接口，类都可以 （3、 结构不能有空构造函数，类可以

（4、 结构可以定义带参的构函数，负责初始化所有的成员字段

7、 请简述类和对象的关系。(知识点：类和对象；难度：简单题) （5分）

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

[完成]类的属性和方法（共28题，占19%）

1、 读程序写结果：（类的方法、简单题）（5分） static void Main(string[] args)

{

myclass c = new myclass(); c.showmsg();

Console.ReadKey(); }

class myclass {

private string msg; public void showmsg() {

msg = \ Console.WriteLine(msg); } }

答：Hello World

2、 编一个程序，定义类student和它的属性（学号,姓名,年龄，成绩）,用类student生

成对象s,分别对对象s的成员赋值，然后输出对象s。（难易度：简单题；知识点：类的属性）（5分）

public class student {

public int ID{get;set;}

public string name{get;set;} public int age{get;set;} public float grade{get;set;} }

student s=new student(); s.ID=1234;

s.name=\爱迪生\ s.age=123; s.grade=187f;

Response.Write(s.ID+s.name+s.age+s.grade);

3、 下列代码的运行结果是什么（难易度：简单题；知识点：类的属性和方法）（5分） using System; class Test {

static void Main() {

Student stu = new Student(105); Console.WriteLine(stu.Age); stu.Age = 100;

Console.WriteLine(stu.Age); }

}

public class Student {

private int age = 10; public int Age {

get {

return this.age; } set {

if(value > 0 && value <= 100) {

this.age = value; } } }

public Student(int age) {

this.age = age; } }

答案：105

100

4、 编一个程序，定义类(有姓名，年龄，手机号码三个字段)，再定义一个一维数组，使数

组元素为类，存入2条数据，然后依次输出,使用for循环语句进行输入输出操作。（难易度：难；知识点：类的属性）（10分）

public class Peo

{

public string name { get; set; } public int age { get; set; } public long phone { get; set; } }

protected void Page_Load(object sender, EventArgs e) {

Peo[] pp = new Peo[2];

for (int i = 0; i < 2; i++) {

pp[i] = new Peo(); }

for (int i = 0; i < 2; i++) {

pp[i].name = \安神补脑\

pp[i].age = i;

pp[i].phone = 123456789101; }

for (int i = 0; i < 2; i++) {

Response.Write(pp[i].name + pp[i].age + pp[i].phone); }

}

5、 定义一个描述学生通讯录的类，数据成员包括下列属性：姓名、学校、电话号码和邮编。

（难易度：简单；知识点：类的属性）（5分） public class StudentAddressList {

public string StudentName { get; set; }

public string SchoolName { get; set; }

public string Phone { get; set; } }

6、 定义一个员工类和员工教育经历类，体现出他们是一对多的关系。（难易度：较难；知

识点：类的属性）（10分）

public class Employee {

public int ID { get; set; } public string Name { get; set; } }

public class Education {

public int ID { get; set; } public string Edu { get; set; }

}

7、 编写一个程序，在其中创建物体类PhysicalObject，通过公有属性来访问其重量、体积、

密度，并通过公有方法来判断该物体是否会在水中下沉。（难易度：简单；知识点：类的属性和方法）（10分）

Public class PhysicalObject {

public double weight{get;set;} public double volume{get;set;} public double Density{ get;set;} public string kk() {

return (Density > 1 ? “下沉” : “不下沉”);

} }

8、 期末有三科成绩：语文、数学、英语，定义成类的属性

在类中写两个方法：（1）计算总成绩（2）计算平均成绩 （难易度：简单；知识点：类的属性和方法）（10分）

public class cs {

public float ch { get; set; } public float en { get; set; } public float ma { get; set; } public float Sum() {

return ch + en + ma; }

public float Ave() {

return (ch + en + ma) / 3; } }

9、 定义一个矩形类，有长、宽两个属性，在类中写计算周长和面积的方法 （难易度：简单；知识点：类的属性和方法）（10分）

public class jx

{

public float l { get; set; } public float k { get; set; } public string Cir() {

return (l + k) * 2; }

public string Area() {

return l * k; }

} 10、 计算产品总金额 属性：商品数量、商品价格 方法：计算商品金额（不打折）、计算商品金额（打折），这是两个重载 （难易度：简单；知识点：类的属性和方法）（10分） public class sp {

public float sl { get; set; } public float jg { get; set; }

public float Money() {

return sl * jg; }

public float Money(float rate) {

return sl * jg * rate; } } 11、 期末有三科成绩：语文、数学、英语，定义成类的属性 在类中写两个方法：（1）计算总成绩（2）计算平均成绩（3）添加一个构造函数为三科成绩赋值。（难易度：简单；知识点：类的属性和方法）（10分）

public class cs {

public float ch { get; set; } public float en { get; set; } public float ma { get; set; } public float Sum() {

return ch + en + ma; }

public float Ave() {

return (ch + en + ma) / 3; }

Public cs(float c,float e,float m) {

ch=c; en=e; ma=m;

}

}

12、 定义轿车类，其有颜色、重量、出厂日期字段，使用年限属性。并实例化对象car1

和car2，编译和调试轿车类。（难易度：简单；知识点：类的属性）（5分）

public class jc {

public string ys { get; set; } public float weight { get; set; } public DateTime time { get; set; } public int useyear{get;set;} }

protected void Page_Load(object sender, EventArgs e)

{

jc car1 = new jc(); jc car2 = new jc(); car1.ys = \红色\

car1.weight = 273.32f;

car1.time = Convert.ToDateTime(\ car2.ys = \黑色\

car2.weight = 2.3452f;

car2.time = Convert.ToDateTime(\

Response.Write(car1.ys + car1.weight + car1.time + car2.ys + car2.weight + car2.time);

} 13、 什么是装箱和拆箱？(知识点：装箱、拆箱；难度：简单题) （5分）

装箱：把值类型转换为引用类型 拆箱：把引用类型转换为值类型 14、 描述一下C#中索引器的实现过程，是否只能根据数字进行索引？(知识点：类成员；难度：简单题) （5分）

答：public 类型 this[检索条件] {

get

{ //根据检索条件取值} set

{ //根据检索条件赋值} }

索引器是用来封装类中的数组或集合的成员。索引器的参数表示检索成员的条件，没有参数类型的限制，但是参数个数至少有1个。 15、 定义一个圆类，包含半径属性，获取圆面积方法和圆周长方法。（难易度：简单；知识点：类的属性和方法）（10分）

public class yuan {

public string j(float r) {

return \面积为：\周长为：\ } } 16、 定义汽车类，添加属性:牌号、颜色、重量、出厂日期，创建一个轿车对象,初始化

一辆完整的车辆。（难易度：简单；知识点：类的属性）（5分）

public class car {

public string h; public string y;

public string z;

public DateTime time; }

protected void butque_Click(object sender, EventArgs e) {

car che = new car(); che.h = tethao.Text; che.y = tetyan.Text; che.z = tetzhong.Text;

che.time = Convert.ToDateTime(tettime.Text);

lalti.Text = \车辆信息为：\che.time.ToString();

} 17、 定义一个班级类，包含辅导员、班级名称、所属系部、人数属性，其中人数不能超过60人。（难易度：简单；知识点：类的属性）（5分）

public class ban {

public string fu { set; get; } public string name { set; get; } public string xi { set; get; } public int ren { get; set; }

public virtual string info(string x, string y, string z, int c) {

fu = x; name = y; xi = z;

if (c <= 0 || c > 60) {

return \输入人数错误！\ } else {

return \辅导员为：\班级为：\系部为： \\人数为：\

} } }

18、 定义一个圆类，包含半径属性，编写获取圆面积方法和圆周长方法。实例化一

个圆对象，输出圆的面积和周长。（难易度：简单；知识点：类的属性和方法）（10分）

public class yuan

19、 {

20、 public float r { get; set; } 21、 public string sh() 22、 {

23、 return \面积：\24、 }

25、 public string sj() 26、 {

27、 return \周长：\28、 } 29、 } 30、

31、 protected void Button2_Click(object sender, EventArgs e) 32、 {

33、 yuan s = new yuan(); 34、 s.r = 4;

35、 Response.Write(s.sh() + s.sj()); 36、 }

37、 定义一个长方体类，包含长、宽、高属性，编写获取长方体体积方法和长方体表面

积方法。实例化一个长方体对象，输出长方体的体积和表面积。(知识点：类成员、方法、对象；难度：较难题) （10分）

public class cft {

public float chang { get; set; } public float kuan { get; set; } public float gao { get; set; } public string sh() {

return \表面积：\gao * 2);

}

public string sj() {

return \周长：\ } }

protected void Button2_Click(object sender, EventArgs e) {

cft sk = new cft(); sk.chang = 32; sk.kuan = 32; sk.gao = 56;

Response.Write(sk.sh() + sk.sj()); } 38、 创建一个班级类，包含辅导员、班级名称、所属系部、人数等相关信息，实例化对

象”_0900103班”，编译和调试班级类。（难易度：简单；知识点：类的属性和方法）

（10分）

class Class {

public string classname; public string teachername; public int sum;

public string department; }

Class myc = new Class();

Myc.classname=\0900103班\; 39、 创建一个长方形类，其有长和宽两个属性，并能计算周长和面积。在程序中创建一

个长和宽分别为10和5的长方形，并打印出该长方形的长、宽、周长和面积。（难易度：简单；知识点：类的属性和方法）（10分） class rectangle {

public float length { get; set; } public float width { get; set; }

public float area() {

return length * width; }

public float zhouchang() {

return (width + length) * 2; } } 40、 定义People类，有两个属性Name、Sex，一个方法print()，用以输出people的

信息。（难易度：简单；知识点：类的属性和方法）（10分） class People {

public string Name { get; set; } public string Sex { get; set; }

public string print() {

return \ }

} 41、 完成学生类的建立（提示：建立三个字段分别是xuehao，name，birthday并为其

添加字段；添加一个方法输出学生的相关信息，其输出格式为：

“姓名：张三 学号：00000000 生日：1989-12-12”。（难易度：简单；知识点：

类的属性和方法）（10分）

class Student {

public string xuehao; public string name;

public DateTime birthday;

public string print() {

return \姓名：\+ name + \学号：\+ xuehao + \生日：\+ birthday; } }

42、 创建人类，有姓名、性别、出生日期、年龄、身份证号码这5个公有属性。再添加

一个公有方法ShowInfo()返回一个字符串，包含此人的所有信息，格式为“我叫***，性别*，出生日期是********，今天*岁，我的身份证号码是********。”，并在程序中输出显示。（难易度：简单；知识点：类的属性和方法）（10分） class Person {

private string name; private string sex; private string birthday; private int age;

private string IDcard;

public string Name { get; set; } public string Sex{ get; set; } public string Birthday{ get; set; } public int Age{ get; set; }

public string idcard{ get; set; } public string ShowInfo() {

return \我叫\性别\出生日期是\今天\Age + \岁,我的身份证号码是\。\ } } 43、 创建时间Shijian类，它包含3个整型字段：Hour、Minute、Second，它们用于表

示采取统一时间格式（24小时时钟格式）的一个时间。并定义一个不含参数的

ToUniversalString方法，该方法采用统一时间格式返回一个字符串，它包括6个数位－－2个表示小时，2个表示分钟，2个表示秒。创建Shijian类的2个实例，编译和调试Shijian类。（难易度：难题；知识点：类的属性和方法）(00:00:00)（15分）

public class Shijian {

public int Hour; public int Minute; public int Second; public string method() {

Return Hour.ToString(\)+ Minute.ToString(\)+ Second.ToString(\)

}

} 44、

（难易度：较难；知识点：类的属性和方法）（15分）完成一个四则运算程序

1） 2） 3） 4） 5）

要求填入要进行“加减乘除”的两个数字，点击“＝”，得出答案。 如果是除法，除数不能为0。 文本框必须填入数字。（使用try?catch?.） 建立一个四则运算类完成 类名：jishuan

成员变量：第一个数、第二个数 属性：第一个数、第二个数

方法四个：求和的方法、求差的方法、求积的方法、求商的方法

6） 在程序中调用这个类，得到计算结果 45、 写一分数计算程序。选手上台表演，有七个裁判打分。计分规则是去掉一个最高分

和最低分，把剩下的5个分相加就是该选手的最后得分。（难易度：难；知识点：类的

属性和方法）（10分）

public class getsum {

public float[] b { get ; set ; } public float method() {

float sum = 0;

for (int i = 0; i < b.Length; i++) {

sum += b[i]; }

return sum - b.Max() - b.Min(); } }

46、 请叙述属性与索引器的区别。（难易度：难；知识点：类的属性和方法）（5分） 属性 索引器 通过名称标识。 通过签名标识。

通过简单名称或成员访问来访问。 通过元素访问来访问。 可以为静态成员或实例成员。 必须为实例成员。

属性的 get 访问器没有参数。 索引器的 get 访问器具有与索引器相同的形参表。

属性的 set 访问器包含隐式 value 参数。 除了 value 参数外，索引器的 set 访问器还具有与索引器相同的形参表。

[完成]关键字（共3题，占2%）

1、 简述 private、 protected、 public、 internal 修饰符的访问权限。（难易度：简单；知识点：关键字）（5分）

private : 私有成员, 在类的内部才可以访问。

protected : 保护成员，该类内部和继承类中可以访问。 public : 公共成员，完全公开，没有访问限制。 internal: 在同一程序集内可以访问。

2、 很多类被定义为public有什么意义？（难易度：简单；知识点：关键字）（5分） public 关键字将公共访问权限授予一个或多个被声明的编程元素。对公共元素的可访问性没有限制。

3、 用sealed修饰的类有什么特点。（难易度：简单；知识点：关键字）（5分）

sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其他类的基类，则会发生编译时错误。 密封类不能同时为抽象类。

4、 静态成员和非静态成员的区别？（难易度：简单；知识点：关键字）（5分）

静态变量使用 static 修饰符进行声明，静态成员在加类的时候就被加载（在类被实例化时创建，哪个对），通过类进行访问；

不带有static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问；

一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值。

5、 简述静态类和静态成员。（难易度：简单；知识点：关键字）（5分）

静态类中的成员都必须是静态的。静态类无构造方法，并且是密封类无法被继承。

静态成员访问时只能通过类名来访问，不能通过对象访问（和JAVA有区别），this也无法访问静态成员。

6、 怎样理解静态变量？静态成员和非静态成员的区别？（难易度：简单；知识点：关键字）

（5分）

静态变量属于类，而不属于对象；并对所有对象所享；静态成员在加类的时候就被加载。

7、 const和readonly区别。（难易度：简单；知识点：关键字）（5分） 都可以标识一个常量。主要有以下区别：

1、初始化位置不同。const必须在声明的同时赋值；readonly即可以在声明处赋值，也可以在静态构造方法（必须是静态构造方法，普通构造方法不行）里赋值。

2、修饰对象不同。const即可以修饰类的字段，也可以修饰局部变量；readonly只能修饰类的字段

3、const是编译时常量，在编译时确定该值；readonly是运行时常量，在运行时确定该值。

4、const默认是静态的；而readonly如果设置成静态需要显示声明 5、修饰引用类型时不同，const只能修饰string或值为null的其他引用类型；readonly可以是任何类型。

8、 using和new这两个关键字有什么意义，请写出你所知道的意义？（难易度：简单；知识点：关键字）（5分）

using引入名称空间或者使用非托管资源

new新建实例或者隐藏父类方法

9、 new有几种用法？（难易度：简单；知识点：关键字）（5分） 1、new 运算符，创建对象，调用构造函数

2、new 修饰符 覆盖方法，隐藏父类的成员。public new XXXX(){} 3、new 约束 用于在泛型声明中，约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。当泛型类创建类型的新实例时，将此约束应用于类型参数，当与其他约束一起使用时，new() 约束必须最后指定。如：

public class ItemFactory where T : IComparable, new() {}

10、 构造方法是否可被重写? （难易度：简单；知识点：关键字）（5分） 构造方法不能被继承，因此不能重写Override，但可以被重载。 11、 读程序写结果：（难易度：简单；知识点：关键字）（5分）

class Program {

static void Main(string[] args) {

myclass.showpassword(); Console.ReadKey(); }

}

class myclass {

private static string password; public myclass() { }

static myclass() {

password = “ABCD”; }

public static void showpassword() {

Console.WriteLine(password); } }

12、 读程序写结果：（难易度：简单；知识点：关键字）（10分）

class Program {

static void Main() {

int i1 = 10; int i2 = 20;

string str = \

Class1 c = new Class1(); Class1.Add(i1);

Class1.AddWithRef(ref i2); Class1.Add(c.i);

Class1 .StringConvert(str); Class1 .StringConvert(c); Console.WriteLine(i1); Console.WriteLine(i2); Console.WriteLine(c.i); Console.WriteLine(str); Console.WriteLine(c.str); Console.ReadKey(); }

public class Class1 {

public string str = \ public int i = 0;

public static void StringConvert(string str) {

str = \ }

public static void StringConvert(Class1 c) {

c.str = \ }

public static void Add(int i) {

i++; }

public static void AddWithRef(ref int i) {

i++; } }

}

3、读程序写结果（难易度：简单；知识点：关键字）（5分） class Program {

static void Main() {

class1 c1 = new class1(); class1.y = 5; c1.Output();

class1 c2 = new class1(); c2.Output(); } }

public class class1 {

private static int x = 0; public static int y = x; public int z = y; public void Output() {

Console.WriteLine(class1.x); Console.WriteLine(class1.y); Console.WriteLine(z); } }

[部分完成]重载（共7题，占5%）

1、 创建一个类MyMath，并为其添加一个方法Add，实现两个整数相加，并重载该方法，实

现两个字符串的相加。（难易度：简单；知识点：重载方法）（15分）

class MyMath {

public int add(int a,int b) {

return a + b; }

public string add(string a, string b) {

return a + b; }

}

2、 什么是方法的重载？（难易度：难；知识点：重载）（5分） （1）.方法名一定要相同。

（2）.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。 如果参数个数不同，就不管它的参数类型了！

如果参数个数相同，那么参数的类型或者参数的顺序必须不同。 （3）.方法的返回类型、修饰符可以相同，也可不同。

3、 定义一个猫类，其字段有颜色、出生日期、性别。分别添加公有属性。添加一方法输出

猫的叫声“喵”，添加一方法输出“猫扑老鼠”,并为猫添加构造函数，通过参数的形式传递猫的颜色，出生日期和性别。最后在主方法中实例化对象。（类及其成员、构造函数及其重载、较难题）（15分）

4、 设计一个长方形类，包含有成员：长、宽两个属性；无参构造方法和带参构造方法用于

初始化长方形；计算长方形的周长和面积的方法。在应用程序中用帶参构造方法创建若干个长方形对象，并打印该长方形对象的长、宽、周长和面积。（类及其成员、构造函数及其重载、较难题）（15分） 5、 （类及其成员、难题）（15分）构造函数及其重载、有一家销售公司，其工资发放规则

如下 职务 经理 主任 普通员工 兼职 基本工资 1500 1000 600 0 业务提成 20％ 18％ 15％ 12％

1)完成程序：要求选择员工的职务类型，输入销售额，得到工资总额。

工资总额＝基本工资＋ 销售额*业务提成比例 2)建立一个工资计算类完成。 3)提示：

输入信息有：职务、销售额 输出信息：工资额

类名：salary

成员变量：职务、销售额

方法：计算工资，要求返回double，使用swith?case?控制结构

4)在程序中调用这个类，得到结果

6、 （类及其成员、构造函数及其重载、难题）（15分）定义一个正方形类，包含左上角

的坐标（x,y）、边长字段(bianchang)。并为所有字段添加可读和可写的属性。添加一个无参数的构造函数，坐标默认为0，0，边长也为0，添加一个带坐标参数的构造函数，边长为0，添加一个带坐标和边长参数的构造函数；添加一方法返回其坐标，添加一方法返回周长，添加一方法返回面积。最后在主方法中用自己定义的三个构造函数实例化三个正方形并输出其坐标、周长和面积。

7、 创建一个类，通过方法重载，在类中使用同一个方法名print分别执行输出整数、双精

度数与字符串的功能（难易度：易；知识点：重载）（15分）

类的继承（共32题，占21%）

1、 教师与学生信息管理。在学校里有很多教师、学生、办公室人员、清洁工、保安等人员，

管理部门可能经常要查看某位学生或教师等员工的基本信息。要求： ? 使用类的继承管理每类人员；

? 创建一个基类——人类Person，其中有两个属性：id（编号）和name（姓名），一个方法printInfo（输出编号和姓名）；

? 创建一个派生类——学生类Student，并为其添加一个属性grade（成绩），一个方法printGrade（输出成绩）;

? 创建一个派生类——教师类Teacher，并为其添加一个属性salary（工资），一个方法printSalary（输出工资）;

? 编写一个应用程序，创建一个学生或教师对象，并输入其基本信息，然后输出该学生或教师的信息。

（难易度：难；知识点：继承）（20分） public class Person {

public string id { get; set; } public string name { get; set; } public string printInfo() {

return \ } }

public class Student:Person {

public float grade { get; set; } public float printGrade() {

return grade; } }

public class Teacher:Person {

public float salary { get; set; } public float printSalary() {

return salary; } } 2、 读程序写结果：（难易度：较难；知识点：继承）（15分）

class Program {

static void Main() {

B b = new B(); Console.ReadKey(); }

class A {

public A() {

PrintFields(); }

public virtual void PrintFields() { } }

class B : A {

int x = 1; int y; public B() {

y = -1; }

public override void PrintFields() {

Console.WriteLine(\ } } }

3、 读程序写结果：（难易度：较难；知识点：继承）（15分） class Program {

static void Main() {

Console.WriteLine(\ Console.ReadKey(); }

class A {

public static int X; static A() {

X = B.Y + 1; } }

class B

{

public static int Y = A.X + 1; static B() { } } }

4、 读程序写结果（难易度：较难；知识点：继承）（15分） class Program {

static void Main() {

Class2 o = new Class2(); o.MethodA();

Console.ReadKey(); }

abstract class BaseClass {

public virtual void MethodA() {

Console.WriteLine(\ }

public virtual void MethodB() { } }

class Class1 : BaseClass {

public void MethodA() {

Console.WriteLine(\ }

public override void MethodB() { } }

class Class2 : Class1 {

new public void MethodB() { } } }

5、 读程序写结果（难易度：较难；知识点：继承）（10分） class Program {

static void Main() {

A a = new B(); a.Fun();

Console.ReadKey(); }

public abstract class A {

public A() {

Console.WriteLine('A'); }

public virtual void Fun() {

Console.WriteLine(\ } }

public class B : A {

public B() {

Console.WriteLine('B'); }

public new void Fun() {

Console.WriteLine(\ } } }

6、 读程序写结果：（难易度：较难；知识点：继承）（ static void Main() {

B bb = new B(); bb.F();

Console.ReadKey(); }

class A {

protected int x = 123; }

class B : A

10分） {

public void F() {

A a = new A(); B b = new B();

Console.WriteLine(b.x); } }

7、 读程序写结果（难易度：较难；知识点：继承）（10分） class Program {

static void Main(string[] args) {

MyClass y = new MyClass(); BaseClass x = y; x.i = 100;

Console.WriteLine(\ } }

class BaseClass {

public int i; }

class MyClass : BaseClass {

public new int i; }

8、 读程序写结果（难易度：较难；知识点：继承）（15分） public class VirtualInheritSample {

public static void Main() {

DerivedClass c = new DerivedClass(); c.Call(); } }

public class BaseClass {

public void A() {

Console.WriteLine(\ }

public virtual void B() {

Console.WriteLine(\ } }

public class DerivedClass : BaseClass {

public new void A() {

Console.WriteLine(\ }

public override void B() {

Console.WriteLine(\ }

public void Call() {

this.A(); this.B();

((BaseClass)this).A(); ((BaseClass)this).B(); } }

9、 读程序写结果（难易度：较难；知识点：继承）（

public abstract class A {

public A() {

Console.WriteLine('A'); }

public virtual void Fun() {

Console.WriteLine(\ } }

public class B : A {

public B() {

Console.WriteLine('B'); }

public new void Fun()

10分） {

Console.WriteLine(\ }

public static void Main() {

A a = new B(); a.Fun(); } }

10、 读程序写结果（难易度：较难；知识点：继承）（10分） class Father {

public void F() { Console.WriteLine(\

public virtual void G() { Console.WriteLine(\ }

class Son : Father {

new public void F() { Console.WriteLine(\

public override void G() { Console.WriteLine(\ }

static void Main(string[] args) {

Son b = new Son(); Father a = b; a.F(); b.F(); a.G(); b.G(); }

11、 写出程序的输出结果：（难易度：较难；知识点：继承）（10分） 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); }

{

12、 阅读以下的代码：（难易度：较难；知识点：继承）（10分） abstract class A {

public abstract void printStr(string str); }

class B : A {

public override void printStr(string str) {

str = str + \重写的方法)\ Console.WriteLine(str); } }

public static void Main() {

B b=new B(); A a=b;

a.printStr(\打印\ b.printStr(\打印\ Console.ReadLine(); }

13、 读程序写结果（难易度：较难；知识点：继承）（10分） abstract class BaseClass {

public virtual void MethodA() {

Console.WriteLine(\ }

public virtual void MethodB() { } }

class Class1 : BaseClass {

public void MethodA()

{

Console.WriteLine(\ }

public override void MethodB() { } }

class Class2 : Class1 {

new public void MethodB() { } }

public static void Main(string[] args) {

Class2 o = new Class2(); o.MethodA(); }

答案：Class1

14、 下列代码运行结果（难易度：较难；知识点：继承）（10分） public class Student{

public virtual void Exam(){

Console.WriteLine(\学生都要考试\ }

}

public class Undergraduate:Student{ public new void Exam(){ base.Exam();

Console.WriteLine(\大学生有选择考试科目的权利\ }

}

static void Main() {

Student stu = new Undergraduate(); stu.Exam();

答案：学生都要考试

15、 （难易度：较难；知识点：继承）（15分）输入两个正整数，分别作为直角三角

形的两个直角边，求出斜边的长度。 提示：勾股定理 c2=a2+b2 Math.Exp

Math.Sqrt

要求继承前面的四则运算类，可以调用其中的求和的方法；在继承类中加写方法完成斜边的计算

16、 （难易度：较难；知识点：继承）（15分）设计一个人类Person，有一个虚方法

GetPerson()，输出“这是基类Person”，然后设计子类：学生类Student，并重写基类的虚方法，输出“这是学生类”；教师类Teacher，并重写基类的虚方法，输出“这是教师类”；医生类Doctor，并重写基类的虚方法，输出“这是医生类”。分别建立每个类的对象，分别输出各对象的信息。 17、 （难易度：较难；知识点：继承）（15分）计算机正方体和长方体的体积：创建

一个含有abstract的求体积的vol()方法抽象基类shape；派生一个子类正方体Cube，实现父类抽象方法vol()；创建子类Cube的对象，然后调用它的vol()方法；派生一个子类长方体Rectangle，实现父类抽象方法vol()；创建子类Rectangle的对象，然后调用它的vol()方法；创建一个应用程序测试系统。 18、 （难易度：较难；知识点：继承）（15分）定义一个体育活动类(Sports)作为基

类，它有一个进行活动的方法play（），足球(Football)和篮球(Bascketball)都是体育活动类的衍生类。请在测试类(Test)中编写一个方法howToPlay(Sports sp)，该方法要求传递一个Sports类型的参数。该方法的作用是：

1） 当传入的实例类型为Football时，控制台上应打印：足球是用脚踢的！ 2） 当传入的实例类型为Bascketball时，控制台上应打印：篮球是用手打的！ 在程序中调用howToPlay()验证代码。 19、 建立一个类和它的继承类，完成票价计算

基类：汽车

属性：距离、每公里的价格 方法：计算票价1

构造函数：初始化距离、每公里的价格

子类：豪华汽车 属性：空调附加费 方法：计算票价2

构造函数：空调附加费（注意构造函数的继承） （难易度：较难；知识点：继承）（15分） 20、 定义一个班级抽象类，有属性id、name，有一个抽象方法ShowInfo()，再定一个类

DriveClass继承myclass，在类中重写抽象类中的方法，输出id和name。调用这个方法。 （难易度：较难；知识点：继承）（15分）

21、 工资计算

教师：学历工资＋岗位工资＋职称工资＋课时费 保卫：岗位工资＋值班津贴 辅导员：学历工资＋岗位工资

定义一个基类，3个继承类实现工资计算

（难易度：较难；知识点：继承）（15分）

22、 票价计算 ? 基类：普通汽车：

? 属性：距离、每公里的价格 ? 方法：计算票价

? 继承类：豪华汽车

? ? ? ? ?

属性：空调附加费 方法：计算票价

继承类：卧铺车

属性：每公里加的价格 方法：计算票价

? 分别使用重写的方法

（难易度：较难；知识点：继承）（15分）

23、 （难易度：较难；知识点：继承）（20分）简易学生信息管理(用抽象类实现多态) 编写一个应用程序，利用方法的重写和多态性进行学生信息的简单管理，输出类似如下格式的学生信息：(高职学生输出总成绩；成教学生输出总学分)。

王静：高职类2年级学生，总成绩：248 刘丽：成教类1年级学生，总学分：26

说明：(1) 定义一个抽象类Students，在其中添加6个属性，分别对应于学生类别、姓名、进校年数、基础课成绩、专业课成绩、实训课成绩； 1个方法，计算总成绩；1个抽象方法，用于显示学生信息。

(2) 定义1个派生类StudentA，继承自抽象类，用于实现“高职”类学生信息的处理，在其中实现基类的抽象方法。

(3) 定义1个派生类StudentB，继承自抽象类，用于实现“成教”类学生信息的处理，在其中实现基类的抽象方法，并添加计算总学分的方法。

(4) 总成绩 = 基础课+专业课+实训课 总学分 = 总成绩 / 10

总学分为整数 24、 接口与继承的区别？什么时候使用接口，什么时候使用继承？ （难易度：较难；知识点：继承）（10分）

（1） 接口定义一个类型需要实现的方法，属性，索引和事件，包括可能的参数类型和返回值类型，而把具体的实现交由相应的类或结构来做，从而为组件提供多态能力。

（2） 继承常用于在一个现有父类的基础上的功能扩展，往往是我们将几个类中相同的成员提取出来放在父类中实现，然后在各自的子类中加以继承。 （3） 接口可以实现多接口继承，而继承只能实现单继承。

（4） 实现继承可继承父类型的实现，由于接口中没有定义方法的实现，因此必须实现继承后该接口的所有方法。 （5） 为父类型添加方法可能不影响使用继承自该类型实现的用户，而为接口添加方法导致用户必须为新方法添加实现。

（6） 当派生类和基类是is-a的关系是使用\继承\，典型案例\苹果 is-a 水果\，存在can-do的关系时使用\接口\

25、 什么是虚方法？什么是抽象方法？（难易度：较难；知识点：继承) （5分） 虚函数：没有实现的，可由子类继承并重写的函数。

抽象方法：在抽象类中定义的方法，没有方法体，规定其非虚子类必须实现的函数，必须被重写。

26、 请简要描述抽象类。(知识点：抽象类；难度：简单题) （10分）

用abstract修饰的类。抽象类可以包含实现的成员。未实现的成员隐含的是virtual属性，子类实现时必须用override关键字。

27、 重载与覆盖（重写）的区别？（难易度：较难；知识点：继承）（10分）

1、方法的重写是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系

2、重写只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。

3、重写要求参数列表相同；重载要求参数列表不同。

4、重写关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调d用时的实参表与形参表来选择方法体的。 28、 写出下列程序的运行结果。（难易度：较难；知识点：继承）（15分） ///

/// 抽象基类 ///

public abstract class People {

public string name; public string sex;

public People(string out_name,string out_sex) {

name = out_name; sex = out_sex; } //

// 一个抽象方法，现在的人都上网，不同的人上网的目的是什么 // 基类的中抽象方法不用实现 //

public abstract void SearchInternet(); }

//======================================================== public class Student : People {

string StudentNum;

///

public Student(string out_name, string out_sex, string out_stuNum) : base(out_name,out_sex) {

name = out_name; sex = out_sex;

StudentNum = out_stuNum;

}

public override void SearchInternet() {

Console.WriteLine(\这个人名叫\性别:\工号:\StudentNum + \他上网的目的是查找习题答案\\n\ } }

//=============================================================== public class Teacher : People {

string TeachNum;

public Teacher(string out_name, string out_sex, string out_Tnum) : base(out_name,out_sex) {

name = out_name; sex = out_sex;

TeachNum = out_Tnum; }

public override void SearchInternet() {

Console.WriteLine( \这个人名叫\性别:\工号:\TeachNum +\他上网的目的是发布习题答案\\n\ }

}

//========================================================= static void Main(string[] args) {

Student stu = new Student(\小明\男\ Teacher teacher = new Teacher(\男\ stu.SearchInternet(); teacher.SearchInternet(); Console.ReadLine();

}

答案：这个人名叫小明,性别:男,学号:120016101,他上网的目的是查找习题答案 这个人名叫Peter,性别:男,工号:20524,他上网的目的是发布习题答案 29、 虚函数的作用是什么？ （难易度：简单；知识点：继承）（10分） （1）、使用虚函数是为了更好的定义类的方法。提供统一的方法定义。 （2）、就是可以在子类中被重写，当你继承一个类时，如果觉得父类中的虚函数不能满足你的要求，就可以在子类中重写这个函数了。 （3）、在派生类中重载时需要加上override关键字。

请解释virtual的含义？（难易度：较难；知识点：继承）

virtual 关键字用于修改方法或属性的声明，在这种情况下，方法或属性被称作虚拟成员。虚拟成员的实现可由派生类中的重写成员更改。 30、

阅读下面的代码，写出运行结果。（难易度：难；知识点：继承）（15分）

///

///

public string bookName; ///

public virtual string GetBookName() {

return \这本书名是：\ } }

///

public class NetBook : Book {

///

public override string GetBookName() {

return bookName; } }

调用：

protected void Page_Load(object sender, EventArgs e) {

if (!IsPostBack) {

NetBook myNetBook = new NetBook();

myNetBook.bookName = \开发案例
\ Response.Write(myNetBook.GetBookName());

Book myBook = new NetBook();

myBook.bookName = \基础开发
\ Response.Write(myBook.GetBookName());

Book myBaseBook = new Book();

myBaseBook.bookName = \基础开发
\ Response.Write(myBaseBook.GetBookName()); }

}

答案：asp.net开发案例

asp.net基础开发

这本书名是：asp.net基础开发

31、 阅读下面的代码，写出运行结果。（难易度：很难；知识点：继承）（abstract class Person {

public abstract void Speak(); }

class Animal {

public virtual void EatFood() {

Console.WriteLine(\ } }

class Man : Person {

public override void Speak() {

Console.WriteLine(\ } }

class Dog : Animal { }

class Cat : Animal {

public override void EatFood() {

Console.WriteLine(\ } }

static void Main(string[] args)

{

Man man = new Man(); man.Speak();

Dog dog = new Dog(); dog.EatFood();

15分）

Cat cat = new Cat(); cat.EatFood();

Console.ReadLine(); }

答案：The man is speaking! The animal is eating!

The cat is eating!

32、 （难易度：很难；知识点：继承）（20分）简易学生信息管理(用抽象类实现多态) 编写一个应用程序，利用方法的重写和多态性进行学生信息的简单管理，输出类似如下格式的学生信息：(高职学生输出总成绩；成教学生输出总学分)。

王静：高职类2年级学生，总成绩：248 刘丽：成教类1年级学生，总学分：26

说明：(1) 定义一个抽象类Students，在其中添加6个属性，分别对应于学生类别、姓名、进校年数、基础课成绩、专业课成绩、实训课成绩； 1个方法，计算总成绩；1个抽象方法，用于显示学生信息。

(2) 定义1个派生类StudentA，继承自抽象类，用于实现“高职”类学生信息的处理，在其中实现基类的抽象方法。

(3) 定义1个派生类StudentB，继承自抽象类，用于实现“成教”类学生信息的处理，在其中实现基类的抽象方法，并添加计算总学分的方法。

(4) 总成绩 = 基础课+专业课+实训课 总学分 = 总成绩 / 10

总学分为整数

接口、委托（共10题，占7%）

1. （难易度：简单；知识点：接口）（10分）创建接口ICalculator，声明求两个整数的

差的方法diff()；创建类Calculator类，实现接口ICalculator；在应用程序中创建一个Calculator类对象，调用diff ()方法，输出两个数的差。

2. （难易度：很难；知识点：接口）（15分）定义一个接口IEmployee，包含计算基础工

资的成员方法baseSalary()；添加一个管理员实现类Manager和生产员工实现类Producter。要求用反射机制，在程序中动态创建管理员或生产员工的实例，输出其基本工资。

3. （难易度：较难；知识点：接口）（15分）编写接口IAddition，定义add方法，返回

string，参数是两个int类型，编写此接口的两种实现，一种是将参数相加后输出，一种是相连后输出。

4. （难易度：较难；知识点：接口）（15分）定义一个接口IPass，有checkPass方法，

返回布尔值，参数name、pass。定类AdminPass实现接口，要求只要用户名是“admin”，密码是123就返回true，否则返回false

5. （难易度：很难；知识点：接口）（20分）简易电灯管理系统（用接口实现多态）

某学院有很多房屋，每间屋都有照明灯，校园内还有很多路灯，但不管是哪里的灯，对其都有开、关两种操作。学院拟采用自动化控制灯的开关，正常情况下

教室里的灯：一旦有人就开，否则就关；

校园里的路灯：早上6点以后就关，晚上8点以后就开。

现创建一个应用程序，模拟实现上述检测功能。

要求：

（1）创建一个接口ILamp，包含有方法Open() 、Close()

（2）创建一个类ClassRoom，管理教室里的灯，按学院要求实现接口的两个方法 （3）创建一个类SchoolGarden，管理校园里的路灯，按学院要求实现接口的两个方法

6. （难易度：较难；知识点：接口）（10分）接口和类有什么区别？

答:接口是负责功能的定义，项目中通过接口来规范类，操作类以及抽象类的概念！ 而类是负责功能的具体实现！

在类中也有抽象类的定义，抽象类与接口的区别在于：

抽象类是一个不完全的类，类里面有抽象的方法，属性，也可以有具体的方法和属性，需要进一步的专业化。

但接口是一个行为的规范，里面的所有东西都是抽象的！ 一个类只可以继承一个基类也就是父类，但可以实现多个接口。

7. （难易度：简单；知识点：接口）（10分）描述接口的作用。

充当类的功能界面，接口里的成员属于抽象描述，必须通过类的实现才能使用。如：某个项目有多个模块组成，每个模块由一个开发者完成，开发者只需编写完模块功能实现后，留下的接口供其他人使用。其他人在程序中，使用接口时，只需知道接口的功能，不了解如何实现。

当功能模块无法满足需要或功能模块的需求变更时，程序员只需将该功能模块的实现代码进行修改和扩充，而其他调用接口的程序无须改动。接口的这种应用模式成为brige模式（即意图和实现分离）

接口反映了面向对象的多态特征，即通过相同方法得到不同实现。接口也反映了面向对象的封装特征，使用者可以不清楚接口成员的实现细节。

注意：因为接口成员默认的访问权限是public，所以在实现接口时，类的成员必须为public，且方法名和参数必须一致。

8. （难易度：简单；知识点：接口）（10分）Abstract、 class和interface有什么区

别?

相同点：

都不能被直接实例化，都可以通过继承实现其抽象方法。 都是面向抽象编程的技术基础，实现了诸多的设计模式。 不同点：

接口支持多继承；抽象类不能实现多继承。

接口只能定义抽象规则；抽象类既可以定义规则，还可能提供已实现的成员。 接口是一组行为规范；抽象类是一个不完全的类，着重族的概念。 接口可以用于支持回调（CallBack）；抽象类不能实现回调，因为继承不支持。 接口只包含方法(Method)、属性(Property)、索引器(Index)、事件(Event)的签名，但不能定义字段和包含实现的方法；

抽象类可以定义字段、属性、包含有实现的方法。

接口可以作用于值类型(Struct)和引用类型(Class)；抽象类只能作用于引用类型。例如，Struct就可以继承接口，而不能继承类。

9. （难易度：较难；知识点：接口）（10分）在项目中为什么使用接口？接口的好处是

什么？什么是面向接口开发？

接口只是一种约束。使用 interface 去定义某些特定的功能，为的是不要将代码写死在自定义类里，以便在系统开发、事后维护、功能扩充 上更有扩展性。

接口用于描述一组类的公共方法/公共属性. 它不实现任何的方法或属性，只是告诉继承它的类至少要实现哪些功能,继承它的类可以增加自己的方法. 使用接口可以使继承它的类： 命名统一/规范,易于维护。提供永远的接口。 当类增加时，现有接口方法能够满足继承类中的大多数方法，没必要重新给新类设计一组方法，也节省了代码，提高了开发效率。 面向接口开发的好处有结构清晰，类间通信简单易懂，扩展性好，提高复用性等等。 面向接口开发就是指面向抽象协议编程，实现者在实现时要严格按协议来办。

10. （难易度：很难；知识点：委托）（15分）下列代码的运行结果是什么。

using System;

public delegate void BuyTicketDelegate(string num); public class Student {

public event BuyTicketDelegate blEvent; public Student(string num) {

blEvent += new BuyTicketDelegate(this.BuyTicket); }

public void ShowNum(string num) {

blEvent(num); }

private void BuyTicket(string num) {

Console.WriteLine(\我要买\次车票\ }

static void Main() {

Console.WriteLine(\创建学生对象\ Student stu = new Student(\ Console.WriteLine(\创建完毕\ stu.ShowNum(\ } }

答案： 创建学生对象 创建完毕

[完成]字符串（共3题，占2%）

1. （难易度：较难；知识点：字符串）（10分）请问: String类与StringBuilder类有

什么区别？为什么在.Net类库中要同时存在这2个类？

在进行累加操作时，StringBuilder利用Append方法实现，拥有比string快很多的优势，累加次数越多，优势越明显。对于string类型系统先是把两个字符串写入内存，接

本文来源：https://www.bwwdw.com/article/h2w.html