Go does not use traditional classes and inheritance models, but implements object-oriented programming through structures, interfaces, and combinations. 1. Structure replacement class: Go uses struct to define data types and add behavior to the structure through method sets. The method is defined independently of the structure. 2. No inheritance only combines: Go implements the combination of multiplexing fields and methods through structure nesting, rather than creating type hierarchies through inheritance. 3. Implicit interface: The implementation of an interface does not require explicit declaration, and the interface can be satisfied as long as the type contains the methods required by the interface. 4. Constructor normalization: Go does not have a constructor keyword, but returns the initialized structure instance through a normal function. This design makes the code lighter, flexible and easy to organize.

Go doesn't follow the traditional class-based object-oriented programming (OOP) model like Java or C . Instead, it uses a simpler, more flexible approach centered around structs and interfaces. If you're coming from an OOP background, this might feel a bit unfamiliar at first, but it's designed to keep things lightweight and compositional.

Structs Replace Classes

In Java or C , you define classes that bundle data (fields) and behavior (methods). In Go, you use structs for data and attach methods separately.

For example:

 type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

Here, Rectangle is a struct, and Area() is a method attached to it. There's no class keyword, and methods are defined outside the struct definition. This separation makes code easier to organize in some cases, especially as your project grows.

Also, structs support composition naturally — you can embed one struct inside another to reuse fields and methods.

No Inheritance, Just Composition

Traditional OOP languages ??rely heavily on inheritance — creating new types by extending existing ones. Go avoids this entirely and favors composition instead.

Instead of saying "a Square is a Rectangle," Go encourages saying "a Square has a Rectangle" or just reuses behaviors through embedding:

 type Base struct {
    Name string
}

func (b Base) SayHello() {
    fmt.Println("Hello from", b.Name)
}

type Composite struct {
    Base
    Value int
}

Now, Composite automatically gets all the methods and fields from Base . It's not inheritance — it's more like automatic field promotion. The benefit? Less complexity and fewer surprises when dealing with large type hierarchies.

Interfaces Are Implicit

In Java or C , interfaces are explicit: you declare that a class implements them and must provide all required methods. Go flips this — interfaces are implicit .

You don't have to say your type implements an interface; if your type has the right methods, it automatically satisfyes the interface.

Example:

 type Shape interface {
    Area() float64
}

func PrintArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

Any type with an Area() float64 method can be passed to PrintArea , whether it's a Rectangle , a Circle , or anything else. You don't have to explicitly declare that these types implement Shape .

This makes Go's interface system more flexible and decoupled, especially in larger programs where tight coupling is risky.

No Constructors, Just Functions

Traditional OOP often includes constructors — special methods called when an object is created. Go doesn't have constructors. Instead, you write regular functions that return initialized values ??or points.

A common pattern:

 func NewRectangle(width, height float64) *Rectangle {
    return &Rectangle{Width: width, Height: height}
}

This function acts like a constructor, but there's nothing magic about it — just a normal function returning a value. You can have multiple such functions for different initialization needs.

• You can name them differently depending on how you want to create the object.
• You can do validation or setup before returning the instance.
• There's no this or super keyword — just plain function logic.

So while Go supports object-like patterns, it does so without many of the features found in classic OOP languages. Its approach is more minimal and composable, focusing on simplicity and clarity rather than strict object hierarchies.

If you're used to working with deep inheritance trees or tightly bound classes, Go's style might take a little getting used to — but once you start thinking in terms of interfaces and composition, it becomes pretty natural.

At least, that's been my experience.

The above is the detailed content of How does Go's approach to object-oriented programming differ from traditional OOP languages like Java or C ?. For more information, please follow other related articles on the PHP Chinese website!