一．面向对象封装性编程

创建一个控制台应用程序，要求：

1．定义一个服装类（Cloth），具体要求如下

（1）包含3个字段：服装品牌（mark）,服装颜色（color），定价（price）

（2）一个接收3个参数的构造函数

（3）自定义函数Information，输出一个服装实例的所有信息。

2．在主类中实现如下功能

（1）调用构造函数，创建1个服装类的实例

（2）通过该实例调用Information方法，获取该实例信息。如图1所示。

 public class Cloth
 {
     // 字段
     public string mark;   // 服装品牌
     public string color;  // 服装颜色
     public decimal price; // 定价

     // 构造函数
     public Cloth(string mark, string color, decimal price)
     {
         this.mark = mark;
         this.color = color;
         this.price = price;
     }

     // 自定义函数Information，输出服装实例的所有信息
     public void Information()
     {
         Console.WriteLine($"服装品牌: {mark}，颜色: {color}，定价: {price}元");
     }
 }
 private static void Main(string[] args)
 {
     // 调用构造函数，创建一个服装类的实例
     Cloth newCloth = new Cloth("笨小孩", "蓝色", 300);

     // 通过该实例调用Information方法，获取该实例信息
     newCloth.Information();

     // 程序结束等待用户输入，以便查看输出信息
     Console.ReadLine();
 }

二、面向对象继承性编程

创建一个控制台应用程序，要求：

1.自定义一个Fruit类，添加name字段和构造函数，添加Info方法输出水果信息；

2.再定义一个Banana类，Banana类继承Fruit类，在Banana类中添加color字段和构造函数，再添加一个like方法；

3.测试类Main方法中实例化两个类对象，输出如图2所示。

// 自定义Fruit类
public class Fruit
{
    // 字段
    public string name;

    // 构造函数
    public Fruit(string name)
    {
        this.name = name;
    }

    // Info方法输出水果信息
    public void Info()
    {
        Console.WriteLine($"名称：{name}");
    }
}

// Banana类继承Fruit类
public class Banana : Fruit
{
    // 字段
    public string color;

    // 构造函数
    public Banana(string name, string color) : base(name)
    {
        this.color = color;
    }
    public void InfoCOLOR()
    {
        Console.WriteLine($"名称：{color}");
    }

    // like方法
    public void Like()
    {
        Console.WriteLine($"猴子喜欢吃{color}的{name}！");
    }
}
private static void Main(string[] args)
{
    // 实例化Fruit类对象
    Fruit fruit = new Fruit("香蕉");
    fruit.Info();

    // 实例化Banana类对象
    Banana banana = new Banana("香蕉", "黄色");
    banana.InfoCOLOR(); // 调用基类的InfoCOLOR方法
    banana.Like();

    // 等待用户输入，以便查看输出信息
    Console.ReadLine();
}

三、面向对象多态性编程。

创建一个控制台应用程序，要求：

1.定义一个Vehicle类，包含name字段和虚方法Wheel；

2.再定义一个Car类，继承Vehicle类，重写Wheel方法；

3.再定义一个Bike类，继承Vehicle类，重写Wheel方法；

4.测试类Main方法中，定义Vehicle数组，长度为3，实例化各类对象，输出如图3所示。

// 定义Vehicle基类
public class Vehicle
{
    public string Name { get; set; }

    // Vehicle类的构造函数
    public Vehicle(string name)
    {
        Name = name;
    }

    // 虚方法Wheel
    public virtual void Wheel()
    {
        Console.WriteLine($"{Name} 都有轮子");
    }
}

// Car类继承Vehicle类，并重写Wheel方法
public class Car : Vehicle
{
    public Car(string name) : base(name) { }

    // 重写Wheel方法
    public override void Wheel()
    {
        Console.WriteLine($"{Name} 有四个轮子");
    }
}

// Bike类继承Vehicle类，并重写Wheel方法
public class Bike : Vehicle
{
    public Bike(string name) : base(name) { }

    // 重写Wheel方法
    public override void Wheel()
    {
        Console.WriteLine($"{Name} 有两个轮子");
    }
}
private static void Main(string[] args)
{
    // 创建一个Vehicle类型的数组，长度为3
    Vehicle[] vehicles = new Vehicle[3];

    // 实例化各类对象并添加到数组中
    vehicles[0] = new Car("交通工具");
    vehicles[1] = new Bike("汽车");
    vehicles[2] = new Vehicle("自行车"); // 默认使用基类的Wheel方法

    // 遍历数组并调用Wheel方法
    foreach (var vehicle in vehicles)
    {
        vehicle.Wheel();
    }

    // 等待用户输入，以便查看输出信息
    Console.ReadLine();
}

四． 委托与事件

创建一个控制台应用程序，要求：

1.定义一个Monitor类和一个Student类，模拟收作业过程；

2.定义委托类型Mydele和事件Homework；

3.班长说开始收作业，学生响应消息交作业。输出如图4所示。

// 定义委托类型MyDelegate
    public delegate void MyDelegate(string message);

    // 定义事件Homework
    public class HomeworkEventArgs : EventArgs
    {
        public string Message { get; }

        public HomeworkEventArgs(string message)
        {
            Message = message;
        }
    }

    // 定义Monitor类
    public class Monitor
    {
        // 事件声明
        public event EventHandler<HomeworkEventArgs> Homework;

        // 开始收作业的方法
        public void StartCollectingHomework()
        {
            Console.WriteLine("班长说：‘开始收作业！’");

            // 检查是否有订阅者，并触发事件
            Homework?.Invoke(this, new HomeworkEventArgs("请交上作业！"));
        }
    }

    // 定义Student类
    public class Student
    {
        public string Name { get; }

        public Student(string name)
        {
            Name = name;
        }

        // 订阅事件并响应作业提交
        public void SubscribeHomeworkEvent(Monitor monitor)
        {
            monitor.Homework += OnHomeworkReceived;
        }

        // 事件处理方法
        private void OnHomeworkReceived(object sender, HomeworkEventArgs e)
        {
            Console.WriteLine($"{Name}说：‘好的，我这就交作业。’");
        }
    }
    private static void Main(string[] args)
    {
        // 创建Monitor对象
        Monitor monitor = new Monitor();

        // 创建Student对象
        Student student1 = new Student("学生A");
        Student student2 = new Student("学生B");

        // 学生订阅收作业事件
        student1.SubscribeHomeworkEvent(monitor);
        student2.SubscribeHomeworkEvent(monitor);

        // 班长开始收作业，触发事件
        monitor.StartCollectingHomework();

        Console.ReadLine(); // 等待用户输入，以便查看输出信息
    }