Applying Creational Patterns in a Scala Banking System

Welcome to the final lesson of our "Creational Patterns in Scala" course! 🎉 Good job in making it to the end. So far, you've delved into the world of creational design patterns, mastering concepts like Singleton, Factory Method, Abstract Factory, and Builder. Now, it's time to apply these design patterns to a practical project — a simple banking system. Join us as we navigate through these creational patterns to design and build system components that are not only efficient but also maintainable and scalable. Let's dive into the world of Scala and have some fun creating clean, reusable, and elegant code! 😎

Before we dive into building our banking system, let's quickly recap the key creational design patterns that we encountered in this course:

1. Singleton Pattern: Ensures a class has only one instance and provides a global point of access to it.
2. Factory Method Pattern: Defines an interface for creating an object, but allows subclasses to specify the type of object they wish to instantiate.
3. Abstract Factory Pattern: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
4. Builder Pattern: Separates the construction of a complex object from its representation, allowing the same construction process to create various representations.

In this lesson, we'll implement these patterns to create a logger, accounts, and account factories within our banking system.

Let's see what you'll build in this unit. You will create:

1. Logger with the Singleton Pattern: A logging mechanism that ensures only one instance exists throughout the application using Scala's object.
2. Accounts using the Factory Method Pattern: Different types of accounts (SavingsAccount and CurrentAccount) created via factory methods.
3. Account Factories using the Abstract Factory Pattern: Factories that will instantiate different types of accounts.
4. Code Integration: Comprehensive integration of these patterns into a cohesive system.

Ready? Let's dive in!

Let's begin by creating a logger using the Singleton Pattern. This ensures that there's only one instance of the logger available throughout the application.

// Singleton Pattern for Logger in Bank System
object Logger:
  def log(message: String): Unit =
    println(message)

Recall that in Scala, the object keyword is used to implement the Singleton pattern elegantly. The Logger object above is a singleton, automatically ensuring that only one instance exists. You can use the log method to print messages wherever necessary in the application.