რატომ არის ჩაშენება Go ენისთვის მემკვიდრეობა არაა?

Go- ში ჩაშენება (embedding) საშუალებას აძლევს ერთ სტრუქტურას გამოიყენოს სხვა სტრუქტურის ველები და მეთოდები როგორც საკუთარი.

ძირითადი განსხვავებები მემკვიდრეობასთან:

• კომპოზიცია vs. ჰიერარქია: ჩაშენება არის კომპოზიციის ფორმა ("აქვს"), სადაც ერთი სტრუქტურა აქვს სხვა. მემკვიდრეობა (კლასიკური OOP-ში) არის ჰიერარქიის ფორმა ("არის"), სადაც ერთი კლასი არის სხვა კლასი ქვესკლასი.
• პოლიმორფიზმი: Go არ უჭერს მხარს პოლიმორფიზმს ქვესტიპების მხრივ ტრადიციულად მემკვიდრეობაში. პოლიმორფიზმი Go-ში რეალიზებულია ინტერფეისების მეშვეობით.
• წვდომა: ჩაშენება საშუალებას აძლევს პირდაპირ მიეღოთ წვდომა ველებს და მეთოდებს ჩაშენებული სტრუქტურის, როგორც გარეგანი სტრუქტურის მეშვეობით, მაგრამ არ ქმნის ტიპების ჰიერარქიას.
• გადაწყვეტილება არ არის: არ არსებობს პირდაპირი მექანიზმი ბაზის კლასის მეთოდების "გადაწერაზე". შეგიძლიათ განსაზღვროთ მეთოდი იგივე სახელით გარეგანი სტრუქტურაში, რომელიც "დაფარავს" ჩაშენებულ მეთოდს.

ჩაშენების მაგალითი:

package main

import "fmt"

type Engine struct {
	Cylinders int
}

func (e Engine) Start() {
	fmt.Println("ძრავი დაიწყო", e.Cylinders, "ცილინდრი")
}

type Car struct {
	Engine // ჩაშენება Engine-ის
	Brand  string
}

func main() {
	myCar := Car{
		Engine: Engine{Cylinders: 4},
		Brand:  "Toyota",
	}
	myCar.Start() // წვდომა Engine-ის Start მეთოდზე Car-ის მეშვეობით
	fmt.Println("ავტომობილის ბრენდი:", myCar.Brand)
	fmt.Println("ძრავის ცილინდრები:", myCar.Cylinders) // წვდომა Engine-ის ცილინდრებზე Car-ის მეშვეობით
}

ამ მაგალითში, Car აქვს Engine, მაგრამ Car არ არის Engine-ის ქვესკლასი. ჩვენ უბრალოდ მარტივად ვიღებთ წვდომას Engine-ის ველებს და მეთოდებს Car სტრუქტურის მეშვეობით.