&>&&>&面向对象程序设计题库_(2013)
面向对象程序设计题库_(2013) 投稿：宋槳槴
（一）面向对象程序设计（共124题，占83%） [完成]面向对象相关概念（共7题，占5%） 1、 什么是面向对象？(知识点：面向对象的概念；难度：简单题)（5分） 面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程O…
资阳市2015年中考数学试卷全卷分为第Ⅰ卷（选择题）和第Ⅱ卷（非选择题）两部分，共4页。全卷满分120分。考试时间共120分钟。 注意事项： 1．答题前，请考生务必在答题卡上正确填写自己的姓名、准考证号和座位号。考试结束，将试卷和答题卡一并交回。 2…
一、历史背景 中国有文字记载的历史长达5000多年，从古到今的绝大多数时间内，中国一直是世界人口大国，占世界人口的比重长期保持在1/4左右。中国陆地面积约为960万平方公里，约占世界陆地总面积的6.5%，居世界第三。 中国悠久的历史，宽广的陆地面积，…
（一）面向对象程序设计（共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
public void showmsg()
msg = "Hello World";
Console.WriteLine(msg);
答：Hello World
2、 编一个程序，定义类student和它的属性（学号,姓名,年龄，成绩）,用类student生
成对象s,分别对对象s的成员赋值，然后输出对象s。（难易度：简单题；知识点：类的属性）（5分）
public class student
public int ID{}
public string name{}
public int age{}
public float grade{}
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 S
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
return this.
if(value > 0 && value <= 100)
this.age =
public Student(int age)
this.age =
4、 编一个程序，定义类(有姓名，年龄，手机号码三个字段)，再定义一个一维数组，使数
组元素为类，存入2条数据，然后依次输出,使用for循环语句进行输入输出操作。（难易度：难；知识点：类的属性）（10分）
public class Peo
public string name { }
public int age { }
public long phone { }
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 =
pp[i].phone = ;
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
public string SchoolName
public string Phone
6、 定义一个员工类和员工教育经历类，体现出他们是一对多的关系。（难易度：较难；知
识点：类的属性）（10分）
public class Employee
public int ID { }
public string Name { }
public class Education
public int ID { }
public string Edu { }
7、 编写一个程序，在其中创建物体类PhysicalObject，通过公有属性来访问其重量、体积、
密度，并通过公有方法来判断该物体是否会在水中下沉。（难易度：简单；知识点：类的属性和方法）（10分）
Public class PhysicalObject
public double weight{}
public double volume{}
public double Density{}
public string kk()
return (Density > 1 ? “下沉” : “不下沉”);
8、 期末有三科成绩：语文、数学、英语，定义成类的属性
在类中写两个方法：（1）计算总成绩（2）计算平均成绩
（难易度：简单；知识点：类的属性和方法）（10分）
public class cs
public float ch { }
public float en { }
public float ma { }
public float Sum()
public float Ave()
(ch + en + ma) / 3;
9、 定义一个矩形类，有长、宽两个属性，在类中写计算周长和面积的方法
（难易度：简单；知识点：类的属性和方法）（10分）
public class jx
public float l { }
public float k { }
public string
return (l + k) * 2;
public string
10、 计算产品总金额
属性：商品数量、商品价格
方法：计算商品金额（不打折）、计算商品金额（打折），这是两个重载
（难易度：简单；知识点：类的属性和方法）（10分）
public class sp
public float sl { }
public float jg { }
public float
public float
Money(float rate)
11、 期末有三科成绩：语文、数学、英语，定义成类的属性
在类中写两个方法：（1）计算总成绩（2）计算平均成绩（3）添加一个构造函数为三科成绩赋值。（难易度：简单；知识点：类的属性和方法）（10分）
public class cs
public float ch { }
public float en { }
public float ma { }
public float Sum()
public float Ave()
(ch + en + ma) / 3;
Public cs(float c,float e,float m)
12、 定义轿车类，其有颜色、重量、出厂日期字段，使用年限属性。并实例化对象car1
和car2，编译和调试轿车类。（难易度：简单；知识点：类的属性）（5分）
public class jc
public string ys { }
public float weight { }
public DateTime time { }
public int useyear{}
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[检索条件]
{ //根据检索条件取值}
{ //根据检索条件赋值}
索引器是用来封装类中的数组或集合的成员。索引器的参数表示检索成员的条件，没有参数类型的限制，但是参数个数至少有1个。
15、 定义一个圆类，包含半径属性，获取圆面积方法和圆周长方法。（难易度：简单；
知识点：类的属性和方法）（10分）
public class yuan
public string j(float r)
return "面积为：" + (r * r * 3.14) + "周长为：" + (2 * 3.14 * r);
16、 定义汽车类，添加属性:牌号、颜色、重量、出厂日期，创建一个轿车对象,初始化
一辆完整的车辆。（难易度：简单；知识点：类的属性）（5分）
public class car
public DateT
protected void butque_Click(object sender, EventArgs e)
car che = new car();
che.h = tethao.T
che.y = tetyan.T
che.z = tetzhong.T
che.time = Convert.ToDateTime(tettime.Text);
lalti.Text = "车辆信息为：" + che.h + che.y + che.z.ToString() + che.time.ToString();
17、 定义一个班级类，包含辅导员、班级名称、所属系部、人数属性，其中人数不能超
过60人。（难易度：简单；知识点：类的属性）（5分）
public class ban
public string fu { }
public string name { }
public string xi { }
public int ren { }
public virtual string info(string x, string y, string z, int c)
return "输入人数错误！";
return "辅导员为：" + x + "班级为：" + y + "系部为： " + z + "人数为：" +
18、 定义一个圆类，包含半径属性，编写获取圆面积方法和圆周长方法。实例化一个圆对象，输出圆的面积和周长。（难易度：简单；知识点：类的属性和方法）（10分）
public class yuan
public float r { }
public string sh()
return "面积：" + r * r * Math.PI;
public string sj()
return "周长：" + 2 * r * Math.PI;
protected void Button2_Click(object sender, EventArgs e)
yuan s = new yuan();
Response.Write(s.sh() + s.sj());
37、 定义一个长方体类，包含长、宽、高属性，编写获取长方体体积方法和长方体表面
积方法。实例化一个长方体对象，输出长方体的体积和表面积。(知识点：类成员、方法、对象；难度：较难题) （10分）
public class cft
public float chang { }
public float kuan { }
public float gao { }
public string sh()
return "表面积：" + (chang * kuan * 2 + chang * gao * 2 + kuan * gao * 2);
public string sj()
return "周长：" + chang * kuan *
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
Class myc = new Class();
Myc.classname="0900103班";
39、 创建一个长方形类，其有长和宽两个属性，并能计算周长和面积。在程序中创建一
个长和宽分别为10和5的长方形，并打印出该长方形的长、宽、周长和面积。（难易度：简单；知识点：类的属性和方法）（10分）
class rectangle
public float length { }
public float width { }
public float area()
return length *
public float zhouchang()
return (width + length) * 2;
40、 定义People类，有两个属性Name、Sex，一个方法print()，用以输出people的
信息。（难易度：简单；知识点：类的属性和方法）（10分）
class People
public string Name { }
public string Sex { }
public string print()
return "Name:" + Name +" "+ "Sex:" + S
41、 完成学生类的建立（提示：建立三个字段分别是xuehao，name，birthday并为其
添加字段；添加一个方法输出学生的相关信息，其输出格式为：
“姓名：张三 学号： 生日：”。（难易度：简单；知识点：
类的属性和方法）（10分）
class Student
public DateT
public string print()
return "姓名：" + name + "学号：" + xuehao + "生日：" +
42、 创建人类，有姓名、性别、出生日期、年龄、身份证号码这5个公有属性。再添加
一个公有方法ShowInfo()返回一个字符串，包含此人的所有信息，格式为“我叫***，性别*，出生日期是********，今天*岁，我的身份证号码是********。”，并在程序中输出显示。（难易度：简单；知识点：类的属性和方法）（10分）
class Person
private string ID
public string Name { }
public string Sex{ }
public string Birthday{ }
public int Age{ }
public string idcard{ }
public string ShowInfo()
return "我叫" + Name + ",性别" + Sex + ",出生日期是" + Birthday + ",今天" + Age + "岁,我的身份证号码是" + idcard + "。";
43、 创建时间Shijian类，它包含3个整型字段：Hour、Minute、Second，它们用于表
示采取统一时间格式（24小时时钟格式）的一个时间。并定义一个不含参数的
ToUniversalString方法，该方法采用统一时间格式返回一个字符串，它包括6个数位－－2个表示小时，2个表示分钟，2个表示秒。创建Shijian类的2个实例，编译和调试Shijian类。（难易度：难题；知识点：类的属性和方法）(00:00:00)（15分）
public class Shijian
public int
public int M
public int S
public string method()
Return Hour.ToString("00")+ Minute.ToString("00")+ Second.ToString("00")
44、 （难易度：较难；知识点：类的属性和方法）（15分）完成一个四则运算程序
要求填入要进行“加减乘除”的两个数字，点击“＝”，得出答案。 如果是除法，除数不能为0。 文本框必须填入数字。（使用try,,catch,,.） 建立一个四则运算类完成 类名：jishuan
成员变量：第一个数、第二个数
属性：第一个数、第二个数
方法四个：求和的方法、求差的方法、求积的方法、求商的方法
6） 在程序中调用这个类，得到计算结果
45、 写一分数计算程序。选手上台表演，有七个裁判打分。计分规则是去掉一个最高分
和最低分，把剩下的5个分相加就是该选手的最后得分。（难易度：难；知识点：类的属性和方法）（10分）
public class getsum
public float[] b { }
public float method()
float sum = 0;
for (int i = 0; i < b.L 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、 怎样理解静态变量？静态成员和非静态成员的区别？（难易度：简单；知识点：关键字）
静态变量属于类，而不属于对象；并对所有对象所享；静态成员在加类的时候就被加载。
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 st
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 = "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 = "Class1.str";
public int i = 0;
public static void StringConvert(string str)
str = "string being converted.";
public static void StringConvert(Class1 c)
c.str = "string being converted.";
public static void Add(int i)
public static void AddWithRef(ref int 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 =
public int z =
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 +
public string add(string a, string b)
return a +
2、 什么是方法的重载？（难易度：难；知识点：重载）（5分）
（1）.方法名一定要相同。
（2）.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
如果参数个数不同，就不管它的参数类型了！
如果参数个数相同，那么参数的类型或者参数的顺序必须不同。
（3）.方法的返回类型、修饰符可以相同，也可不同。
3、 定义一个猫类，其字段有颜色、出生日期、性别。分别添加公有属性。添加一方法输出
猫的叫声“喵”，添加一方法输出“猫扑老鼠”,并为猫添加构造函数，通过参数的形式传递猫的颜色，出生日期和性别。最后在主方法中实例化对象。（类及其成员、构造函数及其重载、较难题）（15分）
4、 设计一个长方形类，包含有成员：长、宽两个属性；无参构造方法和带参构造方法用于
初始化长方形；计算长方形的周长和面积的方法。在应用程序中用帶参构造方法创建若干个长方形对象，并打印该长方形对象的长、宽、周长和面积。（类及其成员、构造函数及其重载、较难题）（15分）
5、 （类及其成员、难题）（15分）构造函数及其重载、有一家销售公司，其工资发放规则
1)完成程序：要求选择员工的职务类型，输入销售额，得到工资总额。
工资总额＝基本工资＋ 销售额*业务提成比例
2)建立一个工资计算类完成。
输入信息有：职务、销售额
输出信息：工资额
类名：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分）
class Person
public string id { }
public string name { }
public string printInfo()
return "id="+id+" "+"name="+
public class Student:Person
public float grade { }
public float printGrade()
public class Teacher:Person
public float salary { }
public float printSalary()
2、 读程序写结果：（难易度：较难；知识点：继承）（15分）
class Program
static void Main()
B b = new B();
Console.ReadKey();
public A()
PrintFields();
public virtual void PrintFields() { }
class B : A
int x = 1;
public B()
public override void PrintFields()
Console.WriteLine("x={0},y={1}", x, y);
3、 读程序写结果：（难易度：较难；知识点：继承）（15分）
class Program
static void Main()
Console.WriteLine("X={0},Y={1}", A.X, B.Y);
Console.ReadKey();
public static int X;
static A()
X = B.Y + 1;
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("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()
5、 读程序写结果（难易度：较难；知识点：继承）（10分）
class Program
static void Main()
A a = new B();
Console.ReadKey();
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()");
6、 读程序写结果：（难易度：较难；知识点：继承）（
static void Main()
B bb = new B();
Console.ReadKey();
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 =
x.i = 100;
Console.WriteLine("{0}, {1}", x.i, y.i);
class BaseClass
class MyClass : BaseClass
8、 读程序写结果（难易度：较难；知识点：继承）（15分）
public class VirtualInheritSample
public static void Main()
DerivedClass c = new DerivedClass();
public class BaseClass
public void A()
Console.WriteLine("Base A");
public virtual void B()
Console.WriteLine("Base B");
public class DerivedClass : BaseClass
public new void A()
Console.WriteLine("Derived A");
public override void B()
Console.WriteLine("Derived B");
public void Call()
((BaseClass)this).A();
((BaseClass)this).B();
9、 读程序写结果（难易度：较难；知识点：继承）（
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() 10分）
Console.WriteLine("B.Fun()");
public static void Main()
A a = new B();
10、 读程序写结果（难易度：较难；知识点：继承）（10分）
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"); }
static void Main(string[] args)
Son b = new Son();
Father a =
11、 写出程序的输出结果：（难易度：较难；知识点：继承）（10分）
public class A
public virtual void Fun1(int i)
Console.WriteLine(i);
public void Fun2(A a)
a.Fun1(1);
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.printStr("打印");
b.printStr("打印");
Console.ReadLine();
13、 读程序写结果（难易度：较难；知识点：继承）（10分）
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() { }
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分）输入两个正整数，分别作为直角三角
形的两个直角边，求出斜边的长度。
提示：勾股定理
要求继承前面的四则运算类，可以调用其中的求和的方法；在继承类中加写方法完成斜边的计算
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
总学分为整数
接口与继承的区别？什么时候使用接口，什么时候使用继承？ （难易度：较难；
知识点：继承）（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 People(string out_name,string out_sex)
name = out_
sex = out_
一个抽象方法，现在的人都上网，不同的人上网的目的是什么
基类的中抽象方法不用实现
public abstract void SearchInternet();
//========================================================
public class Student : People
string StudentN
/// base(out_name,out_sex)同时去初始化抽象类中的两个数据成员
public Student(string out_name, string out_sex, string out_stuNum)
: base(out_name,out_sex)
name = out_
sex = out_
StudentNum = out_stuN
public override void SearchInternet()
Console.WriteLine("这个人名叫" + name + ",性别:" + sex + ",工号:" + StudentNum + ",他上网的目的是查找习题答案\n");
//===============================================================
public class Teacher : People
string TeachN
public Teacher(string out_name, string out_sex, string out_Tnum)
: base(out_name,out_sex)
name = out_
sex = out_
TeachNum = out_T
public override void SearchInternet()
Console.WriteLine( "这个人名叫" + name + ",性别:" + sex + ",工号:"+ TeachNum +",他上网的目的是发布习题答案\n");
//=========================================================
static void Main(string[] args)
Student stu = new Student("小明", "男", "");
Teacher teacher = new Teacher("Peter","男","20524");
stu.SearchInternet();
teacher.SearchInternet();
Console.ReadLine();
答案：这个人名叫小明,性别:男,学号:,他上网的目的是查找习题答案 这个人名叫Peter,性别:男,工号:20524,他上网的目的是发布习题答案
29、 虚函数的作用是什么？ （难易度：简单；知识点：继承）（10分）
（1）、使用虚函数是为了更好的定义类的方法。提供统一的方法定义。
（2）、就是可以在子类中被重写，当你继承一个类时，如果觉得父类中的虚函数不能满足你的要求，就可以在子类中重写这个函数了。
（3）、在派生类中重载时需要加上override关键字。
请解释virtual的含义？（难易度：较难；知识点：继承）
virtual 关键字用于修改方法或属性的声明，在这种情况下，方法或属性被称作虚拟成员。虚拟成员的实现可由派生类中的重写成员更改。
30、 阅读下面的代码，写出运行结果。（难易度：难；知识点：继承）（15分）
/// 抽象类书
public class Book
public string bookN
/// 虚方法，获取书名
public virtual string GetBookName()
return "这本书名是：" + bookN
/// 书的派生类
public class NetBook : Book
/// 重写虚方法override
public override string GetBookName()
return bookN
protected void Page_Load(object sender, EventArgs e)
if (!IsPostBack)
NetBook myNetBook = new NetBook();
myNetBook.bookName = "asp.net开发案例";
Response.Write(myNetBook.GetBookName());
Book myBook = new NetBook();
myBook.bookName = "asp.net基础开发";
Response.Write(myBook.GetBookName());
Book myBaseBook = new Book();
myBaseBook.bookName = "asp.net基础开发";
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("The animal is eating!");
class Man : Person
public override void Speak()
Console.WriteLine("The man is speaking!");
class Dog : Animal
class Cat : Animal
public override void EatFood()
Console.WriteLine("The cat is eating!");
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分）下列代码的运行结果是什么。
public delegate void BuyTicketDelegate(string num);
public class Student
public event BuyTicketDelegate blE
public Student(string num)
blEvent += new BuyTicketDelegate(this.BuyTicket);
public void ShowNum(string num)
blEvent(num);
private void BuyTicket(string num)
Console.WriteLine("我要买" + num + "次车票");
static void Main()
Console.WriteLine("创建学生对象");
Student stu = new Student("T1");
Console.WriteLine("创建完毕");
stu.ShowNum("T1");
创建学生对象
[完成]字符串（共3题，占2%）
1. （难易度：较难；知识点：字符串）（10分）请问: String类与StringBuilder类有
什么区别？为什么在.Net类库中要同时存在这2个类？
在进行累加操作时，StringBuilder利用Append方法实现，拥有比string快很多的优势，累加次数越多，优势越明显。对于string类型系统先是把两个字符串写入内存，接
着删除原来的String对象，然后创建一个String对象，并读取内存中的数据赋给该对象，而StringBuilder则是在原有字符串的基础 上进行累计，而不会多次创建对象
2. （难易度：简单；知识点：字符串）（5分）有字符串"Hello World!"，使用StringBuilder
对象处理字符串，把Beautiful插入到两个单词之间，然后把结尾的感叹号替换为问号，输出”Hello Beautiful World？”
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Insert(6,"Beautiful ");
MyStringBuilder.Replace('!', '?');
Console.WriteLine(MyStringBuilder);
3. （难易度：简单；知识点：字符串）（15分）有字符串"Hello World!"，使用StringBuilder
对象处理字符串，把Hello后的内容移除，然后加上一个问号，输出”Hello？” StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Insert(6,"Beautiful ");
MyStringBuilder.Replace('!', '?');
Console.WriteLine(MyStringBuilder);
反射（共4题，占3%） 1. （难易度：难；知识点：反射）（10分）反射机制的工作原理是什么？
答：首先，如何利用反射获取类的信息：有两种方法，一种是得到实例对象，这时候得到的这个实例对象，也许是一个Object的引用，也许是一个接口的引用，但是并不知道它的确切类型信息，要想知道可以通过调用System.Object上生命的方法GetType来获取实例对象的类型对象，另一种方法是通过Type.GetType以及Assembly.GetType方法。需要注意的是，要查找一个类，必须指定他所在的装配件，或者在已经获得的Assembly实例上面调用GetType：Type t=Type.GetType(“System.String”);
2. （难易度：难；知识点：反射）（10分）概述反射和序列化
反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您可以使用反射在运行时动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。
通过反射命名空间中的类以及 System.Type，可以使用反射在运行时动态地创建类型的实例,然后调用和访问这些实例。也可以获取有关已加载的程序集和在其中定义的类型（如类、接口和值类型）的信息。
序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
3. [未做]（难易度：难；知识点：反射）（10分）有一学生类
public class Student
public int ID{}
public string name{}
public int age{}
public int hisclass { }
使用PropertyInfo类，反射获取类中属性名和属性的类型
4. [未做]（难易度：难；知识点：反射）（10分）一个类实现了打印接口，要求实例化接
口Iprint，调用方法PrintData()，输出"class PrintA 实现"。要求：不能使用关键字“new“
结构（共4题，占3%）
1. （难易度：简单；知识点：结构）（10分）c#中 下列代码的运行结果是
struct Student{
public Student(int age,string name){
this.name=
public class Test{
static void 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);
答案: 18 小方
2. （难易度：简单；知识点：结构）（10分）下列代码的运行结果是什么
class Test
public struct Point
public Point(int x, int y)
static void Main()
Point p1 = new Point(100, 100);
Point p2 = p1;
p1.x = 200;
Console.WriteLine("{0},{1}", p1.x, p2.x);
答案：200,100
3. （难易度：难；知识点：结构）（10分）编一个程序，定义结构(有姓名，年龄，手机
号码三个字段)，再定义一个一维数组，把结构作为数组元素类型，存入数据，然后依次输出。
struct Contact
static void Main(string[] args)
Contact[] c = new Contact[3];
c[0].name="刘龙";
c[0].age=54;
c[0].telephone="";
c[1].name="王鸣";
c[1].age=42;
c[1].telephone="";
c[2].name="张星";
c[2].age=39;
c[2].telephone="";
Console.Write("姓名：{0}，",c[0].name);
Console.Write("年龄：{0}，",c[0].age);
Console.WriteLine("手机号码：{0}",c[0].telephone);
Console.Write("姓名：{0}，",c[1].name);
Console.Write("年龄：{0}，",c[1].age);
Console.WriteLine("手机号码：{0}",c[1].telephone);
Console.Write("姓名：{0}，",c[2].name);
Console.Write("年龄：{0}，",c[2].age);
Console.WriteLine("手机号码：{0}",c[2].telephone);
4. [未做]（难易度：较难；知识点：结构）创建一个结构Student用以存储学生数据,其
成员有学号sNo、姓名sName和性别sSex；在应用程序中定信三个学生对象并赋值，然后输出相应学生的信息。
[完成]枚举（共1题，占1%）
1. （难易度：简单；知识点：枚举）（5分）下列代码的输出结果是什么
class Test
public enum WeekDays
Mon, Tue, Wed, Thur, Fri, Sta, Sun
static void Main()
WeekDays week = (WeekDays)2;
Console.WriteLine(week);
答案： Wed
[大部分完成]泛型 （共3题，占2%）
1. （难易度：很难；知识点：泛型）（10分）请定义一个泛型方法，要求实现两个对象交
换，并调用方法分别实现两个整数和两个字符串交换。
2. （难易度：较难；知识点：泛型）（10分）阅读下面代码，回答问题。
public class Student
public int Id
public string StudentName
public string StudentNumber
public string StudentClass
IList list = new List();
for (int i = 0; i <= 5; i++)
Student student = new Student();
student.Id =
student.StudentName = "张三" + i.ToString();
student.StudentNumber = "1200161" + i.ToString();
student.StudentClass = "1200161";
list.Add(student);
int count = list.C
Student stu = list.Where(o => o.StudentName == "张三
2").FirstOrDefault();
请问：在list中游多少条数据，即count 的值为多少？stu的Id为多少？
答案：count=5。stu的Id为2.
3. （难易度：很难；知识点：泛型）（20分）创建一个书籍类Book,其属性有编号bNo、
名称bName和价格bPrice；再声明三个书籍对象并赋值，然后用泛型 List集合来实现对书籍对象数据的存储，并输出这些书籍的信息。
[大部分完成]集合（共4题，占3%）
1. （难易度：较难；知识点：集合）（10分）列出20内能被3整除的数，求出这些数的
和。使用ArrayList对象实现了。
2. （难易度：较难；知识点：集合）（15分）写一分数计算程序。选手上台表演，有七个
裁判打分。计分规则是去掉一个最高分和最低分，把剩下的5个分相加然后除以5，就是该选手的最后得分。
? 录入的7个分数。
? 使用ArrayList对象了实现。
? 输出计分结果。
3. （难易度：较难；知识点：集合）（10分）下列代码的运行结果是什么
class Test
static void ShowArrayInfo(int[] student)
for(int i=0;i<student.Li++)
Console.Write(student[i]++);
Console.Write(" ");
static void Main()
int[] student = new int[]{1,2,3,4,5};
ShowArrayInfo(student);
Console.Write("\n");
ShowArrayInfo(student);
4、 （难易度：较难；知识点：集合）（10分）下列代码的运行结果是什么 using S
using System.C public class Teacher {
private ArrayList arrNames = new ArrayList();
public Teacher(string[] names)
foreach(string name in names)
this.arrNames.Add(name);
public string this[int index]
return arrNames[arrNames.Count - index].ToString();
static void Main()
String[] names = new string[] { "C#", "WinForms", "ASP.NET", "WebService" };
Teacher tea = new Teacher(names);
Console.WriteLine(tea[3]);
答案：WinForms
[大部分完成]LINQ TO OBJECT（共4题，占3%）
1. （难易度：简单；知识点：LINQ）（5分）查找字符串“linq to object is very
important.This is my first linq to object program.”中的“linq”,并输出；输出该字符串中长度大于10的字符串；在该字符中中找出所有以字母l开头的字符串。
2、 （难易度：简单；知识点：LINQ）（5分）有数组int[] arr = new int[] { 7, 9, 23,
3, 56, 4, 15, 58 }，使用linq取出大于5且小于50的数，把这些数按从大到小的顺序输出。
int[] arr = new int[] { 7, 9, 23, 3, 56, 4, 15, 58 };
var m = from n in arr where n>5 & n<50 orderby n foreach (var n in m)//循环依次取出每个数组元素 {
Console.WriteLine(n); }
3、 （难易度：简单；知识点：LINQ）（5分）有数组string[] arr = { "One", "Two", "Three",
"Four", "Five" }，使用linq查询出这个字符串数组中首字母为“T”的字符串 string[] arr = { "One", "Two", "Three", "Four", "Five" };
var m = from n in arr where n.Substring(0, 1) == "T" foreach (var n in m)//循环依次取出每个数组元素 {
Console.WriteLine(n); }
4、 （难易度：很难；知识点：LINQ）（10分）写一分数计算程序。选手上台表演，有七
个裁判打分。计分规则是去掉一个最高分和最低分，把剩下的5个分相加然后除以5，就是该选手的最后得分。
? 录入的7个分数。 ? 使用泛型集合实现。 ? 输出计分结果。
List list = new List();
for (int i = 0; i < 7; i++)
fen = Convert.ToDouble( Console.ReadLine());
list.Add(fen);
list.Sort();
list.RemoveAt(6);
list.RemoveAt(0);
double sum = 0;
foreach (double i in list)
Console.WriteLine(sum / 5);
[大部分完成]（二）数据库访问技术ADO.NET（共21题，占14%）
1. （难易度：简单；知识点：ADO.NET）（5分）ADO.NET 对象模型中有哪些主要的组件？ 答：Connection对象、Command 对象、DataAdapter、DataSet 以及DataReader。
2. （难易度：较难；知识点：ADO.NET）（10分）请描述DataReader和DataSet的异同。 答：DataReader和DataSet最大的区别在于，DataReader使用时始终占用SqlConnection，在线操作数据库，任何对SqlConnection的操作都会引发DataReader的异常，因为DataReader每次只在内存中加载一条数据，所以占用的内存是很小的，因为DataReader的特殊性和高性能。所以DataReader是只进的，你读了第一条后就不能再去读取第一条了。
DataSet则是将数据一次性加载在内存中。抛弃数据库连接，读取完毕即放弃数据库连接，因为DataSet将数据全部加载在内存中。所以比较消耗内存，但是确比DataReader要灵活，可以动态的添加行，列，数据。对数据库进行回传更新操作。 3、（难易度：简单；知识点：ADO.NET）（10分）在C#中,下列代码运行后的输出结果是什么 using S
using System.D class Test {
static void Main()
DataTable dt = new DataTable();
dt.Columns.Add("编号", typeof(System.Int16));
dt.Columns.Add("成绩", typeof(System.Int16));
for (int i = 1; i <= 3; i++)
DataRow dr = dt.NewRow();
dt.Rows.Add(dr);
Console.WriteLine(dt.Columns.Count);
4、（难易度：简单；知识点：ADO.NET）（5分）在ADO.NET中,下列代码的输出结果是什么 using S
using System.Data.SqlC class Test {
static void Main()
SqlConnection conn = new SqlConnection(@"Data
Source=localhost\SQLEXPRESS;Initial Catalog=ADOTPersist Security Info=TUser ID=Password=123456");
Console.WriteLine(conn.ConnectionString);
Data Source=localhost\SQLEXPRESS;Initial Catalog=ADOTPersist Security Info=TUser ID=Password=、（难易度：较难；知识点：ADO.NET）（10分）什么是事务？它有什么特点？
答：事务是单独的工作单元，它保证在同一个事务内所做的事要么成功，要么失败，不会出现第三种情况。
事务具有ACID的属性：原子性，一致性，隔离性，持续性。 6．（难易度：难；知识点：ADO.NET）（15分）在一个操作中要向jobs表（job_desc,min_lvl,max_lvl）添加两条记录
'teacher',11,200
'student',15,100，请运用事物完成操作代码 7、（难易度：较难；知识点：ADO.NET）（15分）编程构建一个数据集，数据集的名字是 数据集中有两张表，名字分别是stuinfo,tb2;
第一张表有3列，名字分别是id（整型）,name（字符串型）,age（整型）; 第二张表有2列，名字分别是column1（字符串型）,column2（浮点型）;
最后将两张表的显示在不同的datagridview控件上
DataSet ds=new DataSet("newds");
dt1=new DataTable("stuinfo");
dt1.Columns.Add("id", typeof(System.Int32));
dt1.Columns.Add("name", typeof(System.String));
dt1.Columns.Add("age", typeof(System.Int32));
ds.Tables.Add(dt1);
dt2=new DataTable("tb2");
dt2.Columns.Add("column1", typeof(System.String));
dt2.Columns.Add("column2", typeof(System.Double));
ds.Tables.Add(dt2);
DataGridView1.DataSource = ds.Tables["stuinfo"];
DataGridView2.DataSource = ds.Tables["tb2"]; 8、（难易度：较难；知识点：ADO.NET）（15分）将pubs数据库中jobs表中的所有数据装入数据集，在其上应用数据视图，将工作号>5（job_id>5）的工作信息按工作描述降序排序，显示在DataGridView控件上
SqlConnection cn = new SqlConnection("data source=.;initial catalog=integrated security=true");
SqlDataAdapter da = new SqlDataAdapter("select * from jobs", cn);
DataSet ds = new DataSet();
da.Fill(ds, "jobs");
DataView dv = new DataView(ds.Tables["jobs"]);
dv.RowFilter = "job_id>5";
dv.Sort = "job_desc desc";
DataGridView1.DataSource =
9、（难易度：难；知识点：ADO.NET）（20分）有账户资金表 create table bb (
ID int not null primary key,
moneys money
--转账金额 ）
要写一个存储过程，完成从一个账号转钱到另一个账号操作，要求用到事物。存储过程开始如下
create procedure mon --创建存储过程，定义几个变量 @toID int, --接收转账的账户 @fromID int , --转出自己的账户 @momeys money --转账的金额 继续完成此存储过程
create procedure mon --创建存储过程，定义几个变量 @toID int, --接收转账的账户 @fromID int , --转出自己的账户 @momeys money --转账的金额 as
begin tran --开始执行事务
update bb set moneys=moneys-@momeys where ID=@fromID -执行的第一个操作，转账出钱，减去转出的金额
update bb set moneys=moneys+@momeys where ID=@toID --执行第二个操作，接受转账的金额，增加
if @@error0 --判断如果两条语句有任何一条出现错误
begin rollback tran –开始执行事务的回滚，恢复的转账开始之前状态 return 0 end go
else --如何两条都执行成功
begin commit tran 执行这个事务的操作 return 1
end go 10、（以下12题均采用这些表）（每题20分）商品管理系统。建立库名：DBMS，并在库中建立下表，实现下列功能： product商品表：
商品表中有如下数据：
productIn 商品进货表
在表内添加一条管理员用户记录：admin、管理员、123
对上表完成如下功能： 1) （难易度：很难；知识点：ADO.NET）完成管理员登录功能，登录成功则进入商品管理主页面Main.aspx（主页面暂且只显示“欢迎您”），登录失败，则准确提示是“用户名输入错误”还是“密码输入错误”。 2) （难易度：简单；知识点：ADO.NET）完成商品信息的列表显示功能，显示出所有
的商品信息。
3) （难易度：简单；知识点：ADO.NET）完成商品删除，删除前要有删除提示。 4) （难易度：较难；知识点：ADO.NET）用存储过程完成商品信息修改，可以修改名
称、产地、种类。
5) （难易度：较难；知识点：ADO.NET）完成商品信息的增加，增加成功与否要有提
6) （难易度：较难；知识点：ADO.NET）完成商品信息的查询，可以根据商品的名称
进行模糊查询。
7) （难易度：较难；知识点：ADO.NET）能够查询每种商品的平均价格
输入：选择商品种类
输出：平均价格 （例如：选择“电视”，就计算出三种电视类型的平均价格） 8) （难易度：很难；知识点：ADO.NET）能够查询指定价格段的商品的数量总和
界面输入：最低价格、最高价格
界面输出：这个价格段的商品数量
（例如：输入最低价格500，最高价格2000，就有CRT电视和挂式空调，数量为9＋8＝17） 9) （难易度：很难；知识点：ADO.NET）用存储过程实现能够查询出每种商品有多少
界面输入：选择商品种类
界面输出：型号的数量 （例如：选择“电视”，就计算出有63500元） 10) （难易度：较难；知识点：ADO.NET）查询出某一类型商品的库存总额。
所有商品 的 价格×数量 之和。 界面输入：选择商品种类
界面输出：这类商品的库存总额 （例如：选择“电视”，就计算出有三种电视型号）
11) （难易度：很难；知识点：ADO.NET）新增用户功能，实现添加用户的功能。
要求：输入密码及重复密码，且两次密码必须相同；登录号不能重复，如果重复要给出提示。 12) （难易度：较难；知识点：ADO.NET）修改管理员admin的密码。
要求：在修改的时候，必须要对admin的原密码进行验证，如果不符合要给出提示。
修改成功与否也要进行提示。
（三）三层架构（共5题，占3%）
1、（难易度：较难；知识点：三层架构）（10分）请简述什么是三层架构。 答:通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。
区分层次的目的即为了“高内聚，低耦合”的思想。 表现层（UI）：通俗讲就是展现给用户的界面，即用户在使用一个系统的时候的所见所得。 业务逻辑层（BLL）：针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。
数据访问层（DAL）：该层所做事务直接操作数据库，针对数据的增添、删除、修改、更新、查找等每层之间是一种垂直的关系。 三层结构是N层结构的一种，一般来说，层次之间是向下依赖的，下层代码未确定其接口（契约）前，上层代码是无法开发的，下层代码接口（契约）的变化将使上层的代码一起变化。 优点： 分工明确，条理清晰，易于调试，而且具有可扩展性。
缺点： 增加成本。 2、（难易度：简单；知识点：三层架构）（5分）在ASP.NET框架下开发三层结构的应用程序好处有哪些？
答： 三层结构可以使系统结构更加清晰； 三层结构可以大大降低程序后期维护成本； 三层结构可以充分发挥团队协作开发的优势 3、 （难易度：简单；知识点：三层架构）（5分）在.NET框架下开发三层结构应用程序时，以下代码最有可能出现在哪一层？
If(UserCode.Text.Trim()!=””)
string wheresql = " usercode = '" + UserCode.Text.Trim() + "'"; }
答：表示层
4、（难易度：简单；知识点：ADO.NET）（5分）在.NET框架下使用实体类实现三层结构时，要求从数据访问层返回强类型实体对象，则返回类型是什么？（提示：ArrayList或者 IList或List、或简单类型int等） 答：IList或List
5、（难易度：较难；知识点：三层架构）（15分）看图，这是一个标准三层架构，根据这个架构说明程序查询执行的过程
标准三层架构各层间的访问过程： ①传入值，将值进行类型转换;
②创建BLL层的对象，通过对象访问BLL层的方法调用BLL层;
③BLL层方法中取得数据访问层的实例,实例化IDAL层的接口对象，然后返回IDAL层传入值所查找的内容的方法;
④通过工厂层的选择，访问指定DAL层，返回一个完整的调用DAL层的结果给 BLL层; ⑤到此要调用DAL层，DAL层完成赋值Model层的对象值为空，给定一个参数，调用sql层的sqlhelper的方法,读出每个字段的数据赋值给以定义为空的Model层的对象; ⑥sqlhelper执行sql命令，返回一个指定连接的数据库记录集，在这里需要应用参数类型，为打开连接命令执行做好准备; ⑦返回Model层，把查询得到的一行记录值赋值给sql层引入的Model层的对象，然后把这个对象返回给BLL;
⑧回到界面层的BLL层的方法调用,把得到的对象值返回，在前台显示给界面。
（一）面向对象程序设计（共124题，占83%） [完成]面向对象相关概念（共7题，占5%） 1、 什么是面向对象？(知识点：面向对象的概念；难度：简单题)（5分） 面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程O…
（一）面向对象程序设计（共124题，占83%） [完成]面向对象相关概念（共7题，占5%） 1、 什么是面向对象？(知识点：面向对象的概念；难度：简单题)（5分） 面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程O…
（一）面向对象程序设计（共124题，占83%） [完成]面向对象相关概念（共7题，占5%） 1、 什么是面向对象？(知识点：面向对象的概念；难度：简单题)（5分） 面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程O…
本文由()首发，转载请保留网址和出处！
免费下载文档：