Structs Instead of Classes In Go

In Go, the primary building block for defining custom types and their behaviour is the struct. Go does not have a class-based object-oriented paradigm like some other programming languages. Instead, Go promotes a composition-based approach using structs to define data structures and associated methods.

In Go, you define a struct using the type keyword followed by the name of the struct and its field declarations. Here’s an example:

package main

import "fmt"

type Person struct {
    Name  string
    Age   int
    Email string

func (p Person) Greet() {
    fmt.Println("Hello, my name is", p.Name)

func main() {
    p := Person{Name: "John Doe", Age: 30, Email: ""}


In this example, we define a struct Person with fields Name, Age, and Email. We also define a method Greet() associated with the Person struct.

In the main() function, we create an instance of Person named p using a struct literal and initialize its fields. We can access the fields of the struct using dot notation (p.Name, p.Age, p.Email) and print their values.

We can also call the Greet() method on the p struct instance, which outputs:

Hello, my name is John Doe

Structs in Go provide a way to define and encapsulate data along with associated methods. They enable the creation of custom data structures and behavior without relying on classes or inheritance. Instead, Go encourages composition by embedding one struct type within another to achieve code reuse and modularity.

Is Go Object Oriented?

Go is often categorized as a language that supports some object-oriented programming (OOP) features but does not strictly adhere to the traditional class-based OOP paradigm found in languages like Java or C++.

While Go does not have classes, inheritance, or some other traditional OOP concepts, it provides several mechanisms that facilitate object-oriented programming:

  1. Structs: Go uses structs as a way to define custom data types with fields and associated methods. Structs in Go serve a similar purpose to classes in other languages.
  2. Methods: Go allows you to define methods on struct types, enabling you to associate behavior with the data structures. Methods can be defined on both user-defined types (structs) and built-in types.
  3. Encapsulation: Go supports encapsulation by allowing you to control the visibility of struct fields and methods using the concept of exported and unexported identifiers (based on the first letter being uppercase or lowercase).
  4. Interfaces: Go utilizes interfaces to define a set of method signatures that a type must implement. This allows for polymorphism and dependency inversion, similar to interfaces in traditional OOP. Types in Go are implicitly satisfied by interfaces, promoting loose coupling and flexibility.
  5. Composition: Go encourages composition-based design, where you can embed one struct within another to reuse functionality. This approach allows for code reuse and modularity, which are important principles in object-oriented programming.

While Go incorporates some object-oriented concepts, it also draws inspiration from other programming paradigms such as procedural programming and concurrent programming. Go’s design philosophy emphasizes simplicity, efficiency, and composition over rigid class hierarchies and complex inheritance relationships.

Therefore, while Go is not considered a pure object-oriented programming language, it provides sufficient features to write code in an object-oriented style when needed, and it blends well with other programming paradigms.

Why Go’s structs are superior to class-based inheritance

In Go, structs are often considered superior to class-based inheritance found in other programming languages due to the following reasons:

  1. Simplicity and Composition: Go promotes a composition-based approach using structs, which is simpler and more flexible than class-based inheritance. Instead of inheriting behavior from a single parent class, you can compose structs by embedding one struct within another to reuse functionality. This approach allows you to build complex structures using small, reusable components.
  2. Explicitness and Clarity: Inheritance can introduce complex hierarchies and relationships between classes, making the codebase harder to understand and maintain. Go’s approach with structs promotes explicitness and clarity. The behavior and structure of a type are defined explicitly by the struct itself, rather than relying on inheritance hierarchies.
  3. Interface-based Polymorphism: Go uses interfaces for polymorphism instead of class hierarchies. With interfaces, you define behavior independently from the struct, allowing different types to satisfy the same interface. This promotes loose coupling and decoupling of components, enabling greater flexibility and code reuse.
  4. No Implicit Dependencies: Inheritance can lead to implicit dependencies between classes, where changes in one class can have unintended effects on its subclasses. Go’s composition-based approach avoids these implicit dependencies, making code easier to reason about and test. Each struct is self-contained and explicit in its dependencies.
  5. Flexibility and Extensibility: Go’s approach with structs and composition provides greater flexibility and extensibility compared to class-based inheritance. You can add or modify behavior by composing new structs or embedding existing ones. This allows you to adapt and extend functionality without modifying existing code or introducing fragile hierarchies.
  6. Reduced Complexity and Coupling: Class hierarchies can become complex, especially as they grow in size and depth. Go’s struct-based approach avoids the complexities associated with inheritance and reduces coupling between types. This makes the codebase more maintainable and less prone to bugs caused by tightly coupled relationships.

It’s important to note that the effectiveness of struct-based composition depends on the programming paradigm and the specific requirements of the project. While Go’s approach may be well-suited for many scenarios, class-based inheritance can still be valuable in certain contexts. Ultimately, the choice between the two depends on the trade-offs and design principles that best align with the goals of the project.

New() function instead of constructors In GO

In Go, there is no language-level support for constructors like in some other programming languages. Instead, the convention in Go is to use a factory function, often named New(), to create and initialize instances of a struct.

Here’s an example that demonstrates the use of a New() function instead of a constructor in Go:

package main

import "fmt"

type Person struct {
    Name string
    Age  int

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,

func main() {
    p := NewPerson("John Doe", 30)

In this example, we define a Person struct with fields Name and Age. Instead of defining a constructor method, we create a NewPerson() function that acts as a factory function for creating Person instances.

The NewPerson() function takes the necessary parameters for initializing the Person struct and returns a pointer to the newly created Person instance. It uses a struct literal to initialize the struct with the provided values.

In the main() function, we call the NewPerson() function to create a Person instance with the name “John Doe” and age 30. We then print the Name and Age fields of the created Person instance.

Using a New() function as a factory provides flexibility in initializing struct instances and allows for additional initialization logic if needed. It separates the responsibility of object creation from the struct definition itself.

It’s worth noting that the use of New() is a convention in Go, but not a strict rule. You can choose different names for your factory functions based on your preference or naming conventions within your project.