c#期末题库 类的设计

1.设计员工类（Worker）及其子类经理类（Manager），员工类包含私有字段name,salary；并设置其属性Name,Salary；经理类还有自己的私有成员字段bonus,及其对应属性Bonus；员工类、经理类都要有自己的无参、有参构造方法； 在main中创建一个员工数组（经理作为其一个元素），并为数组没个元素赋值，要求打印输出该员工数组的姓名和薪水信息。

  //Worker类
internal class Worker
    {
        // //员工类包含私有字段name,salary；并设置其属性Name,Salary；
        string name;
        double salary;

        public Worker(string name, double salary)
        {
            this.name = name;
            this.salary = salary;
        }
        public Worker()
        {

        }
//        在员工类中，我们定义了两个属性：Name 和 Salary。
//Name 属性用于访问和设置员工的姓名。通过定义 get 和 set 访问器，我们可以在外部代码中获取和修改 name 字段的值。
//Salary 属性用于访问和设置员工的薪水。同样地，通过定义 get 和 set 访问器，我们可以在外部代码中获取和修改 salary 字段的值。

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public double Salary
        {
            get { return salary; }
            set { salary = value; }
        }
    }
//Manager类
internal class Manager:Worker
{//经理类还有自己的私有成员字段bonus,及其对应属性Bonus；
    private double bonus;
    public Manager()
    {
        // 无参构造方法
    }
    public double Bonus
    {
        get { return bonus; }
        set { bonus = value; }
    }

   

    public Manager(string name, double salary, double bonus) : base(name, salary) { 
        
        this.bonus = bonus;
    }
}
//测试类
static void Main(string[] args)
{
    //1.设计员工类（Worker）及其子类经理类（Manager），
    //员工类包含私有字段name,salary；并设置其属性Name,Salary；经理类还有自己的私有成员字段bonus,及其对应属性Bonus；
    //员工类、经理类都要有自己的无参、有参构造方法； 
    //在main中创建一个员工数组（经理作为其一个元素），并为数组没个元素赋值，要求打印输出该员工数组的姓名和薪水信息。
    Worker[] employees = new Worker[2];

    employees[0] = new Worker("uzi", 5000);
    employees[1] = new Manager("faker", 8000, 2000);

    foreach (Worker employee in employees)
    {
        Console.WriteLine("Name: {0}" ,employee.Name);
        Console.WriteLine("Salary: {0}" , employee.Salary);
        Console.WriteLine();
    }
}
    

 

2.设计学生类(Student)及其子类研究生类(Graduate)，学生类包含私有成员字段name,credit；并包含其属性Name,Credit；研究生类包含自己的私有变量postCredit;并包含其属性PostCredit，学生类(Student)及其子类研究生类(Graduate)要有自己的无参、有参构造方法；现需创建一个研究生对象并设置其postcredit，另建立学生数组（研究生作为其一个元素），要求打印输出该学生数组的姓名和学分信息。

static void Main(string[] args)
{
    //2.设计学生类(Student)及其子类研究生类(Graduate)，学生类包含私有成员字段name,credit；并包含其属性Name,Credit；研究生类包含自己的私有变量postCredit; 
    //并包含其属性PostCredit，学生类(Student)及其子类研究生类(Graduate)要有自己的无参、有参构造方法；
    //现需创建一个研究生对象并设置其postcredit，另建立学生数组（研究生作为其一个元素），要求打印输出该学生数组的姓名和学分信息。
    Student[] students = new Student[2];
    Student student = new Student("Faker", 100);
    Graduate graduate = new Graduate("小虎", 99, 80);
    students[0] = student;
    students[1] = graduate;
    for (int i = 0; i < students.Length; i++)
    {
        Console.WriteLine("姓名：{0}，学分：{1}", students[i].Name, students[i].Credit);
    }
}
 internal class Student
 {
     2.设计学生类(Student)及其子类研究生类(Graduate)，学生类包含私有成员字段name,credit；并包含其属性Name,Credit；研究生类包含自己的私有变量postCredit; 
     string name;
     int credit;
     public Student()
     {

     }
     public Student(string name, int credit)
     {
         this.Name = name;
         this.Credit = credit;
     }

     public string Name
     {
         get { return name; }    
         set { name = value; }
     }
     public int Credit
     {
         get { return credit; }
         set { credit = value; } 
     }
    
 }

    internal class Graduate:Student
    {
        int postCredit;

       

        public int PostCredit
        {
            get { return postCredit; } 
            set { postCredit = value; }   
        }
        public Graduate()
        {

        }
        public Graduate(string name, int credit,int postCredit):base(name, credit)
        {
            this.postCredit = postCredit;
            //            在这个构造函数中，我们使用了 : base(name, credit) 这个语法，它表示在调用 Graduate 类的构造函数之前，先调用父类 Student 的构造函数，并传递 name 和 credit 作为参数。
           // 这种方式被称为构造函数的初始化列表（constructor initializer list），它允许我们在派生类的构造函数中显式调用父类的构造函数，并传递参数。
}
    }

 

 

3.定义一个名为Vehicles交通工具的基类：该类中包含私有成员字段商标和颜色，并设置其相应的公有属性；类中包含成员方法Run来模拟交通工具开动，该方法只输出“我已经开动了”信息；类中包含成员方法ShowInfo来显示信息，该方法输出显示商标和颜色；完成基类的无参有参构造方法，编写Car小汽车类继承于Vehicles类，对于此类：增加成员字段座位，并设置其相应的公有属性；增加成员方法ShowCar，输出显示小汽车的信息；覆盖父类的Run方法，输出显示“汽车开动了的信息”；完成小汽车类的无参有参构造方法；在main方法中测试以上各类。

static void Main(string[] args)
{
Vehicles vehicles = new Vehicles("奔驰","蓝色");
vehicles.Run();
vehicles.ShowInfo();
Car c = new Car("宝马", "黑色",2);
c.Run();
c.ShowCar();
}
//Vehicles类
internal class Vehicles
{
    //定义一个名为Vehicles交通工具的基类：
    //    该类中包含私有成员字段商标和颜色，并设置其相应的公有属性；
    //类中包含成员方法Run来模拟交通工具开动，该方法只输出“我已经开动了”信息；
    //    类中包含成员方法ShowInfo来显示信息，该方法输出显示商标和颜色；
    string brand;
    string color;
    public Vehicles() 
    {
    }
    public Vehicles(string brand, string color)
    {
        this.brand = brand;
        this.color = color;
    }

    public string Brand
    {
        get { return brand; }
        set { brand = value; }
    }
    public string Color
    {
        get { return color; }
        set { color = value; }
    }
    public void Run()
    {
        Console.WriteLine("我已经开动了");
    }
    public void ShowInfo()
    {
        Console.WriteLine("商标是{0},颜色是{1}",this.Brand,this.Color);
    }
}
//Car类
 internal class Car:Vehicles
 {
     int seat;
     public int Seat
     {
         get { return seat; }
         set { seat = value; }
     }
     ///编写Car小汽车类继承于Vehicles类，对于此类：
     //    增加成员字段座位，并设置其相应的公有属性；增加成员方法ShowCar，输出显示小汽车的信息；
     //    覆盖父类的Run方法，输出显示“汽车开动了的信息”；完成小汽车类的无参有参构造方法；
     public Car()
     {

     }
     public Car(string brand,string color,int seat) : base(brand, color)
     {
         this.seat = seat;
     }
     public void ShowCar()
     {
         Console.WriteLine("小汽车的品牌是：{0}，颜色是：{1}，座位是：{2}号", this.Brand, this.Color, this.seat);
     }
     public void Run()
     {
         Console.WriteLine("汽车开动了");
     }
 }

 

4.定义一个名为Vehicles交通工具的基类：该类中包含私有成员字段商标和颜色，并设置其相应的公有属性；类中包含成员方法run来模拟交通工具开动，该方法输出显示“我已经开动了”信息；类中包含成员方法ShowInfo来显示信息，该方法输出显示商标和颜色 完成父类的无参有参构造方法；编写Truck卡车类继承于Vehicles类对于此类：增加成员字段载重，并设置其相应的公有属性；增加成员方法showTruck，输出显示卡车的信息；完成卡车类的无参有参构造方法；覆盖父类的run方法，输出显示“开车开动了的信息”；

 static void Main(string[] args)
 {
     #region 4.定义一个名为Vehicles交通工具的基类：
     //    该类中包含私有成员字段商标和颜色，并设置其相应的公有属性；
     //        类中包含成员方法run来模拟交通工具开动，该方法输出显示“我已经开动了”信息；
     //        类中包含成员方法ShowInfo来显示信息，该方法输出显示商标和颜色 完成父类的无参有参构造方法；
     Vehicles v=new Vehicles("大车","grey");
     v.run();
     v.ShoowInfo();
     Trunk trunk = new Trunk("卡车","white",780);
     trunk.run();
     trunk.showTrunk();
     
     #endregion
 }
//Vehicles类
 internal class Vehicles
 {
     //    该类中包含私有成员字段商标和颜色，并设置其相应的公有属性；
     //        类中包含成员方法run来模拟交通工具开动，该方法输出显示“我已经开动了”信息；
     //        类中包含成员方法ShowInfo来显示信息，该方法输出显示商标和颜色 完成父类的无参有参构造方法；
     string brand;
     string color;
     public Vehicles() 
     {
     
     }
     public Vehicles(string brand, string color)
     {
         this.brand = brand;
         this.color = color;
     }

     public string Brand
     {
         get { return brand; }
         set { brand = value; }
     }
     public string Color
     {
         get { return color; }
         set { color = value; }  
     }
     public void run()
     {
         Console.WriteLine("我已经开动了");
     }
     public void ShoowInfo()
     {
         Console.WriteLine("车的商标是：{0}，车的颜色是：{1}", this.Brand, this.Color);
     }
 }
//Trunk类
     internal class Trunk :Vehicles
 {//编写Truck卡车类继承于Vehicles类对于此类：
  //增加成员字段载重，并设置其相应的公有属性；增加成员方法showTruck，输出显示卡车的信息；
  //完成卡车类的无参有参构造方法；覆盖父类的run方法，输出显示“开车开动了的信息”； 
     int weight;

     public int Weight
     {
         get { return weight; }
         set { weight = value; }
     }
     public Trunk()
     {

     }
     public Trunk(string brand, string color, int wgight) : base(brand, color)
     {
         this.Weight = wgight;
     }
     public  void showTrunk()
     {
         Console.WriteLine("卡车的牌子是:{0},颜色是：{1}，能载重{2}斤", this.Brand, this.Color, this.Weight);
     }    
     public void Run()
     {
         Console.WriteLine("汽车开动了");
     }
 }

 

 

5.创建一个名称为IVehicle的接口：在接口中添加两个方法Start()和Stop()用以描述车辆的启动和停止。创建Bike自行车类：该类包含私有成员字段wheel车轮个数，并设置其相应的公有属性；完成该类的无参有参构造方法；实现IVehicle接口的两个方法；创建Bus公共汽车类：该类包含私有成员字段seat座位个数，并设置其相应的公有属性；完成该类的无参有参构造方法；实现IVehicle接口的两个方法；在main方法中定义IVehicle数组，并存放Bike和Bus对象，来测试以上各类。

 static void Main(string[] args)
 {
     #region 5c
     //创建Bike自行车类：该类包含私有成员字段wheel车轮个数，并设置其相应的公有属性；
     //完成该类的无参有参构造方法；实现IVehicle接口的两个方法；
     //创建Bus公共汽车类：该类包含私有成员字段seat座位个数，并设置其相应的公有属性；
     //完成该类的无参有参构造方法；实现IVehicle接口的两个方法；在main方法中定义IVehicle数组，并存放Bike和Bus对象，来测试以上各类。
     IVehicle[] vehicle = new IVehicle[2];
     vehicle[0] = new Bike(2);
     vehicle[1] = new Bus(12);
     for(int i=0;i<vehicle.Length;i++)
     {
         vehicle[i].Start();
         vehicle[i].Stop();
         Console.WriteLine();
     }

         #endregion
 }
//接口 IVehicle
 internal interface IVehicle
 {
     public void start();
     public void stop();
 }
//Bus类
 internal class Bus : IVehicle
 {//创建Bus公共汽车类：该类包含私有成员字段seat座位个数，并设置其相应的公有属性；
  //完成该类的无参有参构造方法；实现IVehicle接口的两个方法；在main方法中定义IVehicle数组，并存放Bike和Bus对象，来测试以上各类。
     int seat;
     public Bus() { 

     }
     public Bus(int seat)
     {
         this.seat = seat;
     }

     public int Seat
     {
         get { return seat; }
         set { seat = value; }
     }

     public void Start()
     {
         Console.WriteLine("我是{0}座公交车，我要开动了",this.Seat);
     }

     public void Stop()
     {
         Console.WriteLine("公共汽车停止了");
     }
 }
//Bike类
 internal class Bike:IVehicle
 {//创建Bike自行车类：该类包含私有成员字段wheel车轮个数，并设置其相应的公有属性；
  //完成该类的无参有参构造方法；实现IVehicle接口的两个方法；
     int wheel;

     public int Wheel
     {
         get { return wheel; }
         set { wheel = value; }
     }
     public Bike()
     {

     }
     public Bike(int wheel)
     {
         this.Wheel = wheel;
     }
    
    public void Start()
     {
         Console.WriteLine("我是{0}轮自行车，我要启动了",this.Wheel);
     }

     public void Stop()
     {
         Console.WriteLine("自行车停止了");
         
     }
 }

 

 

6.定义一个宠物类(Pet)：该类包括两个方法：叫Cry(),吃东西Eat()；该类中定义私有的成员字段name姓名和age年龄，并设置其相应的公有属性；完成该类的无参有参构造方法；定义宠物的子类狗(Dog)：覆盖父类的Cry(),Eat()方法；增加方法看门GuardEntrance()完成该类的无参有参构造方法；定义宠物的子类猫(Cat)：覆盖父类的Cry(),Eat()方法；增加猫自己独有的方法捉老鼠HuntMice()；完成该类的无参有参构造方法；在main中定义两个Pet变量,pet1,pet2，采用引用转型实例化Dog,Cat,分别调用Pet的Cry(),Eat();将Pet强制转换为具体的Dog，Cat，在调Dog的GuardEntrance（），Cat的HuntMice()。

//多态：父类引用指向一个子类对象
//main方法
 static void Main(string[] args)
 {
     //6.6.定义一个宠物类(Pet)：该类包括两个方法：叫Cry(),吃东西Eat()；
     //    该类中定义私有的成员字段name姓名和age年龄，并设置其相应的公有属性；完成该类的无参有参构造方法；
     //    定义宠物的子类狗(Dog)：覆盖父类的Cry(),Eat()方法；增加方法看门GuardEntrance()完成该类的无参有参构造方法；
     //    定义宠物的子类猫(Cat)：覆盖父类的Cry(),Eat()方法；增加猫自己独有的方法捉老鼠HuntMice()；
     //    完成该类的无参有参构造方法；在main中定义两个Pet变量,pet1,pet2，采用引用转型实例化Dog,Cat,分别调用Pet的Cry(),Eat(); 
     //     将Pet强制转换为具体的Dog，Cat，在调Dog的GuardEntrance（），Cat的HuntMice()。
     Pet pet1=new Dog("小七",2);
     Pet pet2 = new Cat("娜娜",3);
     pet1.Cry();
     pet1.Eat();
     pet2.Cry();
     pet2.Eat();
     ((Dog)pet1).GuardEntrance();
     ((Cat)pet2).HuntMice();  
 }
//宠物类
 internal class Pet
 {
     //6.6.定义一个宠物类(Pet)：该类包括两个方法：叫Cry(),吃东西Eat()；
     //    该类中定义私有的成员字段name姓名和age年龄，并设置其相应的公有属性；完成该类的无参有参构造方法；
     string name;
     int age;
     public Pet()
     {

     }

     public Pet(string name, int age)
     {
         this.Name = name;
         this.Age = age;
     }

     public string Name
     {
         get { return name; }
         set { name = value; }
     }
     public int Age
     {
         get { return age; }
         set { age = value; }
     }
     public virtual void Cry()
     {
         Console.WriteLine("我是宠物，我叫{0}，我{1}岁了", this.Name, this.Age);

     }
     public virtual void Eat()
     {
         Console.WriteLine("Pet is eating.");
     }
 }
//狗类
  internal class Dog:Pet
  {
      //定义宠物的子类狗(Dog)：覆盖父类的Cry(),Eat()方法；增加方法看门GuardEntrance()完成该类的无参有参构造方法；
      public Dog() { 
      
      }
      public Dog(string name,int age):base(name,age) {
        

      }
      public override void Cry()
      {
          Console.WriteLine("我是小狗，我叫{0}，我{1}岁了", this.Name, this.Age);
      }
      public override void Eat()
      {
          Console.WriteLine("Dog is eating bones");
      }
      public void GuardEntrance()
      {
          Console.WriteLine("Dog is guarding the entrance");
      }

  }
//猫类
 internal class Cat:Pet
 {
     //定义宠物的子类猫(Cat)：覆盖父类的Cry(),Eat()方法；增加猫自己独有的方法捉老鼠HuntMice()； 完成该类的无参有参构造方法
     
     public Cat()
     {

     }
     public Cat(string name,int age):base(name,age)
     {

     }   
   public override void Cry()
     {
         Console.WriteLine("我是小猫，我叫{0}，我{1}岁了", this.Name, this.Age);
     }
     public override void Eat()
     {
         Console.WriteLine("Cat is eating fish.");
     }

     public void HuntMice()
     {
         Console.WriteLine("Cat is hunting mice");

     }
 }

 

 

7.创建一个名称为IShape的接口：在接口中添加求面积方法Area()和求体积方法Volumn()。定义一个立方体的类Prog：字段包括长、宽、高；并定义相应属性；方法包括：构造方法（初始化立方体的长宽高）；实现接口IShape；在main中创建一个立方体对象，计算并显示其面积和体积。

//main方法
 static void Main(string[] args)
 {
     //7.创建一个名称为IShape的接口：在接口中添加求面积方法Area()和求体积方法Volumn()。
     //    定义一个立方体的类Prog：字段包括长、宽、高；并定义相应属性；方法包括：构造方法（初始化立方体的长宽高）；
     //    实现接口IShape；在main中创建一个立方体对象，计算并显示其面积和体积。
    Prog p=new Prog(3,4,5);
     Console.WriteLine("立方体的面积是：{0}", p.Area());
     Console.WriteLine("立方体的体积是：{0}", p.Volumn());

 }
//Ishape接口
 internal interface IShape
 {
     //7.创建一个名称为IShape的接口：在接口中添加求面积方法Area()和求体积方法Volumn()。
   double Area();
    double Volumn();
 }
//Prog类
 internal class Prog : IShape
 {
     int length;
     int width;
     int height;
     //定义一个立方体的类Prog：字段包括长、宽、高；并定义相应属性；方法包括：构造方法（初始化立方体的长宽高）；
     public Prog(int length, int width, int height)
     {
         this.length = length;
         this.width = width;
         this.height = height;
     }

     public int Length
     {
         get { return length; }
         set { length = value; }
     }
     public int Width
     {
         get { return width; }
         set { width = value; }
     }
     public int Height
     {
         get { return height; }
         set { height = value; }
     }

     public double Area()
     {
         return (width * length + width * height + length * height) * 2;
     }

     public double Volumn()
     {
         return this.width * this.length * this.height;
     }
 }

 

8.创建一个名称为IShape的接口：在接口中添加求面积方法Area()和求体积方法Volumn()。定义一个球的类Ball：字段包括半径；并定义相应属性；方法包括：构造方法（初始化球的半径）；实现接口IShape；在main中创建一个球对象，计算并显示其面积和体积。

​​​​​​​

//main方法
static void Main(string[] args)
{
    //8.创建一个名称为IShape的接口：在接口中添加求面积方法Area()和求体积方法Volumn()。
    //    定义一个球的类Ball：字段包括半径；并定义相应属性；方法包括：构造方法（初始化球的半径）；
    //    实现接口IShape；在main中创建一个球对象，计算并显示其面积和体积。

    Ball b = new Ball(2);
    Console.WriteLine("球的面积是：{0}", b.Area());
    Console.WriteLine("球的体积是：{0}", b.Volumn());
}
//Ishape接口
 internal interface IShape
 {
     //7.创建一个名称为IShape的接口：在接口中添加求面积方法Area()和求体积方法Volumn()。
   double Area();
    double Volumn();
 }
//Ball类
internal class Ball:IShape
{
    //    定义一个球的类Ball：字段包括半径；并定义相应属性；方法包括：构造方法（初始化球的半径）；//实现接口IShape。
    double radius;

    public Ball(double radius)
    {
        this.Radius = radius;
    }

    public double Radius
    {
        get { return radius; }
        set { radius = value; }
    }

    public double Area()
    {
        return 4 * Math.PI * this.Radius * this.Radius;
    }

    public double Volumn()
    {
        return 4 / 3 * Math.PI * this.Radius * this.Radius * this.Radius;
    }
}

 

 

9.创建一个名称为Square的类： 该类中定义私有的成员字段edge，并设置其相应的公有属性；完成该类的无参有参构造方法；该类包含方法Circumference(周长)和面积(Area)；定义子类正方体Cube类：完成该类的无参有参构造方法；实现该类的面积(Area)和体积(Volumn)方法。在main中创建正方形对象，计算并显示其周长和面积；创建正方体对象，计算并显示其面积和体积。

//main方法
 static void Main(string[] args)
 {
     //9.创建一个名称为Square的类： 该类中定义私有的成员字段edge，并设置其相应的公有属性；
     //完成该类的无参有参构造方法；该类包含方法Circumference(周长)和面积(Area)；
     //定义子类正方体Cube类：完成该类的无参有参构造方法；实现该类的面积(Area)和体积(Volumn)方法。在main中创建正方形对象，计算并显示其周长和面积；创建正方体对象，计算并显示其面积和体积。
     Square square = new Square(4);
     Cube cube = new Cube(4);
     Console.WriteLine("正方形的周长是:{0}",square.Circumference());
     Console.WriteLine("正方形的面积是:{0}",square.Area());
     Console.WriteLine("正方体的面积是:{0}",cube.Area());
     Console.WriteLine("正方形的面积是:{0}",cube.Volumn());
 }
//square类
 internal class Square
 {
     //9.创建一个名称为Square的类： 该类中定义私有的成员字段edge，并设置其相应的公有属性；
     //完成该类的无参有参构造方法；该类包含方法Circumference(周长)和面积(Area)；
     double edge;
     public Square() { 
     
     }
     public Square(double edge)
     {
         this.Edge = edge;
     }

     public double Edge
     {
         get { return edge; }
         set { edge = value; }
     }
     public double Circumference()
     {
         return this.Edge * 4;
     }
     public double Area()
     {
         return this.Edge * this.Edge;
     }

 }
//Cube类
internal class Cube:Square
{
    //定义子类正方体Cube类：完成该类的无参有参构造方法；
    //实现该类的面积(Area)和体积(Volumn)方法
    public Cube()
    {

    }
    public Cube(double edge) : base(edge)
    {

    }
    public double Area()
    {
        return 6 * this.Edge * this.Edge;
    }
    public double Volumn()
    {
        return this.Edge * this.Edge*this.Edge;
    }
}

 

 

10.创建一个名称为Circle的类： 该类中定义私有的成员字段radius，并设置其相应的公有属性；完成该类的无参有参构造方法；该类包含方法Circumference(周长)和面积(Area)；定义子类圆柱体Cylinder类：字段包括高；并定义相应属性；完成该类的无参有参构造方法；实现该类的面积(Area)和体积(Volumn)方法。在main中创建圆类对象，计算并显示其周长和面积；创建圆柱体对象，计算并显示其面积和体积。

//main方法
static void Main(string[] args)
 {
     //10.创建一个名称为Circle的类： 该类中定义私有的成员字段radius，并设置其相应的公有属性；
     //    完成该类的无参有参构造方法；该类包含方法Circumference(周长)和面积(Area)；
     //    定义子类圆柱体Cylinder类：
     //    字段包括高；并定义相应属性；完成该类的无参有参构造方法；
     //    实现该类的面积(Area)和体积(Volumn)方法。
     //    在main中创建圆类对象，计算并显示其周长和面积；创建圆柱体对象，计算并显示其面积和体积。
     Circle circle = new Circle(3);
     circle.Area();
     circle.Circumference();
     Cylinder c = new Cylinder(3, 4);
     c.Area();
     c.Volumn();
 }
//Circle类
    internal class Circle
    {
        //10.创建一个名称为Circle的类： 该类中定义私有的成员字段radius，并设置其相应的公有属性；
        //    完成该类的无参有参构造方法；该类包含方法Circumference(周长)和面积(Area)；
        double radius;
        public Circle()
        {

        }
        public Circle(double radius)
        {
            this.Radius = radius;
        }

        public double Radius
        {
            get { return radius; } 
            set { radius = value; }
        }
        public void Circumference()
        {
            Console.WriteLine("圆的周长是:{0}", this.Radius * Math.PI * 2);

        }
        public void Area()
        {
            Console.WriteLine("圆的面积是:{0}",Math.PI*this.Radius*this.Radius);
        }

    }
//Cylinder类
    internal class Cylinder : Circle
    {

        //  定义子类圆柱体Cylinder类：
        //  字段包括高；并定义相应属性；完成该类的无参有参构造方法；
        //  实现该类的面积(Area)和体积(Volumn)方法。
        double height;
        public Cylinder()
        {

        }
        public Cylinder(double radius, double height):base(radius)
        {
            Height = height;
        }

        public double Height
        {
            get { return height; }
            set { height = value; }
        }

        public void Area()
        {
            Console.WriteLine("圆柱的表面积是:{0}", 2 * Math.PI * this.Radius * (this.Radius + this.Height));

        }
        public void Volumn()
    {
        Console.WriteLine("圆柱的体积是:{0}", Math.PI * this.Radius * this.Radius * this.Height);
    }
}

 

 

11.创建一个Student类，要求：(1)封装学生的姓名、性别和成绩等信息；(2)通过构造函数给姓名和性别信息赋值；(3)成绩信息通过属性进行读写，对成绩赋值时，如果成绩大于100分赋值100，小于0分赋值0；(4)具有一个判断成绩等级的方法；在main中使用Student类。

​​​​​​​

 static void Main(string[] args)
 {
     //            11.创建一个Student类，要求：
     //(1)封装学生的姓名、性别和成绩等信息；
     //(2)通过构造函数给姓名和性别信息赋值；
     //(3)成绩信息通过属性进行读写，对成绩赋值时，如果成绩大于100分赋值100，小于0分赋值0；
     //(4)具有一个判断成绩等级的方法；
     //在main中使用Student类。
     Student student = new Student("John", "男");
     student.Grade = 85;
     Console.WriteLine("学生的名字是:{0}，性别是：{1}，成绩是：{2}，等级是：{3} " ,student.Name,student.Gender,student.Grade,student.GetGrade());

 }
//Student类
 internal class Student
 {
     // 11.创建一个Student类，要求：
     //(1)封装学生的姓名、性别和成绩等信息；
     //(2)通过构造函数给姓名和性别信息赋值；
     //(3)成绩信息通过属性进行读写，对成绩赋值时，如果成绩大于100分赋值100，小于0分赋值0；
     //(4)具有一个判断成绩等级的方法；
     string name;
     string gender;
     double grade;

     public Student(string name, string gender)
     {
         this.Name = name;
         this.Gender = gender;
     }

     public string Name
     {
         get { return name; }
         set { name = value; }
     }
     public string Gender
     {
         get { return gender; }  
         set { gender = value; }
     }
         
     public double Grade
     {
         get { return grade; }

         set
         {
             if (value > 100)
             {
                 grade = 100;
             }
             else if (value < 0)
             {
                 grade = 0;
             }
             else

                 grade = value;


         }

     }
     public string GetGrade()
     {
         if (grade >= 90)
         {
             return "A";
         }
         else if (grade >= 80)
         {
             return "B";
         }
         else if (grade >= 70)
         {
             return "C";
         }
         else if (grade >= 60)
         {
             return "D";
         }
         else
         {
             return "F";
         }
     }
 }

 

 

12.创建一个List类，可以存储整数、实数、字符数据等，并具有可以添加、删除、获取指定位置的元素、获取元素的个数、获取所有元素等方法。并在main中进行相关测试。

 

 //List类
internal class List
  {

      //创建一个List类，可以存储整数、实数、字符数据等，并具有可以添加、删除、获取指定位置的元素、获取元素的个数、获取所有元素等方法。

      const int Max = 100;
      int num=0;
      object[] listArray = new object[Max]; //这是一个对象数组，用于存储添加到列表中的元素。我们使用object类型的数组，以便可以存储任何类型的对象。

      public void Add(object obj)
      {
          listArray[num] = obj;
          num++;
          Console.WriteLine("你得到的新数组为:");
          for(int i = 0; i < num; i++)
          {
              Console.Write("{0} ",listArray[i]);
          }
          Console.WriteLine();
      }
      public void Delete()
      {
          int pos;
          Console.WriteLine("请输入你想要删除元素的位置:");
          pos=int.Parse((Console.ReadLine()));
          if(pos>=0&&pos<num) {
          for(int i=pos;i<num-1;i++) {
                  listArray[i] = listArray[i+1];
              }
          num--;
              Console.WriteLine("你得到的新数组为:");
              for(int i = 0; i < num; i++)
              {
                  Console.Write("{0} ", listArray[i]) ;
              }
              Console.WriteLine();
          }
          else
          {
              Console.WriteLine("位置超出范围");
          }
      }
      public void GetNum()
      {
          Console.WriteLine("当前元素的个数为：{0}", num);
      }

      public void Get()
      {
          int pos;
          Console.WriteLine("请输入您想要获得的元素的位置：");
          pos = int.Parse(Console.ReadLine());

          if (pos >= 0 && pos < num)
          {
              Console.WriteLine("您得到的元素为：");
              Console.WriteLine("{0}", listArray[pos]);
              Console.WriteLine("");
          }
          else
          {
              Console.WriteLine("位置超出范围！");
          }
      }

      public void Display()
      {
          Console.WriteLine("您得到的新数组为：");
          for (int i = 0; i < num; i++)
          {
              Console.Write("{0}  ", listArray[i]);
          }
          Console.WriteLine("");
      }
  }
//main方法
static void Main(string[] args)
{
    //12.创建一个List类，可以存储整数、实数、字符数据等，并具有可以添加、删除、获取指定位置的元素、获取元素的个数、获取所有元素等方法。
    //    并在main中进行相关测试。
    List myList = new List();
    myList.Add("Faker");
    myList.Add("will");
    myList.Add("be");
    myList.Add("****");
    myList.Add("****");
    myList.Display();
    myList.Get();
    myList.Delete();
    myList.GetNum();
    myList.Display();
}

 

 

13.输入若干学生的学号、姓名、英语、数学、语文、物理、化学、生物成绩，并求出总分和平均分，按总分从高到低排序。要求：设计一个学生类Student，所有学生对象存储到数组中，按总分排序，并输出最后结果。

//main方法
static void Main(string[] args)
{
    //13.输入若干学生的学号、姓名、英语、数学、语文、物理、化学、生物成绩，并求出总分和平均分，按总分从高到低排序。
    //    要求：设计一个学生类Student，所有学生对象存储到数组中，按总分排序，并输出最后结果。
    const int N = 2;
    Student[] students=new Student[N];
    for(int i=0;i<students.Length;i++)
    {
    Student student = new Student();//每次循环迭代都会创建一个新的Student对象，并为其分配独立的内存空间。这样可以确保每个对象都有自己的数据，并且在内存中独立存在。
        Console.Write("请输入第{0}个学生学号：",i+1);
        student.Studentid = Console.ReadLine();
        Console.Write("请输入第{0}个学生姓名：", i + 1);
        student.Name = Console.ReadLine();
        Console.Write("请输入第{0}个学生的英语成绩：", i + 1);
        student.EnglishScore = double.Parse(Console.ReadLine());
        Console.Write("请输入第{0}个学生的数学成绩：", i + 1);
        student.MathScore = double.Parse(Console.ReadLine());
        Console.Write("请输入第{0}个学生的语文成绩：", i + 1);
        student.Chinesescore = double.Parse(Console.ReadLine());
        Console.Write("请输入第{0}个学生的物理成绩：", i + 1);
        student.PhysicsScore= double.Parse(Console.ReadLine());
        Console.Write("请输入第{0}个学生的生物成绩：", i + 1);
        student.BiologyScore = double.Parse(Console.ReadLine());
        Console.Write("请输入第{0}个学生的化学成绩：", i + 1);
        student.ChemistryScore = double.Parse(Console.ReadLine());
        students[i] = student;
    }
    Array.Sort(students, (a, b) => { return (int)(b.Sum - a.Sum); });//b-a是降序，a-b是升序

    Console.WriteLine("按总分排名：");
    //隐式类型本地变量 var 关键字指示编译器通过初始化语句右侧的表达式推断变量的类型。
 for(int i=0;i<students.Length; i++)
    {
        Console.WriteLine(students[i]);
    }
}
//Student类
  internal class Student
 {
     //13.输入若干学生的学号、姓名、英语、数学、语文、物理、化学、生物成绩，并求出总分和平均分，按总分从高到低排序。
     //    要求：设计一个学生类Student，所有学生对象存储到数组中，按总分排序，并输出最后结果。
     string studentid;
     string name;
     double englishScore;
     double mathScore;
     double chinesescore;
     double physicsScore;
     double chemistryScore;
     double biologyScore;
     double sum;
     double ave;
     public Student()
     {

     }
     public string Studentid { get => studentid; set => studentid = value; }
     public string Name { get => name; set => name = value; }
     //注意：属性如果采用expression-bodied形式，则只能执行一条语句
     public double EnglishScore { get => englishScore; set { englishScore = value; sum += value; } }
     public double MathScore { get => mathScore; set { mathScore = value; sum += value; } }
     public double Chinesescore { get => chinesescore; set { chinesescore = value; sum += value; } }
     public double PhysicsScore { get => physicsScore; set { physicsScore = value; sum += value; } }
     public double ChemistryScore { get => chemistryScore; set { chemistryScore = value; sum += value; } }
     public double BiologyScore { get => biologyScore; set { biologyScore = value; sum += value; } }
     public double Sum { get => sum; set => sum = value; }
     public double Ave { get => ave; set => ave = value; }

     public override string ToString()//ToString 方法是从基类 Object 继承而来的虚方法。通过使用 override 关键字，您可以重写基类的 ToString 方法，并提供自定义的实现
     {
         return String.Format("学号{0} 姓名：{1} 英语：{2} 数学：{3} 语文:{4} 化学:{5} 物理:{6} 生物：{7} 平均分:{8} 总分：{9}", studentid, Name, englishScore, mathScore, chinesescore, chemistryScore, physicsScore, biologyScore, sum/6, Sum);
     }

 }

 

 

14.设计一个抽象类Calculate，该类包括：(1)optA、optB、optC三个double类型的字段；(2)带有两个double类型参数的构造函数（给optA和optB赋值）；(3)计算三个数和的平方根SqrtForSum抽象方法，该方法带有三个double类型的参数，返回值类型为double(4)设计一个继承Calculate的派生类Cal，该类包含一个带有三个double类型参数的构造函数，并重写SqrtForSum方法；(5)在main中进行相关数据验证。

 

//Calculate类
internal abstract class Calculate
{
    //14.设计一个抽象类Calculate，该类包括：(1)optA、optB、optC三个double类型的字段；
    //(2)带有两个double类型参数的构造函数（给optA和optB赋值)
    //(3)计算三个数和的平方根SqrtForSum抽象方法，该方法带有三个double类型的参数，返回值类型为double
    double optA;
    double optB;
    double optC;

    public Calculate(double optA, double optB)
    {
        this.OptA = optA;
        this.OptB = optB;
    }

    public double OptA
    {
        get { return optA; }
        set { optA = value; }
    }
    public double OptB
    {
        get { return optB; }
        set { optB = value; }   
    }

    public double OptC
    {
        get { return optC; }
        set
        {
            optC = value;
        }
    }
    public abstract double SqrtForSum(double optA, double optB, double optC);
   
    
}
//Cal类
 internal class Cal : Calculate
 {
     //设计一个继承Calculate的派生类Cal，该类包含一个带有三个double类型参数的构造函数，并重写SqrtForSum方法；(5)在main中进行相关数据验证。
     public Cal(double optA,double optB,double optC) : base(optA, optB)
     {
         this.OptC = optC;
     }

     public override double SqrtForSum(double optA, double optB, double optC)
     {
         return Math.Sqrt(optA) + Math.Sqrt(optB) + Math.Sqrt(optC);
     }
 }
//main方法
  static void Main(string[] args)
  {
      //14.设计一个抽象类Calculate，该类包括：(1)optA、optB、optC三个double类型的字段；
      //(2)带有两个double类型参数的构造函数（给optA和optB赋值)
      //(3)计算三个数和的平方根SqrtForSum抽象方法，该方法带有三个double类型的参数，返回值类型为double
      //(4)设计一个继承Calculate的派生类Cal，该类包含一个带有三个double类型参数的构造函数，并重写SqrtForSum方法；(5)在main中进行相关数据验证。

      Cal c = new Cal(1, 1, 1);
      Console.WriteLine("三数平方根之和是:{0}",c.SqrtForSum(c.OptA,c.OptB,c.OptC));

  }

 

 

15.设计一个程序，模拟银行存取款业务，要求如下：(1)定义一个接口IBankAccount，包含三个成员，存款方法PayIn，取款方法WithDraw和余额属性Banlance(2)定义一个派生接口ITransfer，基接口为IBankAccount，包含一个转账方法Tansfer；(3)定义一个类Account，继承ITransfer，并实现类该接口的所有成员；在main中实现存款、取款、转账、显示余额等操作。

 

//main方法
 static void Main(string[] args)
 {
     //15.设计一个程序，模拟银行存取款业务，要求如下：(1)定义一个接口IBankAccount，包含三个成员，存款方法PayIn，取款方法WithDraw和余额属性Banlance
     //    (2)定义一个派生接口ITransfer，基接口为IBankAccount，包含一个转账方法Tansfer；
     //    (3)定义一个类Account，继承ITransfer，并实现类该接口的所有成员；在main中实现存款、取款、转账、显示余额等操作。


     Account account1 = new Account();
     Account account2 = new Account();

     account1.PayIn(1000);
     account1.WithDraw(500);
     account1.Transfer(200, account2);//在这个方法中，IBankAccount destn 表示我们可以传递实现了 IBankAccount 接口的任何对象作为参数

     Console.WriteLine("账户1余额:{0} " ,account1.Banlance());
     Console.WriteLine("账户2余额: {0}",account2.Banlance());

 }
 //IBankAccount接口
 internal interface IBankAccount
 {
     //15.设计一个程序，模拟银行存取款业务，要求如下：(1)定义一个接口IBankAccount，包含三个成员，存款方法PayIn，取款方法WithDraw和余额属性Banlance
     void PayIn(double amount);
     void WithDraw(double amount);
     double Banlance();
 }
//ITransfer接口
internal interface ITransfer:IBankAccount
{
    //(2)定义一个派生接口ITransfer，基接口为IBankAccount，包含一个转账方法Tansfer；
    void Transfer(double amount,IBankAccount destn);
}
//Account类
internal class Account : ITransfer
{
    // (3)定义一个类Account，继承ITransfer，并实现类该接口的所有成员；
    double balance=0;
   
    public double Banlance()
    {
     return balance;
    }

   

    public void PayIn(double amount)
    {
        balance += amount;
        
    }

    public void Transfer(double amount, IBankAccount destn)
    {
       if(amount<=balance)
        {
            WithDraw(amount);
            destn.PayIn(amount);
            Console.WriteLine("转账成功");
        }
       else
        {
            Console.WriteLine("余额不足，转账失败");
        }
    }

    public void WithDraw(double amount)
    {
       if(amount<=balance) {

            balance -= amount;
                }
        else
        {
            Console.WriteLine("余额不足");
        }
    }
}

​​​​​​​ ​​​​​​​