Shulou(Shulou.com)06/03 Report--

This article focuses on "how to understand the abstract factory pattern of design patterns that take classes as parameters". Interested friends may wish to take a look at it. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to understand the abstract factory pattern of a design pattern that takes classes as parameters.

This pattern is called abstract factory pattern, and you may be familiar with the factory pattern, which encapsulates the instance creation logic in the factory pattern. The main purpose is to integrate the creation process of some complex classes together through parameter control, so that users can easily obtain instances.

Abstract factory

The abstract factory pattern is similar to the factory pattern, except that it is more abstract. When creating an instance, it is not controlled by parameters, but is passed in directly to the class you want to create. In fact, this is also a feature of Python, everything is an object, everything can be passed parameters, the class itself is also an object, the class can also pass parameters. So we can pass a class directly to the factory, which creates an instance through the class.

Let's briefly demonstrate with the code:

Class AbstractFactory: def _ init__ (self, cls): self.cls = cls def build (self, * args, * * kw): return self.cls (* args, * * kw)

This code can be understood by everyone, but it can't be completely called an abstract factory, because it doesn't reflect abstraction. The abstraction here mainly treats the factory as a higher-level abstract class, which is a bit like the reverse use of the abstract class.

We usually use abstract classes like this:

Import abc class AbstractClass: def _ _ init__ (self): pass @ abc.abstractmethod def run (self, * args, * * kw): pass

Its derived class then implements the abstract methods defined in the abstract class, which is in reverse order. The logic in the parent class is also fixed, but it is implemented by calling the incoming subclass instance when it is executed.

For better illustration, let's look at an example:

Class PetCollection (object): def _ _ init__ (self Animal): self.pet_generator = animal self.pet = self.pet_generator () def speak (self): self.pet.speak () def show_pet (self): pet = self.pet print ('Pet\' s name is {} '.format (pet)) print (' It says: {}! '.format (pet.speak ()) class Dog (object): def speak (self): return 'woof' def _ _ str__ (self): return' dog' class Cat (object): def speak (self): return 'meow' def _ str__ (self): return' cat' if _ name__ ='_ main__': pet = PetCollection (Dog) pet.show_pet ()

In this example, Dog and Cat are subclasses and PetCollection is the parent class. We can see that the speak method is also implemented in the parent class, but it invokes the speak implementation of the subclass. In other words, any subclass that has a speak class can be used to create PetCollection, which is equivalent to an abstract general class, so that we can use it to integrate a lot of logic and simplify operations.

When I first looked at this design pattern, I thought it was ordinary, just using the class as a parameter. But then I read it again and got a new understanding. Isn't this also the reverse use of abstract classes? In fact, the core of the code is only logic, and the so-called design pattern is just the experience summed up by our predecessors. What is really valuable is not how the code in this pattern is written, but the core logic, which is integrated, and it is not difficult to design our own patterns in the future.

At this point, I believe you have a deeper understanding of "how to understand the abstract factory pattern of taking classes as parameters". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.