7 Object Oriented Programming in Go

7 Object-Oriented Programming in Go

While Go does not have classes like traditional object-oriented languages such as Java or Python, it does support a pragmatic approach to object-oriented programming (OOP) using structs and methods. In this post, we’ll explore how to implement OOP concepts such as encapsulation, inheritance, and polymorphism in Go.

Structs and Methods

In Go, structs are used to define custom data types that can have fields and methods associated with them. Methods in Go are functions that have a receiver argument, which is typically a struct type. This allows us to associate behavior with data. Here’s an example:

package main

import "fmt"

// Define a struct type
type Circle struct {
    radius float64
}

// Method to calculate the area of a circle
func (c Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

func main() {
    // Create an instance of Circle struct
    circle := Circle{radius: 5}

    // Call the Area method
    area := circle.Area()

    fmt.Println("Area of the circle:", area)
}

In this example, we define a struct type Circle with a radius field and a method Area associated with it. The Area method calculates the area of the circle using its radius.

Encapsulation

Encapsulation is the concept of hiding the internal state of an object and restricting access to it from outside the object’s scope. In Go, encapsulation is achieved by using lowercase and uppercase identifiers to control visibility. Fields and methods starting with a lowercase letter are only accessible within the same package, while those starting with an uppercase letter are accessible from outside the package. Here’s an example:

package main

import "fmt"

// Define a struct type
type Person struct {
    firstName string
    lastName  string
}

// Method to get the full name of the person
func (p Person) FullName() string {
    return p.firstName + " " + p.lastName
}

func main() {
    // Create an instance of Person struct
    person := Person{
        firstName: "John",
        lastName:  "Doe",
    }

    // Call the FullName method
    fullName := person.FullName()

    fmt.Println("Full name:", fullName)
}

In this example, the firstName and lastName fields of the Person struct are lowercase, making them only accessible within the main package. The FullName method, however, starts with an uppercase letter, making it accessible from outside the package.

Composition

Composition is a mechanism in OOP where a class or struct can contain objects of other classes or structs as fields. In Go, composition is achieved by embedding one struct type into another. Here’s an example:

package main

import "fmt"

// Define struct types
type Address struct {
    city    string
    country string
}

type Person struct {
    name    string
    address Address
}

func main() {
    // Create instances of Address and Person structs
    address := Address{
        city:    "New York",
        country: "USA",
    }

    person := Person{
        name:    "John",
        address: address,
    }

    fmt.Println("Person:", person)
}

In this example, the Person struct contains an Address struct as one of its fields, demonstrating composition in Go.

Conclusion

Although Go does not have built-in support for classes and inheritance like some other languages, it provides powerful mechanisms such as structs and methods to implement object-oriented programming concepts effectively. By leveraging these features, you can write clean, maintainable, and efficient code in Go while following object-oriented principles.