Cum funcționează modelul orientat pe obiecte în Go…

În Go nu există un model orientat pe obiect tradițional cu o ierarhie profundă de moștenire a claselor. În schimb, se utilizează:

Structuri (Structs): Definirea câmpurilor de date, similar cu clasele fără metode.
```
type Person struct {
    Name string
    Age  int
}
```
Metode: Funcții legate de o anumită structură. Sunt definite separat de structură.
```
func (p Person) Greet() string {
    return "Salut, numele meu este " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Metodele cu receptor pe valoare (de exemplu, (p Person)) lucrează cu o copie a structurii.
- Metodele cu receptor pe pointer (de exemplu, (p *Person)) lucrează cu originalul structurii, permițând modificarea câmpurilor sale.
Interfețe: Seturi de semnături de metode. Tipurile care implementează toate metodele unei interfețe satisfac implicit această interfață. Aceasta este baza polimorfismului în Go.
```
type Greeter interface {
    Greet() string
}

// Person implementează implicit Greeter
```

Compoziție (Incrustare): În loc de moștenire, o structură poate incrusta o altă structură, accesând câmpurile și metodele acesteia.

type Employee struct {
    Person // Incrustează structura Person
    ID     string
}

func (e Employee) GetID() string {
    return e.ID
}

Câmpurile și metodele incrustate sunt disponibile direct:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Acces la câmpul Name prin structura Person incrustată
fmt.Println(e.Greet())  // Apelarea metodei Greet prin structura Person incrustată
fmt.Println(e.GetID())  // Apelarea metodei Employee

Astfel, modelul orientat pe obiect în Go se bazează pe compoziția structurilor și comportamentul definit de interfețe, și nu pe o ierarhie clasică de moștenire a claselor.

Cum funcționează modelul orientat pe obiecte în Go?