David Landup

Hiram Kamau

In this detailed and extensive guide to the filter() method in Java 8 - you'll understand how the method works, as well as several use-cases and how to get the best performance out of large datasets.

Java 8 Streams: Definitive Guide to the filter() Method

<h2 id="introduction">Introduction</h2>
Design patterns help make code understandable, scalable, and reusable. There are different categories of design patterns, depending on the problems being addressed. When code is modularized, it's easier to add newer features without making drastic changes to the project.
The Abstract Factory Design Pattern is a creational pattern that provides a framework to create interfaces of closely related objects without specifying their classes - hence the term &quot;abstract&quot;.
An abstract class is partially implemented and defines the requirements that its child classes should have and some generic child behavior as well as what functions they should have. Concrete classes extend abstract classes and provide the unimplemented functionality, while inheriting the common functionalities.
<h3 id="abstractclassesinpython">Abstract Classes in Python</h3>
<blockquote>
For instance, all <code>Animal</code>s have an <code>eat()</code> function, commonly implemented between all animals, but each have unique <code>speak()</code> functions so the abstract <code>Animal</code> class leaves that up to the children.
</blockquote>
In Python, every abstract class is derived from the <code>ABC</code> class of the <code>abc</code> module. The abstract method is declared inside the abstract class but not implemented, and all implemented methods are passed down to concrete classes.
In the following example, notice that the <code>AbstractClass</code> definition contains an <code>@abstractmethod</code> decorator. By decorating a function with it, we define that all child classes must have an implementation of the <code>func()</code> method, as there is no default, common implementation:
<pre><code class="hljs">from abc import ABC, abstractmethod

class AbstractClass(ABC):
 @abstractmethod
 def func():
 pass
</code></pre>
The partial implementation of the parent abstract factory class is fulfilled by its children/concrete class. Each child class will contain a <code>func()</code> method to fulfill the abstract class' requirements.
Building from our previous example, we can create a child class like this:
<pre><code class="hljs">from abc import ABC, abstractmethod

class AbstractClass(ABC):
 @abstractmethod
 def func(self):
 pass

class ChildClass(AbstractClass):
 def func(self):
 out = &quot;This is an output&quot;
 return out

obj = ChildClass()
print(obj.func())
</code></pre>
<h2 id="abstractfactorydesignpatterninpython">Abstract Factory Design Pattern in Python</h2>
Coming back to the definition of the Abstract Factory Pattern:
<blockquote>
Through the Abstract Factory Pattern, we define interfaces to create families of related objects without specifying their concrete classes.
</blockquote>
Therefore, the Abstract Factory Pattern delegates the creation of objects to another class. This pattern is best suited when one wishes to create multiple categories of an object by abstracting its implementation.
You may be familiar with the concept factories - these are objects that create other objects. The Abstract Factory Pattern is primarily concerned with the interface for factory objects.
What's a family of objects?
<blockquote>
A table can be round, square or oval. In a similar sense, a common class such as an <code>Employee</code> might branch out to several more concrete classes.
</blockquote>
Here's a visual representation of the Abstract Factory Pattern:
<img src="https://stackabuse.s3.amazonaws.com/media/abstract-factory-design-pattern-in-python-01.jpeg" alt="Visual Representation of the Abstract Factory Pattern in Python">
Assume that you are designing a family of two products (a browser and a messenger).
<ul>
<li>
Abstract Products: Two abstract classes are created, one for the browser and another for the messenger. These classes contain abstract methods that are mandatory for the construction of the products. These abstract classes are referred to as interfaces.
In the example shown above, the Web Browser and Messenger are the abstract products.
</li>
<li>
Concrete Products: Concrete products inherit the abstract methods from the abstract classes i.e. abstract products. Using the interfaces, different families of products can be created.
For example, in the diagram above, three different kinds of web browsers are created for three different sets of users. If there's one thing that all these concrete products have in common, that would be the abstract methods that were defined in the abstract class.
</li>
<li>
Concrete Factories: Concrete Factories create Concrete Products as directed by the Abstract Factories. The concrete factories are only capable of creating those products that are specified in them - a <code>BrowserFactory</code> creates browsers, while a <code>MessengerFactory</code> creates messengers. Alternatively, you can focus on some common features, and say - create a <code>BasicFactory</code> and <code>SecureFactory</code> which create basic or secure web browsers and messenger instances.
In the diagram mentioned above, the Vanilla Products Factory is capable of creating both vanilla concrete products (browser and messenger), while the Secure Products Factory makes safe versions.
</li>
<li>
Abstract Factories: The Abstract factories possess interfaces to create the abstract products i.e. they contain several methods that return abstract products.
In the example, the interfaces of concrete factories are invoked to get the abstract products as a web browser and messenger.
</li>
</ul>
<h2 id="implementation">Implementation</h2>
Acquainted with the terminology, let's try implementing the Abstract Factory Pattern in Python.
First off, we create the abstract products - <code>Browser</code> and <code>Messenger</code> as:
<pre><code class="hljs">from abc import ABC, abstractmethod

class Browser(ABC):
 &quot;&quot;&quot;
 Creates &quot;Abstract Product A&quot;
 &quot;&quot;&quot;

 # Interface - Create Search Toolbar
 @abstractmethod
 def create_search_toolbar(self):
 pass

 # Interface - Create Browser Window
 @abstractmethod
 def create_browser_window(self):
 pass

class Messenger(ABC):
 &quot;&quot;&quot;
 Creates &quot;Abstract Product B&quot;
 &quot;&quot;&quot;

 @abstractmethod
 # Interface - Create Messenger Window
 def create_messenger_window(self):
 pass
</code></pre>
These act as base classes to the following concrete classes i.e. product variants of the abstract products - vanilla and secure:
<pre><code class="hljs">class VanillaBrowser(Browser):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Browser base class are implemented.
 &quot;&quot;&quot;

 # Interface - Create Search Toolbar
 def create_search_toolbar(self):
 print(&quot;Search Toolbar Created&quot;)

 # Interface - Create Browser Window]
 def create_browser_window(self):
 print(&quot;Browser Window Created&quot;)


class VanillaMessenger(Messenger):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Messenger base class are implemented.
 &quot;&quot;&quot;

 # Interface - Create Messenger Window
 def create_messenger_window(self):
 print(&quot;Messenger Window Created&quot;)

class SecureBrowser(Browser):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Browser base class are implemented.
 &quot;&quot;&quot;

 # Abstract Method of the Browser base class
 def create_search_toolbar(self):
 print(&quot;Secure Browser - Search Toolbar Created&quot;)

 # Abstract Method of the Browser base class
 def create_browser_window(self):
 print(&quot;Secure Browser - Browser Window Created&quot;)

 def create_incognito_mode(self):
 print(&quot;Secure Browser - Incognito Mode Created&quot;)


class SecureMessenger(Messenger):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Messenger base class are implemented.
 &quot;&quot;&quot;

 # Abstract Method of the Messenger base class
 def create_messenger_window(self):
 print(&quot;Secure Messenger - Messenger Window Created&quot;)

 def create_privacy_filter(self):
 print(&quot;Secure Messenger - Privacy Filter Created&quot;)

 def disappearing_messages(self):
 print(&quot;Secure Messenger - Disappearing Messages Feature Enabled&quot;)
</code></pre>
You can notice that apart from the abstract methods, there are also extra features added to the concrete products to make them functional in their own context.
We are almost there. Let's now create the abstract factory itself and the corresponding concrete factories as:
<pre><code class="hljs">class AbstractFactory(ABC):
 &quot;&quot;&quot;
 The Abstract Factory
 &quot;&quot;&quot;

 @abstractmethod
 def create_browser(self):
 pass

 @abstractmethod
 def create_messenger(self):
 pass

class VanillaProductsFactory(AbstractFactory):
 &quot;&quot;&quot;
 Type: Concrete Factory
 Implement the operations to create concrete product objects.
 &quot;&quot;&quot;

 def create_browser(self):
 return VanillaBrowser()

 def create_messenger(self):
 return VanillaMessenger()

class SecureProductsFactory(AbstractFactory):
 &quot;&quot;&quot;
 Type: Concrete Factory
 Implement the operations to create concrete product objects.
 &quot;&quot;&quot;

 def create_browser(self):
 return SecureBrowser()

 def create_messenger(self):
 return SecureMessenger()
</code></pre>
In the code above, since the <code>AbstractFactory</code> acts as a base class, the abstract methods are instantiated just as mentioned in the base class.
Let's add a <code>main()</code> method so we an see our example in action:
<pre><code class="hljs">def main():
 for factory in (VanillaProductsFactory(), SecureProductsFactory()):
 product_a = factory.create_browser()
 product_b = factory.create_messenger()
 product_a.create_browser_window()
 product_a.create_search_toolbar()
 product_b.create_messenger_window()

if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
If you'd like to see the entire code file, you can find it in the repo <a href="https://github.com/StackAbuse/abstract-factory-design-pattern-in-python" target="_blank" rel="noopener nofollow noreferrer">on GitHub</a>.
If we execute our code, it returns the following output showing the creation of the secure browser and the secure messenger:
<pre><code class="hljs">$ python3 abstract_factory_code.py
Browser Window Created
Search Toolbar Created
Messenger Window Created
Secure Browser - Browser Window Created
Secure Browser - Search Toolbar Created
Secure Messenger - Messenger Window Created
</code></pre>
<h2 id="proscons">Pros &amp; Cons</h2>
Now that we have implemented the pattern, let's weigh their pros and cons.
Pros:
<ul>
<li>
The main advantage of this pattern is flexibility - the ability to add newer features and functions to the existing products or perhaps even add newer concrete products to the concrete factories. This can be done without sabotaging the whole code.
</li>
<li>
There is minimal direct interaction between the client and the concrete products. There is also flexibility in organizing and compacting the code.
</li>
</ul>
Cons
<ul>
<li>The major drawback of this pattern is the readability and maintainability of the code. Although it provides a flexible way to add new futures, adding a new component will require adding to the concrete classes, modifying the interfaces, etc. The cascading effects of modification take development time.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Abstract Factory Pattern can be used very effectively for closely related families of different products unlike the Factory Pattern, which can be used only for a single type of product.
<blockquote>
If you are interested in learning more about it, read our guide to the <a href="https://stackabuse.com/the-factory-method-design-pattern-in-python/" target="_blank">Factory Pattern in Python</a>.
</blockquote>
The Abstract Factory Pattern solves a major crisis for the need to write clean code. We have covered the basics of this pattern and also understood the implementation using an example.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

The Abstract Factory Design Pattern is a creational pattern that provides a framework to create interfaces of closely related objects without specifying their classes.

Abstract Factory Design Pattern in Python

Naazneen Jatu

In this guide, we will create a REST API in Python with Django, using the Django REST Framework to create a shopping cart application.

Creating a REST API with Django REST Framework

Scott Robinson

Mila Lukic

Jovana Ninkovic

Graphs in Python: Dijkstra's Algorithm

Bilal Hamada

In this guide, we'll take a look at the np.arange() function, how it works, what arguments you can pass and compare it to np.linspace() as well as the built-in range() function.

Guide to NumPy's arange() Function

In this guide, we'll jump into detail of how Stream collection into Lists works and how you can use pre-defined Collectors and define your own to convert a stream into a list in Java 8.

Guide to Java 8 Collectors: Definitive Guide to toList()

Mehreen Saeed

In this guide, we'll be taking a look at the theory and implementation behind Random Projections in Python - Gaussian and Sparse Random Projections, as well as a practical hands-on tutorial using a real-life dataset.

Random Projection: Theory and Implementation in Python with Scikit-Learn

Dijkstra's Algorithm vs A* Algorithm

In this guide, we'll cover Self-Organizing Maps in detail, as well as implement a SOM in Python with Numpy and experiment with the hyperparameters to get to know how they affect the model.