Jak implementovat koncepty objektově orientovaného programování v Go

Objektově orientované programování (OOP) je programovací paradigma založené na objektech jako ústředním konceptu. V OOP je kód formátován na základě funkčnosti, což umožňuje údržbu kódu, abstrakci, opětovnou použitelnost, efektivitu a řadu funkcí na objektu.

Objekt má atributy (proměnné), které definují jeho charakteristiky, vlastnosti a metody (funkce), které definují akce (procedury) a chování objektu.

Objektově orientované programování v Go se liší od jiných jazyků. Objektově orientované koncepty jsou implementovány v Go pomocí struktur, rozhraní a vlastních typů.

Přizpůsobení typů v Go

Vlastní typy usnadňují seskupování a identifikaci podobného kódu pro opětovné použití.

Kód pro deklarování vlastních typů je:

typ typeName dataType 

Při vytváření vlastního typu a přiřazení proměnné můžete typ zkontrolovat pomocí odrážet. Typ() který převezme proměnnou a vrátí typ proměnné.

import("fmt"
 "odrážet")
typ dva int// vytvoří typ "dva"
var číslo dvě // proměnná typu "dva"
fmt. Println (odraz. TypeOf (číslo))

​​​

The číslo proměnná je typ dva což je celé číslo. Můžete jít dále a vytvořit více vlastního typu.

Vytváření struktur v Go

Struktury (struktury) jsou plány pro objektově orientované programování v Go. Struktury jsou uživatelem definované kolekce polí.

Struktura může obsahovat různé typy dat, včetně složených typů a metod.

Strukturu můžete vytvořit pomocí této syntaxe:

typ StructName strukturovat {
// nějaký kód
}

Obvykle jsou názvy struktur obvykle velká a velká písmena pro čitelnost.

Typ struct přebírá názvy polí a datové typy. Struktury mohou obsahovat jakýkoli datový typ Go, včetně vlastních typů.

typ Uživatel strukturovat {
 pole1 tětiva
 pole2 int
 mapa pole mapa[tětiva]int
}

Instanci typu struct můžete vytvořit přiřazením struktury jako proměnné.

instance := Uživatel{
// nějaký kód
}

Instance struktury může být naplněna poli při vytváření instance, jak je definováno při inicializaci, nebo může být nastaveno na hodnotu null.

instance := Uživatel{
 pole 1: "a tětiva pole",
 pole2: 10,
 mapa pole: mapa[tětiva]int{},
 }

Přístup k prvkům struktury

K polím instance struktury můžete přistupovat pomocí tečkové notace pole.

fmt. Println("Přístup k poli hodnoty", instance.field2)

Tímto výstupem pole2 instance instance struct vytvořené.

Přiřazení metod ke strukturám

Funkce (metody) jsou přiřazeny k typům struktur zadáním jména příjemce a názvu struktury před názvem funkce, jak je znázorněno v syntaxi níže.

func(název struktury přijímače)název funkce() {
// nějaký kód
}

Metoda název funkce lze použít pouze na zadaný typ struktury.

Implementace dědičnosti v Go

Dědičnost je schopnost objektů a typů přistupovat a používat metody a atributy jiných objektů. Go nemá dědičnost jako funkci, ale můžete použít kompozice. V Go znamená složení odkazování na superstrukturu (strukturu, která má být zděděna) v podstruktuře poskytnutím názvu nadstavby podstruktuře.

Pomocí výše uvedeného příkladu struktury:

typ Uživatel strukturovat {
 pole1 tětiva
 pole2 int
 mapa pole mapa[tětiva]int
}
typ Uživatel2 strukturovat {
 Uživatel
}

Předáním Uživatel název struktury do Uživatel2 struktura, Uživatel2 struct má přístup ke všem metodám a atributům Uživatel struct na konkretizaci kromě abstrakce techniky jsou použity.

syn := Uživatel2{
 Uživatel{
 pole 1: "dítě",
 pole2: 0,
 mapa pole: nula,
 },
 }
fmt. Println (son.field2)

The syn výše uvedená proměnná je konkretizací Uživatel2 strukturovat. Jak je vidět na příkladu, syn proměnná může přistupovat a instanciovat hodnoty typu Uživatel a používat je.

Zapouzdření polí typu v Go

Zapouzdření, známé také jako „skrývání informací“, je a technika sdružování metod a atributů objektu do jednotek omezit použití a přístup kromě specifikovaných (povolení oprávnění pro čtení/zápis).

Zapouzdření je implementováno v Go pomocí exportovaných a neexportovaných identifikátorů v balíčcích.

Exportované identifikátory (čtení a zápis)

Exportované identifikátory jsou exportovány z jejich definovaných balíčků a přístupu do jiných programů. Použití velkých písmen v identifikátoru pole exportuje pole fo.

typ Uživatel strukturovat {
 Pole1 tětiva
 Pole2 int
 FieldMap mapa[tětiva]int
}
typ Uživatel2 strukturovat {
 Uživatel
}

Neexportované identifikátory (pouze pro čtení)

Neexportované identifikátory se z definovaného balíku neexportují a jsou obvykle psány malými písmeny.

typ Uživatel strukturovat {
 pole1 tětiva
 pole2 int
 mapa pole mapa[tětiva]int
}
typ Uživatel2 strukturovat {
 Uživatel
}

Koncept exportovaných a neexportovaných identifikátorů platí také pro metody objektu.

Polymorfismus v Go

Polymorfismus je technika používaná k dodání různých forem objektu pro flexibilitu.

Go implementuje polymorfismus pomocí rozhraní. Rozhraní jsou vlastní typy používané k definování signatur metod.

Deklarace rozhraní

Deklarace rozhraní je podobná deklaraci struktur. Rozhraní jsou však deklarována pomocí rozhraní klíčové slovo.

typ Název rozhraní rozhraní{
//některé metody
}

Deklarace rozhraní obsahují metody, které mají být implementovány typy struktur.

Implementace rozhraní ve strukturách

Musí být deklarovány typy, které implementují rozhraní, a poté metody daného typu implementují rozhraní.

// Rozhraní
typ Barva rozhraní{
 Malovat() tětiva
}
// Deklarace struktur
typ Zelená strukturovat {
// nějaký kód specifický pro strukturu
}
typ Modrý strukturovat {
// nějaký specifický kód
}

Fragment kódu výše má a Barva rozhraní deklarované pomocí a Malovat metoda, kterou má implementovat Zelená a Modrý typy struktur.

Rozhraní se implementují přiřazením metod k typům struktur a poté pojmenováním metody podle metody rozhraní, která má být implementována.

func(g zelená)Malovat()tětiva {
vrátit se "zeleně natřený"
}
func(b modrá)Malovat()tětiva {
vrátit se "natřený modře"
}

Metoda Malování je implementována typy Green a Blue, které nyní mohou volat a používat Malovat metoda.

štětec := Zelený{}
fmt. Println (štětec. Malovat())

Na konzole je vytištěno „Vybarveno zeleně“ a potvrzuje, že rozhraní bylo úspěšně implementováno.

Abstrakce polí v Go

Abstrakce je proces skrývání nedůležitých metod a atributů typu, což usnadňuje zabezpečení částí programu před abnormálním, nezamýšleným použitím.

Go nemá abstrakci implementovanou hned od začátku; můžete se však propracovat implementací abstrakce pomocí rozhraní.

// lidé mohou běhat
typ Člověk rozhraní {
 běh() tětiva
}
// Chlapec je člověk s nohama
typ Chlapec strukturovat {
 Nohy tětiva
}
// metoda na chlapci implementuje metodu run rozhraní Human
func(h chlapec)běh()tětiva {
vrátit se h. Nohy
}

Výše uvedený kód vytvoří a Člověk rozhraní s a běh rozhraní, které vrací řetězec. The Chlapec typ implementuje běh metoda Člověk rozhraní a vrátí řetězec při vytváření instance.

Jedním ze způsobů, jak implementovat abstrakci, je vytvořit strukturu, která zdědí rozhraní, jehož metody mají být abstrahovány. Existuje mnoho dalších přístupů, ale tento je nejjednodušší.

typ Osoba strukturovat {
 název tětiva
 Stáří int
 Stav člověka 
}
funchlavní() {
 osoba1 := &Chlapec{Nohy: "dvě nohy"}
 osoba2 := &Osoba{ // instance osoby
 Jméno: "amina",
 Stáří: 19,
 Stav: osoba1,
 }
 fmt. Println (osoba. Status.run()) 
}

The Osoba struct zdědí Člověk rozhraní a může přistupovat ke všem jeho metodám pomocí proměnné Postavení zdědění rozhraní.

Při instanciaci odkazem (pomocí ukazatele) instance the Osoba strukturovat Osoba2 odkazuje na instanci Chlapec strukturovat Osoba1 a získá přístup k metodám.

Tímto způsobem můžete určit konkrétní metody, které mají být implementovány podle typu.

OOP vs funkční programování

Objektově orientované programování je důležité paradigma, protože vám dává větší kontrolu nad vaším programem a podporuje opětovné použití kódu způsobem, který funkcionální programování neumožňuje.

To neznamená, že funkční programování není špatnou volbou, protože funkční programování může být pro některé případy použití užitečné a lepší.

Co je objektově orientované programování? Základy vysvětlené laicky

Přečtěte si další

O autorovi