Clean Code Practices with Polymorphism in Go

Welcome to the next lesson in the Clean Code with Multiple Structures course! This lesson focuses on leveraging Go's interfaces and struct embedding to achieve polymorphism, which enhances code flexibility and dynamic behavior. Polymorphism allows us to design applications that can handle different types of data and operations with a unified approach, promoting a clean and maintainable code structure. Let’s explore how Go uniquely achieves these benefits and how you can use them to improve your code.

Polymorphism in Go allows developers to write flexible and scalable code by utilizing interfaces. Interfaces in Go serve as contracts for behavior, enabling different types to be treated uniformly. Consider a scenario with multiple payment methods like CreditCardPayment, PayPalPayment, and BankTransferPayment. Using Go interfaces, these payment methods can be processed in a consistent manner.

Here's a simple illustration:

package main
import "fmt"

// Payment is the parent interface
type Payment interface {
    Pay()
}

// CreditCardPayment is a child type that implements Payment
type CreditCardPayment struct{}

// Pay method for CreditCardPayment, fulfilling the Payment interface
func (c CreditCardPayment) Pay() {
    fmt.Println("Processing credit card payment.")
}

// PayPalPayment is another child type that implements Payment
type PayPalPayment struct{}

// Pay method for PayPalPayment, fulfilling the Payment interface
func (p PayPalPayment) Pay() {
    fmt.Println("Processing PayPal payment.")
}

With the Payment interface, we can handle these different payment types through a single reference:

// ProcessPayment accepts any Payment type (polymorphism)
func ProcessPayment(payment Payment) {
    payment.Pay() // Calls the Pay method of the specific type
}

func main() {
    var payment Payment

    // CreditCardPayment (child) assigned to Payment (parent)
    payment = CreditCardPayment{}
    ProcessPayment(payment)

    // PayPalPayment (child) assigned to Payment (parent)
    payment = PayPalPayment{}
    ProcessPayment(payment)
}

This example highlights the power of polymorphism in Go: the ability to unify the handling of different types through interfaces, reducing duplication and allowing for easy extensions without altering existing code.