一、基本语法
1.计算圆形的面积——常量、变量和表达式
实现过程：设计一个控制台程序CircleArea，定义常量Pi=Math.PI（π的值在C#中有固定的，用Math.PI引用 ），变量半径Radius，根据用户输入的半径大小计算圆的面积。
面积=Pi* Radius* Radius
namespace CircleArea
{
class Program
{
static void Main(string[] args)
{
const double PI = 3.1415926;
double Radius,Area;
Console.Write("请输入要计算面积的圆形的半径：");
Radius = double.Parse(Console.ReadLine());
//Area = PI * Radius * Radius;
Area = PI * Math.Pow(Radius, 2);
Console.WriteLine("半径为{0}的圆形面积为{1}",Radius,Area);
}
}
}
2.判断矩形是否为正方形——结构类型和布尔型
实例描述：利用自定义结构类型来描述矩形，然后为结构类型成员赋值，并判断用户输入的矩形是否为正方形，最后在控制台输出判断结果。
实现过程：设计一个控制台程序Struct，声明一个结构类型Rectangle ，包含字段成员长（double Height）、宽（double Width）
判断矩形是否为正方形的方式有两种（任选其一）：
1.在结构类型中定义判断是否为正方形的函数成员IsSquare（）。
2.直接在主函数中写判断语句来判断，并输出结果
namespace Struct
{
class Program
{
struct Rectangle
{
public double Width;
public double Height;
public bool IsSquare()
{
return Width == Height;
}
};
static void Main(string[] args)
{
Rectangle rect;
string issquare;
Console.WriteLine("请输入矩形的长：");
rect.Height = double.Parse(Console.ReadLine());
Console.WriteLine("请输入矩形的宽：");
rect.Width = double.Parse(Console.ReadLine());
if (rect.IsSquare())
{
issquare = "是";
}
else
{
issquare = "不是";
}
Console.WriteLine("长为{0}，宽为{1}的矩形{2}正方形！", rect.Height, rect.Width, issquare);
}
}
}
1.输出特价菜——switch选择语句和枚举类型
实例描述：通过控制台输入星期几，在屏幕上输出该天对应的特价菜名和单价（自己编）。
实现过程：设计一个控制台程序OnSpecial，创建一个星期的枚举类型Week用来描述星期，在主函数中用switch结构实现对特价菜的选择。
namespace OnSpecial
{
class Program
{
enum Week
{
Sunday,
Monday,
Tuesday,
Wenesday,
Thursday,
Friday,
Saturday
}
static void Main(string[] args)
{
Console.WriteLine("请输入星期：");
Week week = (Week)int.Parse(Console.ReadLine());
switch(week)
{
case Week.Sunday:
Console.WriteLine("星期日特价菜：爆炒牛肉18元");
break;
case Week.Monday:
Console.WriteLine("星期一特价菜：啤酒鸭26元");
break;
case Week.Tuesday:
Console.WriteLine("星期二特价菜：红烧肉20元");
break;
case Week.Wenesday:
Console.WriteLine("星期三特价菜：回锅肉16元");
break;
case Week.Thursday:
Console.WriteLine("星期四特价菜：水煮鱼24元");
break;
case Week.Friday:
Console.WriteLine("星期五特价菜：剁椒鱼头30元");
break;
case Week.Saturday:
Console.WriteLine("星期六特价菜：手撕包菜12元");
break;
default:
break;
}
}
}
}
2.百钱买百鸡算法——for循环嵌套调用
实例描述：一百个铜钱买一百只鸡，其中公鸡一只5钱，母鸡一只3钱，小鸡三只1钱，问一百只鸡中公鸡、母鸡和小鸡个多少只？
实现过程：设计一个控制台程序CockHenChicknum，设公鸡数量变量cock，母鸡数量变量hen，小鸡数量变量chick，数量上满足，cock+hen+chick=100；cock*5+hen*3+chick/3=100，公鸡的数量在0到20之间，母鸡数量在0到33之间，小鸡数量在0到99之间且数量必须为3的倍数的整数。通过for循环嵌套实现，第一层for循环遍历公鸡的数量，第二层遍历小鸡的数量，小鸡的数量每次递增3个，母鸡的数量用100减去公鸡的数量和小鸡的数量求得，还要判断母鸡的数量是否在0-33之间。
namespace CockHenChicknum
{
class Program
{
static void Main(string[] args)
{
int cock, hen, chick;
for (cock = 0; cock <= 20; cock++)
{
for (chick = 0; chick <= 99; chick += 3)
{
hen = 100 - cock - chick;
if (hen >= 0 && hen <= 33 && cock * 5 + chick / 3 + hen * 3 == 100)
{
Console.WriteLine("公鸡{0}只，母鸡{1}只，小鸡{2}只", cock, hen, chick);
}
}
}
}
}
}3.输出所有的水仙花数
实例描述：设计一个控制台程序Cube，用do或while循环实现，不允许使用for循环，输出所有这样的三位数：这个三位数本身恰好等于其每个数字的立方和（如153=13+53+33）。
答案： 153 370 371 407
namespace Cube
{
class Program
{
static void Main(string[] args)
{
int num = 100;
Console.Write("水仙花数有：");
do
{
int x = num / 100;//百位baidu
int y = num % 100 / 10;//十位
int z = num % 10;//个位
if (x * x * x + y * y * y + z * z * z == num)
{
Console.Write(" {0} ",num);
}
num += 1;
} while (num < 1000);
}
}
}
二、值类型与应用类型
1.学生的出生日期——DateTime类
实例描述：定义一个学生类，该类包含三个字段成员、和两个方法成员。然后声明并实例化两个学生对象，
1）从控制台输出两名学生信息；2）求出他们出生在星期几以及他们出生相差的天数。
实现过程：设计一个控制台程序StudentDateTime，定义名为Student的员工信息类，包括学号（number）、姓名（name）和出生日期（birthday）三个字段成员变量，SetInfo和GetInfo两个方法成员变量用来设置学生的信息和在控制台上输出学生的信息。在主函数中实例化两个学生对象s1和s2：1）通过点记号调用方法SetInfo设置这两个学生的信息，调用方法GetInfo将信息输出到屏幕上。2）利用DateTime类的属性DayOfWeek获取两名学生出生在星期几，用两个学生的生日只差获取他们出生相差的天数。
namespace StudentDataTime
{
enum WeekDayhz { 星期日, 星期一, 星期二, 星期三, 星期四, 星期五, 星期六 };
class Program
{
class Student
{
public string number; //学号
public string name; //姓名
public DateTime birthday; //出生日期
public void SetInfo(string xh, string xm, DateTime sr)
{
number = xh;
name = xm;
birthday = sr;
}
public void GetInfo()
{
Console.WriteLine("学号是{0}的学生的姓名是{1}，出生日期为{2}；", number, name,birthday);
}
}
static void Main(string[] args)
{
Student s1, s2;
s1 = new Student();
s2 = new Student();
DateTime birthday1 = new DateTime(1995, 10, 18);
DateTime birthday2 = new DateTime(1996, 2, 16);
s1.SetInfo("101","张三",birthday1);
s2.SetInfo("102","李四",birthday2);
s1.GetInfo();
s2.GetInfo();
int i = (int)s1.birthday.DayOfWeek;
Console.WriteLine("{0}出生在{1}", s1.name, (WeekDayhz)i);
i = (int)s2.birthday.DayOfWeek;
Console.WriteLine("{0}出生在{1}", s2.name, (WeekDayhz)i);
Console.WriteLine("{0}和{1}相差{2}天", s1.name, s2.name, s2.birthday - s1.birthday);
2.查找词语——String类
实例描述：给定一句话，用户输入一个词语，判断用户给定的词语是否在这句话中，返回检索结果。
实现过程：设计一个控制台程序FindWord，定义一个字符串，并赋初始值为一句话，然后由控制台输入一个词语，用String类中封装的某个方法判断输入的词语是否在上述的那句话中，并将检索结果打印在屏幕上。
namespace FindWord
{
class Program
{
static void Main(string[] args)
{
string sentence = "我希望有个如你一般的人 如山间清爽的风 如古城温暖的光 从清晨到夜晚 由山野到书房 只要最后是你就好";
Console.Write("请输入要检索的词语：");
string word = Console.ReadLine();
if (sentence.IndexOf(word)>=0)
{
Console.WriteLine("词语“{0}”在句子“{1}”中！",word,sentence);
}
else
{
Console.WriteLine("在句子中没有找到词语“{0}”，请重新输入检索词！", word);
}
3.修改班级的班主任和总人数——引用类型
实例描述：设计一个控制台程序 ，定义一个班级的结构类型。在结构类型中包含一个自定义类型的引用变量用来描述班级的学生人数。在主函数中通过描述两个班级的结构变量之间的赋值，理解值类型（结构类型）和引用类型（类）之间的区别。
实现过程：设计一个控制台程序Referencen ，定义一个信息类Information，在该类中只封装一个整型变量sumNum表示班级学生的总人数。定义表示班级的结构类型Class，在这个结构类型中声明一个字符串变量teacher表示班级的班主任，一个Information类的引用变量stuIfo表示这个班级的信息。在主函数中定义两个结构类型的变量class1和class2，并给class1的teacher和stuIfo赋值。然后通过class2=class1语句将class1的信息赋给class2，然后再修改class2的teacher和stuIfo的值。最终输出结果见图。
namespace Reference
{
struct Class //声明结构类型班级Class
{
public Information stuIfo; //学生信息
public string teacher; //班主任
};
class Information
{
public int sumNum; //总数量
}
class Program
{
static void Main(string[] args)
{
Class class1, class2;
Information stuInfo1 = new Information();
stuInfo1.sumNum = 30;
class1.stuIfo = stuInfo1;
class1.teacher = "Marry";
Console.WriteLine("一班的班主任是：{0}", class1.teacher);
Console.WriteLine("一班的总人数是：{0}", class1.stuIfo.sumNum);
Console.WriteLine("\n");
Console.WriteLine("将一班的信息赋值给二班!");
Console.WriteLine("\n");
class2 = class1;
Console.WriteLine("修改二班的班主任信息!");
class2.teacher = "Tom";
Console.WriteLine("二班的班主任是{0}：", class2.teacher);
Console.WriteLine("修改二班的学生人数!");
class2.stuIfo.sumNum = 31;
Console.WriteLine("二班的总人数是：{0}", class2.stuIfo.sumNum);
Console.WriteLine("\n");
Console.WriteLine("一班的班主任是{0}，总人数是{1}：", class1.teacher,class1.stuIfo.sumNum);
三、构造函数与方法
结构类型由若干字段组成的，每个字段都有自已的数据类型。
访问结构变量字段的一般格式如下：
结构变量名.字段名
结构变量的赋值： class2=class1
字段赋值方法与普通变量相同
两个类型相同的结构变量可以互相赋值。
构造函数具有如下性质：
构造函数的名称与类的名称相同
构造函数没有任何返回类型，因为它返回的一个新创建对象的引用
和方法头一样，构造函数头也有一个用括号围起来的参数列表，且可为空
不用点记号法调用
类可以有多个构造函数，但所有构造函数的名称都必须相同，它们的参数各不相同，即构造函数可以重载
当类对象创建时，构造函数会自动地执行；由于它们没有返回类型，因此不能像其他函数那样进行调用
当类对象声明时，调用哪一个构造函数取决于传递给它的参数类型
构造函数不能被继承
通常把构造函数声明为公有可访问性
class ComplexNumber
{ int real;
int imaginary;
public void Create()
{ Console.WriteLine(请输入实部:");
real = int.Parse(Console.ReadLine());
Console.WriteLine(“请输入虚部:");
imaginary = int.Parse(Console.ReadLine());
}
public void PrintResult()
{ Console.WriteLine(“两复数相加之和为:");
Console.WriteLine(real + "+" + imaginary + "i");
}
public ComplexNumber ComplexAdd(ComplexNumber Param1)
{ Param1.real += real ;
Param1.imaginary += imaginary;
return Param1;
}
}
public static void Main(string[] args)
{
ComplexNumber Number1 = new ComplexNumber();
ComplexNumber Number2 = new ComplexNumber();
Number1.Create();
Number2.Create();
ComplexNumber Temp = Number1.ComplexAdd(Number2);
Temp.PrintResult();
}
2.学生的信息初始化——构造函数
实现过程：设计一个控制台程序StudentInfo，定义名为Student的学生类，包括学号（number）、姓名（name）和班级（sclass）三个字段成员，一个有参数的构造函数和一个方法成员GetInfo（在控制台上输出学生的信息）。定义名为SStudent的学生结构类型，包括学号（number）、姓名（name）和班级（sclass）三个字段成员，一个方法成员SetInfo（为学生结构类型中的字段成员赋值）和一个方法成员GetInfo（在控制台上输出学生的信息）。
namespace StudentInfo
{
class Student
{
public string number; //学号
public string name; //姓名
public string sclass; //班级
public Student(string xh, string xm, string bj)
{
number = xh;
name = xm;
sclass = bj;
}
public void GetInfo()
{
Console.WriteLine("类Student中学号是{0}的学生的姓名是{1}，来自{2}；", number, name, sclass);
}
}
struct SStudent
{
public string number; //学号
public string name; //姓名
public string sclass; //班级
public void SetInfo(string xh, string xm, string bj)
{
number = xh;
name = xm;
sclass = bj;
}
public void GetInfo()
{
Console.WriteLine("结构类型SStudent中学号是{0}的学生的姓名是{1}，来自{2}；", number, name, sclass);
}
}
class Program
{
static void Main(string[] args)
{
Student s1 = new Student("101", "张三", "信息191");
Console.WriteLine("请输出学生s1的信息：");
s1.GetInfo();
Console.WriteLine("");
Student s2 = s1;
s2.number = "102";
s2.name = "王小花";
Console.WriteLine("请输出学生s1的信息：");
s1.GetInfo();
Console.WriteLine("");
Console.WriteLine("请输出学生s2的信息：");
s2.GetInfo();
Console.WriteLine("");
SStudent ss1 = new SStudent();
ss1.SetInfo("201", "云朵朵", "信息192");
Console.WriteLine("请输出学生ss1的信息：");
ss1.GetInfo();
Console.WriteLine("");
SStudent ss2 = ss1;
ss2.number = "202";
ss2.name = "令狐花";
Console.WriteLine("请输出学生ss1的信息：");
ss1.GetInfo();
Console.WriteLine("");
Console.WriteLine("请输出学生ss2的信息：");
ss2.GetInfo();
Console.WriteLine("");
}
}
}
3.计算不同级别员工的工资——方法重载
实现过程：设计一个控制台程序ReloadFunction，定义名为Employee的员工信息类，包括编号（number）、姓名（name）和职称（professionalTitle）三个私有的字段成员变量，有参数的构造函数 ，计算不同员工工资的方法及其重载等。在主函数中实例化三个员工e1、e2和e3分别对应三种职称，计算不同职称员工的工资并输出到屏幕上。
另：研究员的基本工资为1000元，工程师的基本工资为1200元，住房津贴500元，高级工程师的基本工资2000元，住房津贴1000元，奖金2000元。
namespace ReloadFunction
{
class Program
{
class Employee
{
int no;
string name;
string professionalTitle;
public Employee()
{ }
public Employee(int bh, string xm, string jb)
{
no = bh;
name = xm;
professionalTitle = jb;
}
public void GetIfo(int basesalary)
{
Console.WriteLine("编号{0},姓名{1},职称为{2}，薪水为：基本工资{3}元", no, name, professionalTitle, basesalary);
}
public void GetIfo(int basesalary, int housingAllowance)
{
Console.WriteLine("编号{0},姓名{1},职称为{2}，薪水为：基本工资{3}元+住房补贴{4}元={5}元", no, name, professionalTitle, basesalary, housingAllowance, basesalary + housingAllowance);
}
public void GetIfo(int basesalary, int housingAllowance, int reward)
{
Console.WriteLine("编号{0},姓名{1},职称为{2}，薪水为：基本工资{3}元+住房补贴{4}元+奖金{5}元={6}元", no, name, professionalTitle, basesalary, housingAllowance, reward, basesalary + housingAllowance + reward);
}
}
static void Main(string[] args)
{
Employee e1 = new Employee(001, "张三", "研究员");
Employee e2 = new Employee(002, "李四", "工程师");
Employee e3 = new Employee(003, "王五", "高级工程师");
e1.GetIfo(1000);
e2.GetIfo(1200, 500);
e3.GetIfo(2000, 1000, 2000);
}
}
}
4.计算平面上两点之间的距离——引用型参数
实现过程：设计一个控制台程序CalculateDistance，定义平面上的点类，包括两个私有的字段成员变量及构造函数，计算两点间距离的三种方法（用Tpoint类的引用变量作为参数的形参）。在主函数中实例化两个点，通过点记号调用不同的计算距离的方法，将这两点间的距离输出到屏幕上。
namespace CalculateDistance
{
class Program
{
class Point
{
double x;
double y;
public double X
{
get { return x; }
set { x = value; }
}
public double Y
{
get { return y; }
set { y = value; }
}
public void Eu_distance(Point p1)
{
double result;
result = Math.Sqrt(Math.Pow((x - p1.x), 2) + Math.Pow((y - p1.y), 2));
Console.WriteLine("点({0},{1})和点({2},{3})之间的欧式距离是：{4}",x,y,p1.x,p1.y,result);
}
public void MH_distance(Point p1)
{
double result;
result = Math.Abs(x - p1.x) + Math.Abs(y - p1.y);
Console.WriteLine("点({0},{1})和点({2},{3})之间的曼哈顿距离是：{4}", x, y, p1.x, p1.y, result);
}
public void Cos_distance(Point p1)
{
double result;
result = (x * p1.x + y * p1.y) / (Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2)) * Math.Sqrt(Math.Pow(p1.x, 2) + Math.Pow(p1.y, 2)));
Console.WriteLine("点({0},{1})和点({2},{3})之间的余弦距离是：{4}", x, y, p1.x, p1.y, result);
}
}
static void Main(string[] args)
{
Point p = new Point();
Point p1 = new Point();
p.X = 1;
p.Y = 1;
p1.X = 2;
p1.Y = 2;
p.Eu_distance(p1);
p.MH_distance(p1);
p.Cos_distance(p1);
}
}
}
四、属性与继承
1、显示学生所选课程的信息——对象交互
实例描述：学生成功的选上了一门公选课，请将该学生基本信息，该门课程的信息及该学生所选择的所有学分数输出在屏幕上。
实现过程：设计一个控制台程序InteractionObject，定义名为Student的学生信息类，包括学号、姓名、已修学分、选修的某门课程（Course类）4个字段，方法UpdateCredit将新选课程的学分添加到已修学分上更新已修学分。定义Course类，包含课程号，课程名称，学分和授课教师4个信息。在主函数中给出至少1个对象实例，将该学生基本信息，所选课程的信息及该学生所选择的所有学分数输出在屏幕上。
namespace InteractionObject
{
class Program
{
class Student
{
string id;
string name;
int scredits;
Course course;
public Student(string id, string name, int scredits, Course course)
{
this.id = id;
this.name = name;
this.scredits = scredits;
this.course = course;
}
public void UpdateCredit()
{
scredits += course.Credits;
}
public void display()
{
Console.WriteLine("该生的学号是{0}，姓名是{1}，已选择了《{2}》课，这门课的课程号是{3}，{4}学分，由{5}讲授，现在该生的总学分数是{6}"
,id,name,course.Name,course.Cid,course.Credits,course.Teacher,scredits);
}
}
class Course
{
string cid;
string cname;
int credits;
string teacher;
public Course(string cid,string cname,int credits,string teacher)
{
this.cid = cid;
this.cname = cname;
this.credits = credits;
this.teacher = teacher;
}
public string Cid
{
get { return cid; }
}
public string Name
{
get { return cname; }
}
public int Credits
{
get { return credits; }
}
public string Teacher
{
get { return teacher; }
}
}
static void Main(string[] args)
{
Course c = new Course("Scl178","高阶英语",4,"Marry");
Student s = new Student("101","王明",30,c);
s.UpdateCredit();
s.display();
}
}
}
2.输出学生信息——继承
实现过程：设计一个控制台程序Inheritance1，定义一个教师类Teacher，包含教工号、姓名两个字段，由类派生出一个导师类Advisor类，添加字段研究方向。定义名为Student的学生基类，包含学号和姓名两个字段成员，一个输出基本信息的方法。由Student类派生出本科生UnderGraduate类和研究生Graduate类，在本科生类中加入新的字段成员班主任(Teacher类)，在研究生类中加入新的字段成员导师(Advisor类)和研究方向 。在主函数中分别输出一个本科生对象和一个研究生对象的所有信息。
PS：每个类中封装的其它成员按需定义
namespace Inheritance1
{
class Teacher
{
string tid;
string tname;
public Teacher(string tid,string tname)
{
this.tid = tid;
this.tname = tname;
}
public string Tid
{
get
{
return tid;
}
}
public string Tname
{
get
{
return tname;
}
}
}
class Advisor:Teacher
{
string major;
public Advisor(string tid,string tname,string major):base(tid,tname)
{ this.major = major; }
public string Major
{
get
{
return major;
}
}
}
class Student
{
protected string sid;
protected string sname;
public Student(string sid, string sname)
{
this.sid = sid;
this.sname = sname;
}
}
class UnderGraduate : Student
{
Teacher teacher;
public UnderGraduate(string sid, string sname, Teacher teacher) : base(sid, sname)
{ this.teacher = teacher; }
public void Udisplay()
{
Console.WriteLine("该生学号：{0}，姓名：{1}；他班主任的工号：{2}，姓名：{3}。",sid,sname,teacher.Tid,teacher.Tname);
}
}
class Graduate : Student
{
Advisor advisor;
public Graduate(string sid, string sname, Advisor advisor) : base(sid, sname)
{ this.advisor = advisor; }
public void Gdisplay()
{
Console.WriteLine("该生学号：{0}，姓名：{1}；他导师的工号：{2}，姓名：{3}，研究方向：{4}。",sid,sname, advisor.Tid, advisor.Tname, advisor.Major);
}
}
class Program
{
static void Main(string[] args)
{
Teacher t = new Teacher("2020112", "Marry");
UnderGraduate ug = new UnderGraduate("20200101", "Rose",t);
ug.Udisplay();
Advisor a = new Advisor("2018111", "Jim", "信息行为");
Graduate g = new Graduate("20200201", "Jack", a);
g.Gdisplay();
}
}
}
2.计算圆柱体的表面积——派生类的构造函数
实例描述：定义一个圆形类，该类包含计算圆形面积的方法，由圆类派生出圆柱体类，并通过调用计算圆的面积公式来计算圆柱体的表面积。在主函数中分别计算一个圆和一个圆柱的面积并输出到屏幕上。
实现过程：设计一个控制台程序Inheritance2，定义名为Circle的圆形类，包括字段成员半径，有参数的构造函数和计算面积的方法。从圆形类派生出圆柱类Cylinder，添加新的字段成员圆柱的高和派生类的构造函数。在派生类中计算圆柱的表面积时用base关键字调用Circle类中计算圆形面积的方法。在主函数中分别定义圆类和圆柱类的对象，通过构造函数初始化，并计算它们的表面积数出在屏幕上。
PS. π = Math.PI,
圆柱体的表面积=两个底面圆的面积+侧面矩形的面积
namespace Ploymorphism
{
class Circle
{
protected double radius;
public Circle(double bj)
{
radius = bj;
}
public double CircleArea()
{
return Math.PI * radius * radius;
}
}
class Cylinder : Circle
{
double high;
public Cylinder(double r, double h)
: base(r)
{
high = h;
}
public double CylinderArea()
{
return base.CircleArea() * 2 + 2 * Math.PI * radius * high;
}
}
class Program
{
static void Main(string[] args)
{
Circle circle = new Circle(100);
Console.WriteLine("半径为100的圆的面积为{0:N2}", circle.CircleArea());
Cylinder cylinder = new Cylinder(100, 100);
Console.WriteLine("半径为100，高为100的圆柱体的表面积为{0:N2}", cylinder.CylinderArea());
五、多态
1.计算圆柱体和圆锥体的表面积——多态
实例描述：定义一个圆形类，该类包含计算面积的方法，圆柱体和圆锥体都继承了面积的计算方法，在主程序中虽然调用计算面积的方法，实现圆柱体和圆锥体的表面积
实现过程：设计一个控制台程序Ploymorphism，定义名为Circle的圆形类，包括半径和计算面积的虚方法。从圆形类派生出圆柱类Cylinder和圆锥类Cone。在两个派生类中重写计算面积的虚方法，计算圆柱体和圆锥体的表面积。
namespace Ploymorphism
{
class Circle
{
protected double radius;
public Circle(double bj)
{
radius = bj;
}
public virtual double Area()
{
return Math.PI * radius * radius;
}
}
class Cylinder : Circle
{
double high;
public Cylinder(double r, double h)
: base(r)
{
high = h;
}
public override double Area()
{
return base.Area() * 2 + 2 * Math.PI * radius * high;
}
}
class Cone : Circle
{
double high;
public Cone(double r, double h)
: base(r)
{
high = h;
}
public override double Area()
{
return base.Area() + Math.PI * radius * Math.Sqrt(radius * radius + high * high);
}
}
class Program
{
static void Main(string[] args)
{
Circle cylinder = new Cylinder(100, 100);
Console.WriteLine("半径为100，高为100的圆柱体的表面积为{0:N2}", cylinder.Area());
Circle cone = new Cone(100, 100);
Console.WriteLine("半径为100，高为100的圆锥体的表面积为{0:N2}", cone.Area());
}
}
}
2.输出不同员工的工资——new或虚方法
实例描述：在一家公司普通员工的工资为基本工资（1000元）加上工龄工资（每年增加30元）。本科生员工的工资为普通员工工资的2倍，研究生员工的工资是本科生员工工资的1.5倍。将三种不同员工的工资输出在屏幕上。分别用new或虚方法实现多态。
提示：使用base关键字会简化代码
namespace Proj7_1
{
class Program
{
public class Employee
{
int no;
string name;
int lengthofservice;
const double basesalary = 1000;
// double realsalary;
public int No
{
get { return no; }
set { no = value; }
}
public string Name
{
get { return name; }
set { name = value; }
}
public virtual double SetRealSalary()
{
Console.Write("请输入此人的工龄：");
lengthofservice = int.Parse(Console.ReadLine());
double realsalary = basesalary + 30 * lengthofservice;
return realsalary;
}
}
public class UEmployee:Employee
{
public override double SetRealSalary()
{
return base.SetRealSalary() * 2;
}
}
public class GEmployee : UEmployee
{
public override double SetRealSalary()
{
return base.SetRealSalary() * 1.5;
}
}
static void Main(string[] args)
{
Employee s1 = new Employee();
s1.No = 101;
s1.Name = "张三";
Console.WriteLine("普通职工 工号：{0} 姓名：{1}",s1.No,s1.Name);
Console.WriteLine("此人的实际工资为：{0}", s1.SetRealSalary());
Console.WriteLine();
UEmployee s2 = new UEmployee();
s2.No = 201;
s2.Name = "李四";
Console.WriteLine("本科生职工 工号：{0} 姓名：{1}", s2.No, s2.Name);
Console.WriteLine("此人的实际工资为：{0}", s2.SetRealSalary());
Console.WriteLine();
GEmployee s3 = new GEmployee();
s3.No = 301;
s3.Name = "王五";
Console.WriteLine("研究生职工 工号：{0} 姓名：{1}", s3.No, s3.Name);
Console.WriteLine("此人的实际工资为：{0}", s3.SetRealSalary());
}
}
}
3. 图书馆管理学生借书权限——抽象类
实例描述：定义一个抽象类，在抽象类中定义一个抽象方法描述图书馆的借书权限，本科生可以借5本书，硕士生可以借8本书，博士生可以借10本书
实现过程：设计一个控制台程序AstractClass，定义名为Student的抽象学生类，包括一个抽象方法Authority。从抽象学生类中派生三个具体的学生类：Undergraduate、Postgraduate和Doctor，在每个派生类中实现抽象方法。并在主函数中实例化三种学生，输出他们的信息和借阅权限
namespace AbstructClass
{
abstract class Student
{
public abstract void Authority();
}
class Undergraduate : Student
{
public override void Authority()
{
Console.WriteLine("本科生可以借5本书");
}
}
class Postgraduate : Student
{
public override void Authority()
{
Console.WriteLine("硕士生可以借8本书");
}
}
class Doctor : Student
{
public override void Authority()
{
Console.WriteLine("博士生可以借10本书");
}
}
class Program
{
static void Main(string[] args)
{
Undergraduate s1 = new Undergraduate();
s1.Authority();
Postgraduate s2 = new Postgraduate();
s2.Authority();
Doctor s3 = new Doctor();
s3.Authority();
}
}
}
4. 教师和学生信息的显示——抽象类
实例描述：定义一个抽象Person类，在抽象类中定义编号、姓名的抽象属性和输出信息的抽象方法。从这个类中派生出一个学生类一个教师类，实现学生和教师类的数据输入和输出，学生类包含学号，姓名，班级，成绩等字段，教师类包含工号、姓名、职称和部门等字段。在主函数中用相关数据测试程序。
namespace duotai1
{
abstract class Person
{
protected string no;
protected string name;
abstract public string No
{ set;}
abstract public string Name
{ set;}
abstract public void Display();
}
class Student : Person
{
string grade;
public override string No
{ set { no = value; } }
public override string Name
{ set { name = value; } }
public string Grade
{ set { grade = value; } }
public override void Display()
{
Console.WriteLine("学生的学号是{0}，姓名是{1}，班级是{2}！",no, name,grade);
}
}
class Teacher : Person
{
string professionalTitle;
string department;
public override string No
{ set { no = value; } }
public override string Name
{ set { name = value; } }
public Teacher(string no, string name, string professionalTitle, string department)
{
this.no = no;
this.name = name;
this.professionalTitle = professionalTitle;
this.department = department;
}
public override void Display()
{
Console.WriteLine("教师的学号是{0}，姓名是{1}，是{2}的{3}！", no, name, department, professionalTitle);
}
}
class Program
{
static void Main(string[] args)
{
Student s = new Student();
s.No = "19111701";
s.Name = "Mary";
s.Grade = "信息161";
s.Display();
Teacher t = new Teacher("2017001","Tom","副教授","信息管理系");
t.Display();
}
}
}
六、窗体应用程序
FindStudent
namespace FindStudent
{
public partial class Form1 : Form
{
public class Student
{
int no;
string name;
string sex;
int sclass;
DateTime birthday;
public Student(int no, string name, string sex, int sclass, DateTime birthday)
{
this.no = no;
this.name = name;
this.sex = sex;
this.sclass = sclass;
this.birthday = birthday;
}
public int No
{
get { return no; }
}
public string Name
{
get { return name; }
}
public string Sex
{
get { return sex; }
}
public int Sclass
{
get { return sclass; }
}
public DateTime Birthday
{
get { return birthday; }
}
}
Student[] Stu = new Student[] {new Student(101, "张三", "男", 1, new DateTime(1990, 2, 1)), new Student(102, "张四", "女", 1, new DateTime(1991, 12, 1)), new Student(201, "张五", "男", 2, new DateTime(1992, 7, 8)), new Student(202, "张花", "女", 2, new DateTime(1991, 1, 18)) };
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
for (int i = 0; i < Stu.Length; i++)
{
comboBox1.Items.Add(Stu[i].No);
comboBox2.Items.Add(Stu[i].Name);
}
}
private void button1_Click(object sender, EventArgs e)
{
bool flag = false;
if (comboBox1.Text != "")
{
for (int i = 0; i < Stu.Length; i++)
{
if (Convert.ToInt32(comboBox1.Text) == Stu[i].No)
{
textBox1.Text = Stu[i].No.ToString();
textBox2.Text = Stu[i].Name;
textBox3.Text = Stu[i].Sex;
textBox4.Text = Stu[i].Sclass.ToString();
textBox5.Text = Stu[i].Birthday.ToString();
flag = true;
}
}
if (flag == false)
MessageBox.Show("没有该学号的记录","信息提示", MessageBoxButtons.OK);
}
}
private void button2_Click(object sender, EventArgs e)
{
bool flag = false;
if (comboBox2.Text != "")
{
for (int i = 0; i < Stu.Length; i++)
{
if (comboBox2.Text == Stu[i].Name)
{
textBox1.Text = Stu[i].No.ToString();
textBox2.Text = Stu[i].Name;
textBox3.Text = Stu[i].Sex;
textBox4.Text = Stu[i].Sclass.ToString();
textBox5.Text = Stu[i].Birthday.ToString();
flag = true;
}
}
if (flag == false)
MessageBox.Show("没有该姓名的记录", "信息提示", MessageBoxButtons.OK);
}
}
private void button3_Click(object sender, EventArgs e)
{
textBox1.Text = "";
textBox2.Text = "";
textBox3.Text = "";
textBox4.Text = "";
textBox5.Text = "";
}
}
}
292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
