Olio-ohjelmointikonseptien toteuttaminen Gossa

Object-Oriented Programming (OOP) on ohjelmointiparadigma, joka perustuu olioihin keskeisenä käsitteenä. OOP: ssa koodi muotoillaan toiminnallisuuden perusteella, mikä mahdollistaa koodin ylläpidon, abstraktion, uudelleenkäytettävyyden, tehokkuuden ja lukuisat toiminnallisuudet objektissa.

Objektilla on attribuutteja (muuttujia), jotka määrittelevät sen ominaisuudet, ominaisuudet ja menetelmät (funktiot), jotka määrittävät kohteen toiminnot (menettelyt) ja käyttäytymisen.

Go: n olioohjelmointi eroaa muista kielistä. Oliosuuntautuneita käsitteitä toteutetaan Go: ssa rakenteiden, rajapintojen ja mukautettujen tyyppien avulla.

Tyyppien mukauttaminen Gossa

Mukautetut tyypit tekevät samanlaisen koodin ryhmittelystä ja tunnistamisesta helppoa uudelleenkäyttöä varten.

Mukautettujen tyyppien ilmoittamisen koodi on:

tyyppi typeName dataType 

Kun luot mukautetun tyypin ja määrität muuttujan, voit tarkistaa tyypin käyttämällä heijastaa. Tyyppi() joka ottaa muuttujan ja palauttaa muuttujan tyypin.

tuonti("fmt"

instagram viewer


 "heijastaa")
tyyppi kaksi int// luo tyypin "kaksi"
var numero kaksi // muuttuja tyyppiä "kaksi"
fmt. Println (heijastaa. TypeOf (numero))

​​​

The määrä muuttuja on eräänlainen kaksi joka on kokonaisluku. Voit mennä pidemmälle luodaksesi lisää mukautettua tyyppiä.

Rakenteiden luominen Gossa

Rakenteet (rakenteet) ovat Go: n olio-ohjelmoinnin suunnitelmia. Rakenteet ovat käyttäjän määrittämiä kenttäkokoelmia.

Rakenne voi sisältää useita tietotyyppejä, mukaan lukien yhdistetyypit ja menetelmät.

Voit luoda rakenteen käyttämällä tätä syntaksia:

tyyppi RakenteenNimi struct {
// joku koodi
}

Perinteisesti rakenteiden nimet kirjoitetaan yleensä isoilla kirjaimilla ja kamelin kirjaimilla luettavuuden vuoksi.

Rakennetyyppi ottaa kenttien nimet ja tietotyypit. Rakenteet voivat ottaa vastaan ​​minkä tahansa Go-tietotyypin, mukaan lukien mukautetut tyypit.

tyyppi Käyttäjä struct {
 kenttä1 merkkijono
 kenttä2 int
 kenttäkartta kartta[merkkijono]int
}

Voit ilmentää rakennetyypin määrittämällä rakenteen muuttujaksi.

esimerkki := Käyttäjä{
// joku koodi
}

Rakenteen ilmentymä voidaan täyttää ilmentymisen kentillä, kuten alustuksessa on määritetty, tai asettaa arvoksi nolla.

esimerkki := Käyttäjä{
 kenttä1: "a merkkijono ala",
 kenttä2: 10,
 kenttäkartta: kartta[merkkijono]int{},
 }

Rakenne-elementtien käyttö

Voit käyttää rakenneilmentymän kenttiä käyttämällä kenttään pistemerkintää.

fmt. Println("Arvokentän käyttäminen", esimerkki.kenttä2)

Tämä tulostaa kenttä2 instantoidusta struct-ilmentymästä.

Menetelmien määrittäminen rakenteille

Funktiot (menetelmät) määritetään rakennetyypeille määrittämällä vastaanottimen nimi ja rakenteen nimi ennen funktion nimeä alla olevan syntaksin mukaisesti.

func(vastaanottimen rakennenimi)funktion nimi() {
// joku koodi
}

Menetelmä funktion nimi voidaan käyttää vain määritetylle rakennetyypille.

Perinnön käyttöönotto Gossa

Perintö on objektien ja tyyppien kyky päästä käsiksi ja käyttää muiden objektien menetelmiä ja attribuutteja. Gossa ei ole perintöä ominaisuutena, mutta voit käyttää sävellyksiä. Go: ssa kokoonpano tarkoittaa viittaamista superrakenteeseen (peritettävään rakenteeseen) alirakenteessa antamalla superrakenteen nimi alirakenteelle.

Käyttämällä yllä olevaa rakenneesimerkkiä:

tyyppi Käyttäjä struct {
 kenttä1 merkkijono
 kenttä2 int
 kenttäkartta kartta[merkkijono]int
}
tyyppi Käyttäjä2 struct {
 Käyttäjä
}

Ohitamalla Käyttäjä rakenteen nimi Käyttäjä2 rakenne, Käyttäjä2 struct voi käyttää kaikkia menetelmiä ja määritteitä Käyttäjä struct on instantiation, paitsi että käytetään abstraktiotekniikoita.

poika := Käyttäjä2{
 käyttäjä{
 kenttä1: "vauva",
 kenttä2: 0,
 kenttäkartta: nolla,
 },
 }
fmt. Println (son.field2)

The poika yllä oleva muuttuja on ilmentymä Käyttäjä2 struct. Kuten esimerkistä näkyy, poika muuttuja voi käyttää ja ilmentää User-tyypin arvoja ja käyttää niitä.

Tyyppikenttien kapselointi Go: ssa

Kapselointi, joka tunnetaan myös nimellä "tietojen piilottaminen", on a tekniikka objektin menetelmien ja attribuuttien niputtamiseksi yksiköiksi rajoittaa käyttöä ja pääsyä paitsi määritettynä (luku-/kirjoitusoikeudet).

Kapselointi toteutetaan Gossa käyttämällä vietyjä ja viemättömiä tunnisteita paketeissa.

Viedyt tunnisteet (luku ja kirjoitus)

Viedyt tunnisteet viedään niiden määritetyistä paketeista ja pääsystä muihin ohjelmiin. Kentän tunnisteen kirjoittaminen isoilla kirjaimilla vie kentän fo.

tyyppi Käyttäjä struct {
 Kenttä 1 merkkijono
 Kenttä 2 int
 FieldMap kartta[merkkijono]int
}
tyyppi Käyttäjä2 struct {
 Käyttäjä
}

Viemättömät tunnisteet (vain luku)

Viemättömiä tunnisteita ei viedä määritetystä paketista, ja ne kirjoitetaan perinteisesti pienillä kirjaimilla.

tyyppi Käyttäjä struct {
 kenttä1 merkkijono
 kenttä2 int
 kenttäkartta kartta[merkkijono]int
}
tyyppi Käyttäjä2 struct {
 Käyttäjä
}

Vietyjen ja viemättömien tunnisteiden käsite pätee myös objektin menetelmiin.

Polymorfismi Gossa

Polymorfismi on tekniikka, jota käytetään antamaan esineelle erilaisia ​​muotoja joustavuuden vuoksi.

Go toteuttaa polymorfismin rajapintojen avulla. Liitännät ovat mukautettuja tyyppejä, joita käytetään menetelmän allekirjoitusten määrittämiseen.

Liitäntöjen ilmoittaminen

Liitäntöjen ilmoittaminen on samanlaista kuin rakenteiden ilmoittaminen. Liitännät on kuitenkin ilmoitettu käyttämällä käyttöliittymä avainsana.

tyyppi Käyttöliittymän nimi käyttöliittymä{
//joitakin menetelmiä
}

Rajapintamääritykset sisältävät menetelmiä, jotka tulee toteuttaa rakennetyypeillä.

Liitäntöjen käyttöönotto rakenteissa

Rajapinnan toteuttavat tyypit on ilmoitettava, minkä jälkeen tyypin menetelmät toteuttavat rajapinnan.

// Käyttöliittymä
tyyppi Väri käyttöliittymä{
 Maali() merkkijono
}
// Rakenteiden ilmoittaminen
tyyppi Vihreä struct {
// jokin rakennekohtainen koodi
}
tyyppi Sininen struct {
// jokin tietty koodi
}

Yllä olevassa koodinpätkässä on a Väri a: lla ilmoitettu käyttöliittymä Maali menetelmä, jonka toteuttaa Vihreä ja Sininen rakennetyypit.

Liitännät toteutetaan antamalla menetelmiä rakennetyypeille ja sitten nimeämällä menetelmä toteutettavan liitäntämenetelmän mukaan.

func(g vihreä)Maali()merkkijono {
palata "vihreäksi maalattu"
}
func(b Sininen)Maali()merkkijono {
palata "maalattu siniseksi"
}

Paint-menetelmä on toteutettu vihreällä ja sinisellä tyypeillä, jotka voivat nyt kutsua ja käyttää Maali menetelmä.

sivellin := Vihreä{}
fmt. Println (sivellin. Maali())

"Maalattu vihreäksi" tulostetaan konsoliin vahvistaen, että käyttöliittymä on otettu käyttöön onnistuneesti.

Abstracting Fields in Go

Abstraktio on prosessi, jossa piilotetaan tyypin merkityksettömiä menetelmiä ja attribuutteja, mikä helpottaa ohjelman osien suojaamista epänormaalilta, tahattomalta käytöltä.

Go ei ota abstraktiota käyttöön heti; Voit kuitenkin työskennellä läpi abstraktin toteuttamisen rajapintojen avulla.

// ihmiset voivat juosta
tyyppi Ihmisen käyttöliittymä {
 juosta() merkkijono
}
// Poika on ihminen jolla on jalat
tyyppi Poika struct {
 Jalat merkkijono
}
// Boy-metodi toteuttaa ihmisrajapinnan run-menetelmän
func(h poika)juosta()merkkijono {
palata h. Jalat
}

Yllä oleva koodi luo a Ihmisen käyttöliittymä a juosta käyttöliittymä, joka palauttaa merkkijonon. The Poika tyyppi toteuttaa juosta menetelmä Ihmisen käyttöliittymä ja palauttaa merkkijonon instanssissa.

Yksi tapa toteuttaa abstraktio on saada rakenne perimään rajapinta, jonka menetelmät abstraktoidaan. On monia muita lähestymistapoja, mutta tämä on helpoin.

tyyppi Henkilö struct {
 Nimi merkkijono
 Ikä int
 Ihmisen tila 
}
funcpää() {
 henkilö1 := &Poika{Jalat: "kaksi jalkaa"}
 henkilö2 := &henkilö{ // henkilön esimerkki
 Nimi: "amina",
 Ikä: 19,
 Status: henkilö1,
 }
 fmt. Println (henkilö. Status.run()) 
}

The Henkilö rakenne perii Ihmisen käyttöliittymä ja voi käyttää kaikkia sen menetelmiä muuttujan avulla Tila perii käyttöliittymän.

Instantoinnissa viittauksella (osoittimen avulla) esiintymä Henkilö struct Henkilö 2 viittaa esiintymään Poika struct Henkilö 1 ja pääsee käsiksi menetelmiin.

Tällä tavalla voit määrittää tietyt menetelmät tyypin mukaan.

OOP vs toiminnallinen ohjelmointi

Olioohjattu ohjelmointi on tärkeä paradigma, koska se antaa sinulle enemmän hallintaa ohjelmaasi ja rohkaisee koodin uudelleenkäyttöön tavoilla, joita toiminnallinen ohjelmointi ei tee.

Tämä ei tee toiminnallisesta ohjelmoinnista huonoa valintaa, sillä toiminnallinen ohjelmointi voi olla hyödyllistä ja parempi joissakin käyttötapauksissa.

Mitä on olioohjelmointi? Perusasiat selitetty Layman's Terms

Lue Seuraava

Kirjailijasta