Windows程序设计作业周黑鸭工厂

逗雪人

已于 2024-04-08 22:35:17 修改

阅读量610

点赞数 8

文章标签： windows

于 2024-04-08 22:11:22 首次发布

本文链接：https://blog.csdn.net/qq_74390263/article/details/137481652

版权

0.作业内容

使用 C# 编码（涉及类、接口、委托等关键知识点），实现对周黑鸭工厂的产品生产统一管理，主要产品包括鸭脖和鸭翅。武汉工厂能生生产鸭脖和鸭翅，南京工厂只能生产鸭翅，长沙工厂只能生产鸭脖。具体要求如下：

定义接口 IProductionFactory，包含生产鸭脖和鸭翅的方法。
定义类 WuhanFactory、NanjingFactory、ChangshaFactory 分别实现接口 IProductionFactory，用于具体的生产工厂。
使用委托 ProductionDelegate 定义生产委托。

1.代码实现

1.1定义接口

接口是一种定义一组方法的契约，但它不包含这些方法的实现。一个类可以实现一个或多个接口，从而承诺它将提供这些接口中定义的方法的具体实现。

接口的主要特点：

不能实例化：接口本身不能创建对象，它只是一个规范或契约。
包含方法签名：接口可以包含方法、属性、事件和索引器的签名，但不包含实现。
隐式实现：当一个类实现一个接口时，它必须提供接口中所有方法的实现。
多态性：通过接口，可以实现多态性，即使用接口类型的变量来引用实现了该接口的任何类的对象。

定义接口 IProductionFactory，分别是生产鸭脖和鸭翅的方法。

public interface IProductionFactory
{
    void ProduceDuckNecks();
    void ProduceDuckWings();
}

1.2定义具体的类

1.2.1武汉工厂（鸭脖，鸭翅）

public class WuhanFactory : IProductionFactory  
{  
    public void ProduceDuckNeck()  
    {  
        Console.WriteLine("Wuhan Factory is producing Duck Neck.");  
        //在此处可以对duckneck进行实例化并进行生产操作  
    }  
  
    public void ProduceDuckWing()  
    {  
        Console.WriteLine("Wuhan Factory is producing Duck Wing."); 
        //  在此处可以对duckwing进行实例化并进行生产操作}  
}

1.2.2南京工厂（鸭翅）

对于不能生产的鸭脖部分进行抛异常处理，下一部分的长沙工厂也一样

public class NanjingFactory : IProductionFactory  
{  
    public void ProduceDuckNeck()  
    {  
        throw new NotSupportedException("Nanjing Factory does not produce Duck Neck.");
        //对不能进行加工的鸭翅部分进行抛异常处理  
    }  
  
    public void ProduceDuckWing()  
    {  
        Console.WriteLine("Nanjing Factory is producing Duck Wing.");  
        // 这里可以实例化 DuckWing 并进行生产操作  
    }  
}

1.2.3长沙工厂（鸭脖）

public class ChangshaFactory : IProductionFactory  
{  
    public void ProduceDuckNeck()  
    {  
        Console.WriteLine("Changsha Factory is producing Duck Neck.");  
        // 这里可以实例化 DuckNeck 并进行生产操作  
    }  
  
    public void ProduceDuckWing()  
    {  
        throw new NotSupportedException("Changsha Factory does not produce Duck Wing.");
        //对不能生产的鸭翅部分进行抛异常处理  
    }  
}

2.定义委托

2.1委托代码语句

public delegate void ProductionDelegate();

2.2委托注意事项

委托是一种类型安全的函数指针，它用于封装方法的签名和引用。通过委托，可以将方法作为参数传递，或者将方法赋值给变量，从而实现回调和事件处理等功能。

委托的主要特点：

类型安全：委托是类型安全的，即它只能引用与其定义时指定的签名匹配的方法。
封装方法引用：委托可以封装对静态方法或实例方法的引用。
回调和事件：委托常用于实现回调机制和事件驱动编程。

3.具体实现

internal class Program
    {

        static void Main(string[] args)
        {

            try
            {
                // 实例化工厂并测试生产    
                IProductionFactory wuhanFactory = new WuhanFactory();
                wuhanFactory.ProduceDuckNecks();
                wuhanFactory.ProduceDuckWings();

                IProductionFactory nanjingFactory = new NanjingFactory();
                nanjingFactory.ProduceDuckWings();
                try
                {
                    nanjingFactory.ProduceDuckNecks(); // 注意：尝试生产鸭脖将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Nanjing Factory does not produce Duck Neck: " + ex.Message);
                }

                IProductionFactory changshaFactory = new ChangshaFactory();
                changshaFactory.ProduceDuckNecks();
                try
                {
                    changshaFactory.ProduceDuckWings(); // 注意：尝试生产鸭翅将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Changsha Factory does not produce Duck Wing: " + ex.Message);
                }

                // 使用委托来封装生产动作    
                ProductionDelegate produceDuckNecksDelegate = new ProductionDelegate(wuhanFactory.ProduceDuckNecks);
                produceDuckNecksDelegate.Invoke();

                ProductionDelegate produceDuckWingsDelegate = new ProductionDelegate(nanjingFactory.ProduceDuckWings);
                produceDuckWingsDelegate.Invoke();
            }
            catch (Exception ex)
            {
                // 捕获其他未处理的异常  
                Console.WriteLine("An unhandled exception occurred: " + ex.Message);
            }

            Console.ReadLine();
        }

    }
    }

4.运行结果

4.1正常运行结果

4.2 抛出异常运行结果

5.小结

本次的难点在于如何合理得使用类和接口使得不同的工厂可以调用不同的生产产品，保证每个生产类能够正确地实现接口中方法，委托的使用使得我们可以更加灵活地调用不同工厂的生产方法。通过将委托作为参数传递，我们可以轻松地在不修改代码结构的情况下，添加新的工厂或改变生产逻辑。

在程序中能够处理异常也是不可忽略的，我开始出现了程序崩溃无法接下去运行的情况，这是因为对我在main方法中并没有对这些异常进行捕获和处理。见到了如下窗口：

6.完整代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public interface IProductionFactory
{
    void ProduceDuckNecks();
    void ProduceDuckWings();
}

namespace duckproduct
{

    public class WuhanFactory : IProductionFactory
    {
        public void ProduceDuckNecks()
        {
            Console.WriteLine("Wuhan Factory is producing Duck Neck.");
            //在此处可以对duckneck进行实例化并进行生产操作  
        }

        public void ProduceDuckWings()
        {
            Console.WriteLine("Wuhan Factory is producing Duck Wing.");
            //  在此处可以对duckwing进行实例化并进行生产操作}  
        }
    }
    public class NanjingFactory : IProductionFactory
        {
            public void ProduceDuckNecks()
            {
                throw new NotSupportedException("Nanjing Factory does not produce Duck Neck.");
                //对不能进行加工的鸭翅部分进行抛异常处理  
            }

            public void ProduceDuckWings()
            {
                Console.WriteLine("Nanjing Factory is producing Duck Wing.");
                // 这里可以实例化 DuckWing 并进行生产操作  
            }
        }
    public class ChangshaFactory : IProductionFactory
    {
        public void ProduceDuckNecks()
        {
            Console.WriteLine("Changsha Factory is producing Duck Neck.");
            // 这里可以实例化 DuckNeck 并进行生产操作  
        }

        public void ProduceDuckWings()
        {
            throw new NotSupportedException("Changsha Factory does not produce Duck Wing.");
            //对不能生产的鸭翅部分进行抛异常处理  
        }
    }
    public delegate void ProductionDelegate();

    internal class Program
    {

        static void Main(string[] args)
        {

            try
            {
                // 实例化工厂并测试生产    
                IProductionFactory wuhanFactory = new WuhanFactory();
                wuhanFactory.ProduceDuckNecks();
                wuhanFactory.ProduceDuckWings();

                IProductionFactory nanjingFactory = new NanjingFactory();
                nanjingFactory.ProduceDuckWings();
                try
                {
                    nanjingFactory.ProduceDuckNecks(); // 注意：尝试生产鸭脖将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Nanjing Factory does not produce Duck Neck: " + ex.Message);
                }

                IProductionFactory changshaFactory = new ChangshaFactory();
                changshaFactory.ProduceDuckNecks();
                try
                {
                    changshaFactory.ProduceDuckWings(); // 注意：尝试生产鸭翅将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Changsha Factory does not produce Duck Wing: " + ex.Message);
                }

                // 使用委托来封装生产动作    
                ProductionDelegate produceDuckNecksDelegate = new ProductionDelegate(wuhanFactory.ProduceDuckNecks);
                produceDuckNecksDelegate.Invoke();

                ProductionDelegate produceDuckWingsDelegate = new ProductionDelegate(nanjingFactory.ProduceDuckWings);
                produceDuckWingsDelegate.Invoke();
            }
            catch (Exception ex)
            {
                // 捕获其他未处理的异常  
                Console.WriteLine("An unhandled exception occurred: " + ex.Message);
            }

            Console.ReadLine();
        }

    }
    }

逗雪人

关注

8
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Windows程序设计作业周黑鸭工厂

接口是一种定义一组方法的契约，但它不包含这些方法的实现。一个类可以实现一个或多个接口，从而承诺它将提供这些接口中定义的方法的具体实现。不能实例化：接口本身不能创建对象，它只是一个规范或契约。包含方法签名：接口可以包含方法、属性、事件和索引器的签名，但不包含实现。隐式实现：当一个类实现一个接口时，它必须提供接口中所有方法的实现。多态性：通过接口，可以实现多态性，即使用接口类型的变量来引用实现了该接口的任何类的对象。定义接口 IProductionFactory，分别是生产鸭脖和鸭翅的方法。
复制链接

扫一扫