Go
Object georiënteerd programmeren

Opmerkingen

structs

Go ondersteunt door de gebruiker gedefinieerde typen in de vorm van structs en type aliassen. structs zijn samengestelde typen, de gegevensbestanddelen waaruit het struct-type bestaat, worden velden genoemd . een veld heeft een type en een naam die uniek moet zijn.

package main

type User struct {
    ID uint64
    FullName string
    Email    string
}

func main() {
    user := User{
        1,
        "Zelalem Mekonen",
        "[email protected]",
    }

    fmt.Println(user) // {1 Zelalem Mekonen [email protected]}
}

dit is ook een juridische syntaxis voor het definiëren van structuren

type User struct {
    ID uint64
    FullName, Email string
}

user := new(User)

user.ID = 1
user.FullName = "Zelalem Mekonen"
user.Email = "[email protected]"

Ingesloten structs

omdat een struct ook een gegevenstype is, kan het worden gebruikt als een anoniem veld, de buitenste struct heeft rechtstreeks toegang tot de velden van de ingebedde struct, zelfs als de struct uit een ander pakket kwam. dit gedrag biedt een manier om een deel van of uw gehele implementatie af te leiden van een ander type of een set typen.

package main

type Admin struct {
    Username, Password string
}

type User struct {
    ID uint64
    FullName, Email string
    Admin // embedded struct
}

func main() {
    admin := Admin{
        "zola",
        "supersecretpassword",
    }

    user := User{
        1,
        "Zelalem Mekonen",
        "[email protected]",
        admin,
    }

    fmt.Println(admin) // {zola supersecretpassword}

    fmt.Println(user) // {1 Zelalem Mekonen [email protected] {zola supersecretpassword}}

    fmt.Println(user.Username) // zola

    fmt.Println(user.Password) // supersecretpassword
}

methoden

In Go is een methode

een functie die werkt op een variabele van een bepaald type, de ontvanger genoemd

de ontvanger kan van alles zijn, niet alleen structs maar zelfs een function , alias types voor ingebouwde types zoals int , string , bool kunnen een methode hebben, een uitzondering op deze regel is dat interfaces (later besproken) geen methoden kunnen hebben, omdat een interface is een abstracte definitie en een methode is een implementatie die probeert een compilatiefout te genereren.

Door structs en methods combineren, kunt u een object van een class in Object Oriented programmeren krijgen.

een methode in Go heeft de volgende handtekening

func (name receiverType) methodName(paramterList) (returnList) {}

package main

type Admin struct {
    Username, Password string
}

func (admin Admin) Delete() {
    fmt.Println("Admin Deleted")
}

type User struct {
    ID uint64
    FullName, Email string
    Admin
}

func (user User) SendEmail(email string) {
    fmt.Printf("Email sent to: %s\n", user.Email)
} 

func main() {
    admin := Admin{
        "zola",
        "supersecretpassword",
    }

    user := User{
        1,
        "Zelalem Mekonen",
        "[email protected]",
        admin,
    }

    user.SendEmail("Hello") // Email sent to: [email protected]

    admin.Delete() // Admin Deleted
}

Pointer Vs Value-ontvanger

de ontvanger van een methode is meestal een aanwijzer om prestatieredenen, omdat we geen kopie van de instantie zouden maken, zoals het geval zou zijn bij waardeontvanger, dit is met name het geval als het ontvangertype een struct is. een andere reden om van het ontvangertype een aanwijzer te maken zou zijn zodat we de gegevens kunnen wijzigen waarnaar de ontvanger verwijst.

een waardeontvanger wordt gebruikt om wijziging van de gegevens in de ontvanger te voorkomen, een vaule-ontvanger kan een prestatiehit veroorzaken als de ontvanger een grote structuur heeft.

package main

type User struct {
    ID uint64
    FullName, Email string
}

// We do no require any special syntax to access field because receiver is a pointer
func (user *User) SendEmail(email string) {
    fmt.Printf("Sent email to: %s\n", user.Email)
}    

// ChangeMail will modify the users email because the receiver type is a ponter
func (user *User) ChangeEmail(email string) {
    user.Email = email;
}

func main() {
    user := User{
        1,
        "Zelalem Mekonen",
        "[email protected]",
    }

    user.SendEmail("Hello") // Sent email to: [email protected]

    user.ChangeEmail("[email protected]")

    fmt.Println(user.Email) // [email protected]
}

Interface & polymorfisme

Interfaces bieden een manier om het gedrag van een object op te geven. Als iets dit kan, kan het hier worden gebruikt. een interface definieert een set methoden, maar deze methoden bevatten geen code omdat ze abstract zijn of de implementatie wordt overgelaten aan de gebruiker van de interface. in tegenstelling tot de meeste objectgeoriënteerde talen kunnen interfaces variabelen in Go bevatten.

Polymorfisme is de essentie van objectgeoriënteerd programmeren: het vermogen om verschillende soorten objecten uniform te behandelen, zolang ze zich maar aan dezelfde interface houden. Go-interfaces bieden deze mogelijkheid op een zeer directe en intuïtieve manier

package main

type Runner interface {
    Run()
}

type Admin struct {
    Username, Password string
}

func (admin Admin) Run() {
    fmt.Println("Admin ==> Run()");
}

type User struct {
    ID uint64
    FullName, Email string
}

func (user User) Run() {
    fmt.Println("User ==> Run()")
}

// RunnerExample takes any type that fullfils the Runner interface
func RunnerExample(r Runner) {
    r.Run()
}

func main() {
    admin := Admin{
        "zola",
        "supersecretpassword",
    }

    user := User{
        1,
        "Zelalem Mekonen",
        "[email protected]",
    }

    RunnerExample(admin)

    RunnerExample(user)
    
}