RIPPLE : Subrat Gyawali

When you come from an object‑oriented background, you’re used to thinking in terms of classes, inheritance, and implicit polymorphism. Go, on the other hand, is not “object‑oriented” in the classic sense. It doesn’t have classes or a built‑in inheritance mechanism; instead, it supports many core OOP principles in a more explicit and transparent way. In Go, you work with structs, interfaces, and composition, making all relationships and dependencies clear in your code.

Explicit Encapsulation with Structs and Methods

In traditional OOP, classes bundle both data and behavior together. Go achieves a similar goal by using structs for data and associating functions with those structs as methods. This approach keeps your code simple and forces you to be explicit about the behavior each type provides.

Consider this basic example:

package main
import "fmt"
// Person holds the data.
type Person struct {
    Name string
}
// Greet is a method on Person that prints a greeting.
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}
func main() {
    p := Person{Name: "Alice"}
    p.Greet() // Output: Hello, my name is Alice
}

Even without classes, you still get encapsulation — data and the functions that operate on that data are bundled together.

Achieving Polymorphism Through Interfaces

Polymorphism lets you write code that can work with different types through a common interface. Unlike many traditional languages that require you to explicitly declare a class implements an interface, Go uses implicit interface implementation. If a type provides the necessary methods, it satisfies the interface automatically.

For instance, let’s define a simple interface and two types that satisfy it:

package main
import "fmt"
// Vehicle defines a behavior.
type Vehicle interface {
    Drive()
}
// Car implements Vehicle.
type Car struct {
    Model string
}
// Drive for Car.
func (c Car) Drive() {
    fmt.Printf("The car %s is driving.\n", c.Model)
}
// Bike implements Vehicle.
type Bike struct {
    Brand string
}
// Drive for Bike.
func (b Bike) Drive() {
    fmt.Printf("The bike %s is riding.\n", b.Brand)
}
// testDrive accepts any Vehicle.
func testDrive(v Vehicle) {
    v.Drive()
}
func main() {
    myCar := Car{Model: "Sedan"}
    myBike := Bike{Brand: "Yamaha"}
    
    // Both myCar and myBike satisfy the Vehicle interface.
    testDrive(myCar)
    testDrive(myBike)
}

Here, both the Car and Bike types satisfy the Vehicle interface simply by implementing a Drive() method. This implicit satisfaction gives you the benefits of polymorphism without needing explicit declarations.

Code Reuse Through Composition, Not Inheritance

Traditional OOP often relies on inheritance to share behavior. Go takes a different approach: it uses composition via struct embedding. Instead of inheriting from a base class, you embed one struct within another to reuse its fields and methods. This makes your code more modular and clear because every relationship is declared explicitly.

For example, consider an Employee type that reuses behavior from a Person type:

package main
import "fmt"
// Person encapsulates basic attributes.
type Person struct {
    Name string
}
// Greet is a method defined on Person.
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}
// Employee reuses Person by embedding it.
type Employee struct {
    Person      // Embedding Person
    EmployeeID  int
}
// Work adds behavior specific to Employee.
func (e Employee) Work() {
    fmt.Printf("%s (ID: %d) is working.\n", e.Name, e.EmployeeID)
}
func main() {
    emp := Employee{
        Person:     Person{Name: "Bob"},
        EmployeeID: 101,
    }
    // Employee automatically has Person's Greet method.
    emp.Greet() // Output: Hello, my name is Bob
    emp.Work()  // Output: Bob (ID: 101) is working.
}

By embedding the Person struct in Employee, you “inherit” its methods without the overhead and pitfalls of deep inheritance trees.

A Clear, Explicit Approach

One of Go’s key philosophies is to favor simplicity and explicitness over hidden complexity. Without traditional classes and inheritance, the relationships between types are laid bare in your code. There are no implicit hierarchies; instead, you directly see how types interact:

• Encapsulation is achieved by bundling data in structs with methods attached.
• Polymorphism is handled via interfaces that any type can satisfy as long as it implements the required methods.
• Code Reuse comes from embedding and composition rather than hidden base classes.

This explicit model forces you to think clearly about your design decisions, leading to code that’s easier to understand, test, and maintain.

Conclusion

Even though Go is fundamentally a procedural programming language, it supports many core OOP principles in a more explicit manner. By using structs, interfaces, and composition rather than traditional classes and inheritance, Go encourages clear, maintainable, and modular code. Whether you’re encapsulating data with methods, achieving polymorphism with implicit interfaces, or reusing code through composition, Go’s approach to OOP is practical and efficient.

If you’re coming from a classic OOP background, you’ll find that while Go doesn’t have “classes” in the traditional sense, its design encourages you to write code that embodies the same principles — only in a simpler, more transparent way.

Happy coding, and enjoy exploring how Go’s explicit style can help you build robust, maintainable software!