C#探索之路基础夯实篇(2)：接口Interface的概念、实现、应用范围

不知道大家在学习的过程中，有没有反复的接触到接口这个概念。

但如果在没有经常使用接口的情况下， 我相信大家可能在接口的设计和使用上有点陌生和茫然。

特别容易出现，我知道接口是什么，也知道它的作用是什么，但是真让你写功能的时候去使用上接口时，往往就不知所措了。

1 概念

在C#中，接口（Interface）是一种抽象类型，它定义了一组方法、属性、索引器和事件的契约，但并不提供这些成员的具体实现。接口定义了对象应该具有的行为，但不指定每个行为的具体实现方式。

接口在C#中有以下几个关键特点和用途：

1. 抽象行为定义: 接口定义了类应该具有的行为，但不关心具体的实现细节。通过接口，你可以定义一组方法、属性等，但是具体的实现由实现该接口的类来完成。

2. 实现多态性: 接口提供了一种多态的实现方式。**多个类可以实现同一个接口，从而在不同的上下文中使用这些类，而不需要关心它们的具体类型。**这种多态性的使用可以增加代码的灵活性和可维护性。

3. 解耦合: 接口有助于减少类之间的耦合度。当类通过接口进行通信时，它们只需要知道接口定义的契约，而不需要知道具体的实现细节。这样可以使得系统更易于扩展和修改。

4. 实现约束: 接口可以用来约束类的行为。通过实现特定的接口，可以确保类具有某些特定的行为或功能，这有助于提高代码的可靠性和可预测性。

5. 模块化设计: 使用接口可以将系统划分为模块化的组件，每个组件通过接口定义自己的行为，从而实现更好的代码组织和管理。

举例来说，如果你在一个图形界面应用程序中需要定义各种形状（如矩形、圆形等）的绘制行为，你可以定义一个IShape接口，包含一个Draw方法。然后，不同的形状类可以实现这个接口，并提供自己的Draw方法实现，从而实现各种形状的绘制。

总之，接口是一种非常有用的工具，可以帮助你实现代码的抽象、多态、解耦合和模块化，从而提高代码的质量、可维护性和可扩展性。

2 示例代码：

2.1 简单接口的实现

//声明一个简单的接口
interface IAnimal
{
    void Eat();
}

接口本身是一种约束，当这个接口没有约束任何类的时候，声明接口也就没有意义了。

2.2 简单的使用接口

//声明一个简单的接口
interface IAnimal
{
    string Name { get; }
    void Eat();
}

//使用接口去约束类
class Dog : IAnimal
{

    public string Name => GetName();

    public void Eat()
    {
        Console.WriteLine($"{Name}吃东西了");
    }

    public string GetName()
    {
        return "狗";
    }
}


class Program
{
    static void Main(string[] args)
    {

        Dog dog = new Dog();
        Console.WriteLine(dog.Name);
        dog.Eat();
    }
}

2.3 使用接口呈现多态性

// 定义日志记录器接口
public interface ILogger
{
    void Log(string message);
}

// 文件日志记录器实现
public class FileLogger : ILogger
{
    public void Log(string message)
    {
        // 将日志信息写入文件
        Console.WriteLine($"[File] {message}");
    }
}

// 控制台日志记录器实现
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        // 在控制台输出日志信息
        Console.WriteLine($"[Console] {message}");
    }
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        ILogger logger = new FileLogger();
        logger.Log("This is a log message."); // 输出：[File] This is a log message.

        logger = new ConsoleLogger();
        logger.Log("This is another log message."); // 输出：[Console] This is another log message.
    }
}

在这个示例中，接口 ILogger 定义了日志记录器的契约，而 FileLogger 和 ConsoleLogger 分别提供了不同的日志记录方式。通过接口，我们可以轻松地切换不同的日志记录器实现。

2.4 通过接口实现一个数组迭代器

// 定义迭代器接口
public interface IIterator<T>
{
    T Next();
    bool HasNext();
}

// 数组迭代器实现
public class ArrayIterator<T> : IIterator<T>
{
    private T[] _array;
    private int _index = 0;

    public ArrayIterator(T[] array)
    {
        _array = array;
    }

    public T Next()
    {
        return _array[_index++];
    }

    public bool HasNext()
    {
        return _index < _array.Length;
    }
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        IIterator<int> iterator = new ArrayIterator<int>(numbers);

        while (iterator.HasNext())
        {
            Console.WriteLine(iterator.Next());
        }
    }
}

在这个示例中，接口 IIterator<T> 定义了迭代器的契约，而 ArrayIterator<T> 则提供了数组迭代器的实现。

2.5 通过接口来实现松耦合的关系

public interface IOrderProcessor
{
    void ProcessOrder(Order order);
}

// 网上商店订单处理器实现
public class OnlineStoreOrderProcessor : IOrderProcessor
{
    public void ProcessOrder(Order order)
    {
        // 处理网上商店订单
        Console.WriteLine($"处理在线商店订单{order.ProductName}");
    }
}

// 实体商店订单处理器实现
public class PhysicalStoreOrderProcessor : IOrderProcessor
{
    public void ProcessOrder(Order order)
    {
        // 处理实体商店订单
        Console.WriteLine($"处理实体店订单 {order.ProductName}");
    }
}

// 订单类
public class Order
{
    public string ProductName { get; set; }
    // 其他订单相关信息
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        IOrderProcessor onlineStoreProcessor = new OnlineStoreOrderProcessor();
        IOrderProcessor physicalStoreProcessor = new PhysicalStoreOrderProcessor();

        Order onlineOrder = new Order { ProductName = "笔记本电脑" };
        onlineStoreProcessor.ProcessOrder(onlineOrder); // 输出：处理笔记本电脑的在线商店订单

        Order physicalOrder = new Order { ProductName = "书" };
        physicalStoreProcessor.ProcessOrder(physicalOrder); // 输出：处理书籍的实体店订单
    }
}

2.6 使用接口实现可扩展、便利性

public interface IOrderProcessor
{
    void ProcessOrder(Order order);
}

// 支付接口
public interface IPaymentProcessor
{
    void ProcessPayment(Order order);
}

// 网上商店订单处理器实现
public class OnlineStoreOrderProcessor : IOrderProcessor
{
    private readonly IPaymentProcessor _paymentProcessor;//我们在一个订单处理器类中加入了支付接口，即给订单处理器添加支付的功能(接口，不关注实现)

    public OnlineStoreOrderProcessor(IPaymentProcessor paymentProcessor)
    {
        _paymentProcessor = paymentProcessor;
    }

    public void ProcessOrder(Order order)
    {
        // 处理网上商店订单
        Console.WriteLine($"处理在线商店订单 {order.ProductName}");
        _paymentProcessor.ProcessPayment(order);
    }
}

// 网上商店支付处理器实现
public class OnlineStorePaymentProcessor : IPaymentProcessor
{
    public void ProcessPayment(Order order)
    {
        // 处理网上商店支付
        Console.WriteLine($"处理在线商店订单的付款： {order.OrderId}");
    }
}

// 订单类
public class Order
{
    public int OrderId { get; set; }
    public string ProductName { get; set; }
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        //创建了网上商店支付处理器(处理器中中包含支付接口)
        Console.WriteLine("创建了网上商店支付处理器(处理器中中包含支付接口)");
        IPaymentProcessor paymentProcessor = new OnlineStorePaymentProcessor();

        //创建订单处理器(在声明中，创建订单->要求我们传入一个支付接口)
        Console.WriteLine("创建订单处理器(在声明中，创建订单->要求我们传入一个支付接口)");
        IOrderProcessor onlineStoreProcessor = new OnlineStoreOrderProcessor(paymentProcessor);

        //创建一个最简单的订单
        Console.WriteLine("创建一个最简单的订单");
        Order onlineOrder = new Order { OrderId = 123, ProductName = "Laptop" };
        //通过订单处理处理器->处理对应的订单->此时我们不需要传入支付接口，
        //因为支付接口旨在提供给订单处理器，而非订单。而订单处理器中要求我们指定对应的订单是什么
        Console.WriteLine("通过订单处理处理器->处理对应的订单->此时我们不需要传入支付接口，");
        Console.WriteLine("因为支付接口旨在提供给订单处理器，而非订单。而订单处理器中要求我们指定对应的订单是什么");
        onlineStoreProcessor.ProcessOrder(onlineOrder);
        // 输出：
        // 处理笔记本电脑的在线商店订单
        // 处理在线商店订单的付款：123
    }
}

3 使用范围与时机

1、需求要求我们实现多态

2、当前类的关系耦合关系比较严重，要求去实现解耦

3、实现约束

4、模块化的设计、框架过程中的设计

5、实现设计模式（为了提高代码的可读性、可维护性、可扩展性）

4 注意事项

在使用接口时，有一些注意事项需要考虑：

1. 接口设计要合理：接口应该根据需求进行设计，具有清晰的定义和明确的目的。接口设计应该简洁、一致，避免定义过于复杂或冗余的接口。

2. 遵循接口设计原则：遵循接口设计原则，如单一职责原则（一个接口应该只有一个目的）、依赖倒置原则（高层模块不应该依赖于低层模块，两者都应该依赖于抽象）、开闭原则（接口应该是开放的，但是关闭修改）等，可以帮助你设计出更好的接口。

3. 命名规范：接口的命名应该清晰明了，能够准确地描述其所表示的功能或行为。一般来说，接口名称应该以大写字母 “I” 开头，后面跟着描述性的名称。

4. 避免过度使用接口：不要过度使用接口，否则可能会导致代码过于复杂和冗余。只有在需要实现多态性、解耦合等特性时才使用接口，否则可以考虑使用抽象类或其他方式来实现需求。

5. 避免接口膨胀：不要定义过多的接口，否则可能会导致接口膨胀问题。如果接口过于庞大，考虑将其拆分成多个更小的接口，以提高代码的可维护性和可读性。

6. 接口版本管理：在项目中使用接口时，要考虑接口的版本管理。当接口发生变化时，要确保对接口的修改不会影响到已有的实现类，并且要及时通知和更新依赖于该接口的其他模块。

7. 文档和注释：为接口提供清晰的文档和注释，描述接口的用途、约束和使用方式，以便其他开发人员能够正确地使用接口。

8. 避免过度设计：有的时候只是一个很小的功能，并且从需求的角度出发，是一次性的使用时，就没有太大的必要一定要抽象成一个接口出来用于使用。

总的来说，合理设计和使用接口可以提高代码的灵活性、可维护性和可扩展性，但在使用时需要注意上述事项，以避免出现不必要的问题。

公众号：平平无奇代码猴
也可以搜索：Jackiie_wang 公众号，欢迎大家关注！欢迎催更！留言！

作者：ProMer_Wang

链接：https://blog.csdn.net/qq_43801020/article/details/136925776