What is the difference between a struct and a class in Go?

In Go, there is no traditional concept of 'class' (Class). Go is a language that prioritizes simplicity and practical functionality. However, Go achieves functionality similar to classes in other object-oriented programming languages by combining structs with methods. The following are several key differences between structs in Go and classes in traditional object-oriented programming languages:

1. Definition and Inheritance:

   • Class: In traditional object-oriented languages such as Java or C++, classes encapsulate data and support inheritance, enabling features like polymorphism.
   • Struct: In Go, structs are used exclusively for data encapsulation and do not support inheritance directly. Instead, similar functionality can be achieved by embedding other structs, which is simpler and avoids the pitfalls of traditional inheritance.

2. Method Definition:

   • Class: Methods are typically defined within the class definition and are tightly bound to class instances.
   • Struct: In Go, methods are not defined within structs but are implemented by using the struct as a receiver in function definitions. This separation ensures that structs focus solely on data, while methods can be managed separately as needed.

3. Polymorphism and Interfaces:

   • Class: Polymorphism is typically achieved through inheritance and method overriding.
   • Struct: Go handles polymorphism using interfaces. Any type that implements all methods of an interface automatically satisfies it. Compared to class inheritance, interfaces provide a more flexible and decoupled approach to polymorphism.

4. Constructors:

   • Class: Many object-oriented languages allow defining constructors within classes, which are special methods automatically called when creating objects.
   • Struct: Go does not have a concept of constructors. Instead, ordinary functions are typically defined to return struct instances, serving as a substitute for constructors. These functions can handle parameter settings and initialization as needed.

Examples:

Assume we have a struct representing geometric shapes:

• In Java (using classes):

  java
  public class Shape {
      private int edgeCount;
      public Shape(int edgeCount) {
          this.edgeCount = edgeCount;
      }
      public int getEdgeCount() {
          return this.edgeCount;
      }
  }

• In Go (using structs and interfaces):

  go
  type Shape struct {
      EdgeCount int
  }
  func NewShape(edgeCount int) *Shape {
      return &Shape{EdgeCount: edgeCount}
  }
  type Geometric interface {
      Area() float64
  }
  func (s *Shape) Area() float64 {
      // Implementation for calculating area
      return 0.0 // Example; actual implementation depends on the specific shape
  }

Through these examples, it is evident that although Go's structs and methods provide functionality comparable to traditional classes, Go's approach is more concise and flexible, especially beneficial for handling complex inheritance scenarios.