Скачать или смотреть Understanding the Embedding vs. Inheritance in Go: A Deep Dive into Structs

Explore the fundamental differences between embedding and inheritance in Go programming. Learn how to implement struct behavior effectively in Go!
---
This video is based on the question https://stackoverflow.com/q/70720911/ asked by the user 'Dennis M' ( https://stackoverflow.com/u/11136209/ ) and on the answer https://stackoverflow.com/a/70721052/ provided by the user 'Dylan Reimerink' ( https://stackoverflow.com/u/1205448/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Embedding vs. Inheritance in Go

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Embedding vs. Inheritance in Go: A Deep Dive into Structs

Go is a unique programming language that breaks away from traditional object-oriented programming practices, especially when it comes to struct behavior. One of the most common points of confusion for those transitioning to Go from languages like C++ or Java is the concepts of embedding and inheritance. In this guide, we'll unpack these concepts, clarifying how Go handles these struct behaviors, and provide illustrative examples to solidify your understanding.

The Problem: Why the Confusion?

Many newcomers to Go encounter issues when trying to pass an embedded struct (like Car) to a function that expects a base struct (like Vehicle). For example, you might have the following struct definitions:

[[See Video to Reveal this Text or Code Snippet]]

You might expect that a Car can be treated as a Vehicle because it embeds Vehicle. However, trying to pass an instance of Car to a function that accepts a Vehicle results in an error message stating that it cannot convert from the Car type to the Vehicle type. This leads to the question: Is there an equivalent to struct inheritance in Go, similar to C++?

The Solution: Understanding Embedding and Interfaces

No Traditional Inheritance

First and foremost, it's essential to grasp that Go does not support inheritance in the traditional sense. Instead, it uses a mechanism called embedding. Here’s a breakdown of how embedding works in Go:

Embedding allows one struct to include another struct as a field. This is akin to having a "has-a" relationship rather than an "is-a" relationship, which is what traditional inheritance represents.

Methods from the embedded struct can be directly accessed using the struct that embeds it, but it does not make the embedding struct an instance of the embedded struct type.

This can lead to confusion when trying to use a struct like Car as its embedded struct, Vehicle. Even though Car contains a Vehicle, they are considered separate types.

Struct Methods and Interface Implementation

To effectively use the behavior you're looking for, Go offers a different approach through interfaces. Let’s look at how we can set this up.

Step 1: Define an Interface

We start by defining an interface that declares the methods we expect from our Vehicle:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Implement Struct Methods

Next, we implement methods for our Vehicle and any structs that embed Vehicle:

[[See Video to Reveal this Text or Code Snippet]]

Now, let’s define additional structs like Car, Bike, and Motorcycle:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Use the Interface in a Function

Now we can define a function that takes our interface as a parameter:

[[See Video to Reveal this Text or Code Snippet]]

Example Usage

Now you can easily pass any struct that implements the Seater interface:

[[See Video to Reveal this Text or Code Snippet]]

Running this code will print the correct number of seats for each vehicle, demonstrating the flexibility gained from using interfaces in this way.

Conclusion

In summary, Go does not have traditional inheritance but instead employs embedding and interfaces to achieve polymorphism and code reuse. This approach, while different, provides a clear and structured method for managing behaviors in your structs. Remember, while it might feel different at first, embracing Go's model will lead to more flexible and maintainable code in the long run.

Now that you're equipped with a better understanding of embedding vs. inheritance in Go, you’re ready to tackle your Go programming journey with confidence!