Design Patterns in Go: Encapsulation, Polymorphism, Composition, and Abstraction

Lesson Introduction

Hello! Today, we'll delve into design patterns in Go with practical exercises that apply these fundamental principles to solve problems. Mastering these concepts will enhance your coding skills and understanding. Our focus today is to strengthen your understanding of how and when to apply specific Go design concepts using structs, interfaces, and composition . These include Encapsulation, Abstraction, Polymorphism, and Composition through Go’s distinct approach. We'll explore four real-life scenarios, examining which pattern is applicable and why, using Go’s unique features. Let's dive in!

Real-life Example 1: Database Management System (Encapsulation)

In Go, Encapsulation is achieved using structs and package-level visibility. We use unexported fields and methods to control data access and promote data integrity. Gopackage main import ( "fmt" ) type Employees struct { employees map[int]string // unexported field } func NewEmployees() *Employees { return &Employees{employees: make(map[int]string)} } func (e *Employees) AddEmployee(id int, name string) { // method to operate on unexported data e.employees[id] = name } func (e *Employees) UpdateEmployee(id int, newName string) { // method to operate on unexported data if _, exists := e.employees[id]; exists { e.employees[id] = newName } } func (e *Employees) GetEmployee(id int) string { // method to get unexported data if name, exists := e.employees[id]; exists { return name } return "" } func main() { employees := NewEmployees() employees.AddEmployee(1, "John") employees.AddEmployee(2, "Mark") employees.UpdateEmployee(2, "Jake") fmt.Println(employees.GetEmployee(1)) // Outputs: John fmt.Println(employees.GetEmployee(2)) // Outputs: Jake }package main import ( "fmt" ) type Employees struct { employees map[int]string // unexported field } func NewEmployees() *Employees { return &Employees{employees: make(map[int]string)} } func (e *Employees) AddEmployee(id int, name string) { // method to operate on unexported data e.employees[id] = name } func (e *Employees) UpdateEmployee(id int, newName string) { // method to operate on unexported data if _, exists := e.employees[id]; exists { e.employees[id] = newName } } func (e *Employees) GetEmployee(id int) string { // method to get unexported data if name, exists := e.employees[id]; exists { return name } return "" } func main() { employees := NewEmployees() employees.AddEmployee(1, "John") employees.AddEmployee(2, "Mark") employees.UpdateEmployee(2, "Jake") fmt.Println(employees.GetEmployee(1)) // Outputs: John fmt.Println(employees.GetEmployee(2)) // Outputs: Jake } Here, Encapsulation restricts direct access to the employee data, using methods to interact with the stored information securely.

Real-life Example 2: Graphic User Interface (GUI) Development (Polymorphism)

In Go, Polymorphism is achieved through interfaces, allowing different structs to define specific behaviors for the same method. Go package main import ("fmt") type Clickable interface {Click()} type Button struct{} func (b Button) Click() {fmt.Println("Button Clicked!")} type CheckBox struct{} func (c CheckBox) Click() {fmt.Println("CheckBox Clicked!")} func main() {var b Clickable = Button{} var c Clickable = CheckBox{} // Click Controls b.Click() // Outputs: Button Clicked! c.Click() // Outputs: CheckBox Clicked!} package main import ("fmt") type Clickable interface {Click()} type Button struct{} func (b Button) Click() {fmt.Println("Button Clicked!")} type CheckBox struct{} func (c CheckBox) Click() {fmt.Println("CheckBox Clicked!")} func main() {var b Clickable = Button{} var c Clickable = CheckBox{} // Click Controls b.Click() // Outputs: Button Clicked! c.Click() // Outputs: CheckBox Clicked!} Interfaces in Go allow Polymorphism, enabling different structs to share behavior provided by the Clickable interface.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

package main

import (
    "fmt"
)

type Employees struct {
    employees map[int]string // unexported field
}

func NewEmployees() *Employees {
    return &Employees{employees: make(map[int]string)}
}

func (e *Employees) AddEmployee(id int, name string) { // method to operate on unexported data
    e.employees[id] = name
}

func (e *Employees) UpdateEmployee(id int, newName string) { // method to operate on unexported data
    if _, exists := e.employees[id]; exists {
        e.employees[id] = newName
    }
}

func (e *Employees) GetEmployee(id int) string { // method to get unexported data
    if name, exists := e.employees[id]; exists {
        return name
    }
    return ""
}

func main() {
    employees := NewEmployees()
    employees.AddEmployee(1, "John")
    employees.AddEmployee(2, "Mark")

    employees.UpdateEmployee(2, "Jake")

    fmt.Println(employees.GetEmployee(1)) // Outputs: John
    fmt.Println(employees.GetEmployee(2)) // Outputs: Jake
}

package main

import (
    "fmt"
)

type Clickable interface {
    Click()
}

type Button struct{}

func (b Button) Click() {
    fmt.Println("Button Clicked!")
}

type CheckBox struct{}

func (c CheckBox) Click() {
    fmt.Println("CheckBox Clicked!")
}

func main() {
    var b Clickable = Button{}
    var c Clickable = CheckBox{}

    // Click Controls
    b.Click() // Outputs: Button Clicked!
    c.Click() // Outputs: CheckBox Clicked!
}

package main

import (
    "fmt"
    "strings"
)

type Header struct {
    Text string
}

func (h Header) Render() string {
    return "<h1>" + h.Text + "</h1>\n"
}

type Paragraph struct {
    Text string
}

func (p Paragraph) Render() string {
    return "<p>" + p.Text + "</p>\n"
}

type ListElement struct {
    Items []string
}

func (l ListElement) Render() string {
    var sb strings.Builder
    sb.WriteString("<ul>")
    for _, item := range l.Items {
        sb.WriteString("<li>" + item + "</li>")
    }
    sb.WriteString("</ul>\n")
    return sb.String()
}

type WebPage struct {
    Title    string
    Elements []interface{ Render() string }
}

func (wp *WebPage) AddElement(e interface{ Render() string }) {
    wp.Elements = append(wp.Elements, e)
}

func (wp WebPage) Display() string {
    var sb strings.Builder
    sb.WriteString("<html><head><title>")
    sb.WriteString(wp.Title)
    sb.WriteString("</title></head><body>\n")
    for _, e := range wp.Elements {
        sb.WriteString(e.Render())
    }
    sb.WriteString("</body></html>\n")
    return sb.String()
}

func main() {
    page := WebPage{Title: "My Web Page"}
    page.AddElement(Header{Text: "Welcome to My Web Page"})
    page.AddElement(Paragraph{Text: "This is a paragraph of text on the web page."})

    items := []string{"Item 1", "Item 2", "Item 3"}
    page.AddElement(ListElement{Items: items})

    fmt.Println(page.Display())
    /*
        Outputs:
        <html><head><title>My Web Page</title></head><body>
        <h1>Welcome to My Web Page</h1>
        <p>This is a paragraph of text on the web page.</p>
        <ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>
        </body></html>
    */
}

package main

import (
    "fmt"
    "strings"
)

type Header struct {
    Text string
}

func (h Header) Render() string {
    return "<h1>" + h.Text + "</h1>\n"
}

type Paragraph struct {
    Text string
}

func (p Paragraph) Render() string {
    return "<p>" + p.Text + "</p>\n"
}

type ListElement struct {
    Items []string
}

func (l ListElement) Render() string {
    var sb strings.Builder
    sb.WriteString("<ul>")
    for _, item := range l.Items {
        sb.WriteString("<li>" + item + "</li>")
    }
    sb.WriteString("</ul>\n")
    return sb.String()
}

type WebPage struct {
    Title    string
    Elements []interface{ Render() string }
}

func (wp *WebPage) AddElement(e interface{ Render() string }) {
    wp.Elements = append(wp.Elements, e)
}

func (wp WebPage) Display() string {
    var sb strings.Builder
    sb.WriteString("<html><head><title>")
    sb.WriteString(wp.Title)
    sb.WriteString("</title></head><body>\n")
    for _, e := range wp.Elements {
        sb.WriteString(e.Render())
    }
    sb.WriteString("</body></html>\n")
    return sb.String()
}

func main() {
    page := WebPage{Title: "My Web Page"}
    page.AddElement(Header{Text: "Welcome to My Web Page"})
    page.AddElement(Paragraph{Text: "This is a paragraph of text on the web page."})

    items := []string{"Item 1", "Item 2", "Item 3"}
    page.AddElement(ListElement{Items: items})

    fmt.Println(page.Display())
    /*
        Outputs:
        <html><head><title>My Web Page</title></head><body>
        <h1>Welcome to My Web Page</h1>
        <p>This is a paragraph of text on the web page.</p>
        <ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>
        </body></html>
    */
}

package main

import (
    "fmt"
)

type Vehicle interface {
    StartEngine()
    StopEngine()
    Drive()
}

type Car struct {
    Color       string
    EngineType  string
    EngineRunning bool
}

func (c *Car) StartEngine() {
    c.EngineRunning = true
    fmt.Println("Car engine started!")
}

func (c *Car) StopEngine() {
    c.EngineRunning = false
    fmt.Println("Car engine stopped!")
}

func (c *Car) Drive() {
    if c.EngineRunning {
        fmt.Printf("%s car is driving on the %s engine type!\n", c.Color, c.EngineType)
    } else {
        fmt.Println("Start the engine first!")
    }
}

func main() {
    car := &Car{Color: "red", EngineType: "gasoline"}
    car.StartEngine()
    car.Drive()
    /*
        Output:
        Car engine started!
        red car is driving on the gasoline engine type!
    */
}

package main

import (
    "fmt"
)

type Vehicle interface {
    StartEngine()
    StopEngine()
    Drive()
}

type Car struct {
    Color       string
    EngineType  string
    EngineRunning bool
}

func (c *Car) StartEngine() {
    c.EngineRunning = true
    fmt.Println("Car engine started!")
}

func (c *Car) StopEngine() {
    c.EngineRunning = false
    fmt.Println("Car engine stopped!")
}

func (c *Car) Drive() {
    if c.EngineRunning {
        fmt.Printf("%s car is driving on the %s engine type!\n", c.Color, c.EngineType)
    } else {
        fmt.Println("Start the engine first!")
    }
}

func main() {
    car := &Car{Color: "red", EngineType: "gasoline"}
    car.StartEngine()
    car.Drive()
    /*
        Output:
        Car engine started!
        red car is driving on the gasoline engine type!
    */
}

package main

import (
    "fmt"
    "strings"
)

type Header struct {
    Text string
}

func (h Header) Render() string {
    return "<h1>" + h.Text + "</h1>\n"
}

type Paragraph struct {
    Text string
}

func (p Paragraph) Render() string {
    return "<p>" + p.Text + "</p>\n"
}

type ListElement struct {
    Items []string
}

func (l ListElement) Render() string {
    var sb strings.Builder
    sb.WriteString("<ul>")
    for _, item := range l.Items {
        sb.WriteString("<li>" + item + "</li>")
    }
    sb.WriteString("</ul>\n")
    return sb.String()
}

type WebPage struct {
    Title    string
    Elements []interface{ Render() string }
}

func (wp *WebPage) AddElement(e interface{ Render() string }) {
    wp.Elements = append(wp.Elements, e)
}

func (wp WebPage) Display() string {
    var sb strings.Builder
    sb.WriteString("<html><head><title>")
    sb.WriteString(wp.Title)
    sb.WriteString("</title></head><body>\n")
    for _, e := range wp.Elements {
        sb.WriteString(e.Render())
    }
    sb.WriteString("</body></html>\n")
    return sb.String()
}

func main() {
    page := WebPage{Title: "My Web Page"}
    page.AddElement(Header{Text: "Welcome to My Web Page"})
    page.AddElement(Paragraph{Text: "This is a paragraph of text on the web page."})

    items := []string{"Item 1", "Item 2", "Item 3"}
    page.AddElement(ListElement{Items: items})

    fmt.Println(page.Display())
    /*
        Outputs:
        <html><head><title>My Web Page</title></head><body>
        <h1>Welcome to My Web Page</h1>
        <p>This is a paragraph of text on the web page.</p>
        <ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>
        </body></html>
    */
}

package main

import (
    "fmt"
)

type Vehicle interface {
    StartEngine()
    StopEngine()
    Drive()
}

type Car struct {
    Color       string
    EngineType  string
    EngineRunning bool
}

func (c *Car) StartEngine() {
    c.EngineRunning = true
    fmt.Println("Car engine started!")
}

func (c *Car) StopEngine() {
    c.EngineRunning = false
    fmt.Println("Car engine stopped!")
}

func (c *Car) Drive() {
    if c.EngineRunning {
        fmt.Printf("%s car is driving on the %s engine type!\n", c.Color, c.EngineType)
    } else {
        fmt.Println("Start the engine first!")
    }
}

func main() {
    car := &Car{Color: "red", EngineType: "gasoline"}
    car.StartEngine()
    car.Drive()
    /*
        Output:
        Car engine started!
        red car is driving on the gasoline engine type!
    */
}