进阶主题 (Advanced Topic)

Object-Oriented Programming has ruled the programming world for years. Some programming languages (such as Java) were designed with the native support to what OOP had principled, and some older ones (such as C++) were changed in such a way to add support for OOP lovers. Although during the years there have been new approaches, OOP is still one of the best approaches to use for almost any kind of software project with differnet size and different team skills. Despite all these popularity, this article is not about OOP, it is about walking through together to learn how we can implement Polymorphism using Swift Protocols as well as the traditional OOP approach.

面向对象编程已经统治了编程世界多年。 设计某些编程语言(例如Java)时，要获得对OOP原则性的本机支持，而对某些较旧的语言(例如C ++)进行了更改，以增加对OOP爱好者的支持。 尽管多年来已经有了新的方法，但是OOP仍然是几乎任何一种具有不同网络规模和不同团队技能的软件项目所使用的最佳方法之一。 尽管有如此之多的人气，但本文并不是关于OOP的，而是要逐步学习如何使用Swift协议以及传统的OOP方法来实现多态 。

什么是多态 (What is Polymorphism)

According to Wikipedia

根据维基百科

polymorphism is about provisioning a single interface to entities of different types.

多态性 是关于为不同类型的实体提供单个接口 。

Although it is usually underestimated, it is one of the most powerful concepts in software engineering that lets you define different behaviors for different objects while you are still using a shared interface among them. Don’t worry if it is still vague to you, let’s take a quick recap of how it works.

尽管它通常被低估，但它是软件工程中最强大的概念之一，可让您在仍使用对象之间的共享接口的同时为不同的对象定义不同的行为。 不用担心它是否对您仍然很模糊，让我们快速回顾一下它的工作原理。

如何使用多态 (How to use Polymorphism)

Imagine we are asked to develop a simple zoo application that could contain different types of animals, but for simplicity, let’s just imagine only 3 animals: Lion, Snake, and Eagle. For simplicity, we are asked just to focus on a single behavior for these types, moving

假设我们被要求开发一个简单的动物园应用程序，其中可能包含不同类型的动物，但为简单起见，我们仅假设仅3种动物：狮子，蛇和鹰。 为简单起见，我们被要求只专注于这些类型的单一行为， 移动

The first approach that comes to our mind is to define 3 objects as Lion, Snake, Eagle, and then, define different properties and behaviors for them. Although it doesn’t seem to be a bad design in the first place, we would face issues if we are asked to add more animals with the same categories, such as Pelican or Tiger. What we see is that we are gradually repeating the same behavior for all new animals.

我们想到的第一种方法是将3个对象定义为Lion，Snake，Eagle，然后为它们定义不同的属性和行为。 尽管起初它似乎并不是一个糟糕的设计，但是如果要求我们添加更多具有相同类别的动物，例如鹈鹕或老虎，我们将面临问题。 我们看到的是，我们正在对所有新动物逐渐重复相同的行为。

This is an example where we can gain polymorphism to make a better design.

这是一个示例，我们可以获取多态性以进行更好的设计。

面向对象的方式 (OOP Way)

In OOP, polymorphism is implemented by another OOP principle, Inheritance. All we have to do is to define all objects as the parent type, and initiate them with the child object. Then, calling the parent function will perform the child’s overridden one. Magic!

在OOP中，多态性是通过另一个OOP原则Inheritance实现的 。 我们要做的就是将所有对象定义为父类型，并使用子对象启动它们。 然后，调用父函数将执行子函数的重写函数。 魔法！

通讯协定 (Protocols)

With the same example in mind, let’s see how can we solve it using Protocols in Swift. Protocols are one of the most powerful Swift concepts making the programming even easier than before. Here, we would learn how they can be useful for the implementation of polymorphism, a Polymorphism without any Inheritances.

考虑到相同的示例，让我们看看如何使用Swift中的Protocols解决它。 协议是最强大的Swift概念之一，使编程比以前更加容易。 在这里，我们将学习它们如何对实现多态性(没有任何继承的多态性)有用。

To solve the design problem in our example, we first need to define proper Protocols. This is probably the most important step in designing your architecture, to decide what you want to design. In our example, we can think about different categories as different protocols.

为了解决示例中的设计问题，我们首先需要定义适当的协议。 这可能是设计体系结构，决定要设计的对象中最重要的步骤 。 在我们的示例中，我们可以将不同的类别视为不同的协议。

再一步 (One more step)

We have a proper polymorphism implemented without any inheritance using just protocols. Now, let’s see how we can go further and make it even better.

我们仅使用协议就实现了适当的多态性，而没有任何继承。 现在，让我们看看如何进一步发展并使其变得更好。

POP还是OOP？ (POP or OOP?)

So far we have seen how to implement polymorphism with Object-Oriented and Protocol-Oriented approaches. But which one would you prefer? What are the advantages of each one?

到目前为止，我们已经看到了如何使用面向对象和面向协议的方法来实现多态。 但是您想要哪一个呢？ 每个人都有哪些优势？

While polymorphism is an OOP principle, I’d personally prefer to use Protocols to implement it, especially, for large scale projects. Let’s take a quick look at a more complex level of our current zoo project.

尽管多态性是OOP原则，但我个人更喜欢使用协议来实现它，尤其是对于大型项目。 让我们快速看一下当前动物园项目的更复杂层次。

Imagine that now we are asked to add specific behaviors to different animal categories that have nothing in common with any other categories. For example, we now know that Big Cats are naturally attackers, so we want to have a record of their aggressive reactions. This behavior is shared between all Big Cats, but it is not true for other animals such as Birds.

想象一下，现在我们被要求向与其他类别没有共同点的不同动物类别添加特定的行为。 例如，我们现在知道大猫是天生的攻击者，因此我们想要记录它们的攻击性React。 所有大型猫科动物都有这种行为，但其他动物(例如鸟类)却并非如此。

Now we have to decide which approach we would rather to use.

现在，我们必须决定要使用哪种方法。

面向对象 (OOP)

With OOP, we need to come up with a layered inheritance design that reflects our real-world problem. In this case, we need to add one more parent objects that contains the functions we are asked for. Since it is not possible to have multiple inheritances in most modern OOP languages, the middle parent also has to inherit from another parent. Since this could be kind of confusing now, let’s check the code.

使用OOP，我们需要提出一个分层的继承设计，以反映我们的实际问题。 在这种情况下，我们需要再添加一个包含我们要求的功能的父对象。 由于在大多数现代OOP语言中不可能有多个继承，因此中间父级也必须从另一个父级继承。 由于这现在可​​能会造成混淆，因此让我们检查一下代码。

流行音乐 (POP)

With Protocols, you don’t need to have any inheritance (although you can have inheritance for your Protocols). Any objects in Swift can conform to multiple Protocols at the same time, which means it can hold different behaviors at the same time without any additional inheritance. Check the code below to get the idea.

使用协议，您不需要任何继承(尽管您可以对协议进行继承)。 Swift中的任何对象都可以同时符合多个协议，这意味着它可以同时具有不同的行为，而无需任何其他继承。 查看下面的代码以了解主意。

结论 (Conclusion)

As you have seen so far, polymorphism is a very powerful concept that lets you design complex relations between objects in a scalable manner. As both OOP and POP offers their own advantages, it is finally up to you, as a software engineer, to choose horizontal growth (POP) or vertical growth (OOP). Personally, I’d rather POP as it is applicable to Swift structs types which are commonly advised over using classes due to performance improvements.

到目前为止，您已经看到，多态是一个非常强大的概念，可让您以可扩展的方式设计对象之间的复杂关系。 由于OOP和POP都有各自的优势，因此最终，作为软件工程师，您需要选择水平增长(POP)或垂直增长(OOP)。 就个人而言，我更喜欢POP，因为它适用于Swift结构结构类型，由于性能改进，通常建议在使用类时使用POP结构。

There are also many articles available to help you to combine different features to gain even better design decisions, where you will end up with a code that is easier to read, maintain, and scale.

也有许多文章可帮助您组合不同的功能以获得更好的设计决策，最终您将获得一个易于阅读，维护和扩展的代码。