Ինչպես է Golang-ում ժառանգությունը իրականացվում…

Go-ում ավանդական դասի ժառանգությունը չկա, ինչպես օրինակ Java կամ C++-ում: Փոխարենը օգտագործվում են երկու մեխանիզմներ՝

Ներառում (Embedding):

Ներառումը թույլ է տալիս ներդնել մեկ կառուցվածք կամ տիպ մյուսի մեջ:
Ներառված տիպը "փոխանցում" է իր դաշտերը և մեթոդները ներառող տիպին:
Ներառված տիպի դաշտերին և մեթոդներին հասանելիությունը կատարվում է ուղղակի, կարծես դրանք սահմանված լինեին ներառող տիպում:
Սա իմիտացիա է կոմպոզիցիայի, բայց ավելի հարմարեցված մուտքագրման սինտաքսով, ինչպես ժառանգության դեպքում:

package main

import "fmt"

type Engine struct {
    Type string
}

func (e Engine) Start() {
    fmt.Println(e.Type, "մոտորակ սկսվեց")
}

type Car struct {
    Engine // Ներառում է Engine կառուցվածքը
    Model  string
}

func main() {
    car := Car{
        Engine: Engine{Type: "V8"},
        Model:  "Mustang",
    }

    // Ներառված կառուցվածքի դաշտին և մեթոդին ուղղակի հասանելիություն
    fmt.Println("Ավտոմեքենայի մոդելը:", car.Model)
    car.Start() // Ներառված կառուցվածքի մեթոդի կանչ
}

Ինտերֆեյսներ:
- Ինտերֆեյսները սահմանում են մեթոդների հավաքածու, որոնք պետք է իրականացնել տիպը:
- Նրանք սահմանում են "գործողություն", ոչ թե տվյալների կառուցվածք:
- Տիպը պետք է միայն իրականացնել բոլոր մեթոդները, որոնք սահմանված են ինտերֆեյսում, առանց բացահայտ հայտարարելու, որ այն իրականացնում է այդ ինտերֆեյսը:
- Ինտերֆեյսները ապահովում են պոլիմորֆիզմ:
```
package main

import "fmt"

type Speaker interface {
    Speak()
}

type Dog struct {
    Name string
}

func (d Dog) Speak() {
    fmt.Println(d.Name, "ասում է Woof!")
}

type Cat struct {
    Name string
}

func (c Cat) Speak() {
    fmt.Println(c.Name, "ասում է Meow!")
}

func main() {
    animals := []Speaker{
        Dog{Name: "Buddy"},
        Cat{Name: "Whiskers"},
    }

    for _, animal := range animals {
        animal.Speak() // Պոլիմորֆիկ կանչ
    }
}
```

Կոմբինացիան ներառման և ինտերֆեյսների թույլ է տալիս Go-ին հասնել ճկունության և կոդի կրկնվող օգտագործման առանց ժառանգության դասավորությունների բարդությունների և խնդիրների, ինչպես օրինակ "դիամանտ" խնդիրը: Go-ում գերադասվում է կոմպոզիցիան և ինտերֆեյսները ժառանգության հիերարխիաների փոխարեն։

Ինչպես է Golang-ում ժառանգությունը իրականացվում?