Understanding Golang Object Oriented Programming (OOP) with Examples

Introduction

Object-oriented programming (OOP) is a popular programming paradigm that emphasizes the use of objects and their interactions to design and build applications. Go is not a pure object-oriented language like Java or Python, but it does support many OOP concepts like encapsulation, abstraction, inheritance, and polymorphism. In this article, we will explore how to write object-oriented programs in Go.

Defining a Class

In Go, we define classes as structures. A class is a collection of attributes (fields) and behaviors (methods). Here's an example of a class representing a Person :

type Person struct {
    Name   string
    Age    int
    Gender string
}

This defines a class Person with the three fields Name , Age , and Gender .

Creating an Object

In Go, we create an object by instantiating a structure. We can create an object of class Person like this:

person := Person{Name: "John Doe", Age: 30, Gender: "Male"}

This creates an object person with the values "John Doe" , 30 , and "Male" .

Encapsulation

Encapsulation is the concept of wrapping data and methods inside a single unit. In Go, encapsulation is achieved by using a naming convention for fields and methods: Private fields and methods start with a lowercase letter, while public fields and methods start with an uppercase letter.
Here's an example of a Person class with private fields and public methods:

type Person struct {
    name   string
    age    int
    gender string
}
func (p *Person) SetName(name string) {
    p.name = name
}
func (p *Person) GetName() string {
    return p.name
}

In this example, we've made the fields name , age , and gender private by using lowercase letters. We've also defined two public methods SetName() and GetName() to access and modify the value of the name field.

Abstraction

Abstraction is the process of hiding implementation details while showing only the necessary information to the user. In Go, we can achieve abstraction by using interfaces. An interface specifies a set of methods that a struct must implement to satisfy the interface.
Here's an example:

type Animal interface {
    Speak() string
}
type Dog struct {
    Name string
}
func (d Dog) Speak() string {
    return "Woof!"
}
type Cat struct {
    Name string
}
func (c Cat) Speak() string {
    return "Meow!"
}
func main() {
    animals := []Animal{Dog{Name: "Fido"}, Cat{Name: "Fluffy"}}
    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }
}

In this example, we've defined an interface Animal with a single method Speak() . We've also defined two implementations of this interface: Dog and Cat . We can now create a list of Animal objects and call the Speak() method on each of them to get their respective sounds.

Inheritance

Inheritance is the concept of creating a new class from an existing class. In Go, we achieve inheritance using composition. Composition is the process of combining different structures to create a new one.
Here's an example:

type Animal struct {
    Name   string
    Origin string
}
type Bird struct {
    Animal
    SpeedKPH float32
    CanFly   bool
}

In this example, we've defined a class Animal with two fields Name and Origin . We've also defined a class Bird that "inherits" all of the fields and methods from Animal using composition. In addition, Bird has two additional fields SpeedKPH and CanFly .

Polymorphism

Polymorphism is the concept of using a single interface to represent multiple classes. In Go, we achieve polymorphism using interfaces and method overriding.
Here's an example:

type Shape interface {
    Area() float64
}
type Rectangle struct {
    Width  float64
    Height float64
}
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
type Circle struct {
    Radius float64
}
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}
func main() {
    shapes := []Shape{Rectangle{2, 3}, Circle{4}}
    for _, shape := range shapes {
        fmt.Println("Area =", shape.Area())
    }
}

In this example, we've defined an interface Shape with a single method Area() . We've also defined two implementations of this interface: Rectangle and Circle . We can now create a list of Shape objects and call the Area() method on each of them to get the area of the shape, regardless of whether it's a rectangle or a circle.

Conclusion

In this article, we've explored how to write object-oriented programs in Go. We've covered defining a class, creating an object, encapsulation, abstraction, inheritance, and polymorphism. By using these concepts, you can write well-organized, modular code that is easy to maintain and extend.