Skip to content

Latest commit

 

History

History
321 lines (241 loc) · 9.95 KB

02.5.md

File metadata and controls

321 lines (241 loc) · 9.95 KB
Raw

Nesne-Yönelim

Son iki bölüm de fonksiyonlar ve struct hakkında konuştuk, ancak fonksiyonları struct ın bir alanı olarak kullanmayı düşündünüz mü? Bu bölümde, alıcısı olan method olarak adlandırılan başka bir fonksiyon biçimi tanıtacağım.

method

Bir "Dikdortgen" struct tanımladığınızı ve onun alanını hesaplamak istediğinizi varsayalım. Bu amaca ulaşmak için genellikle aşağıdaki kodu kullanırdık.

package main

import "fmt"

type Dikdortgen struct {
	genislik, yukseklik float64
}

func alan(d Dikdortgen) float64 {
	return d.genislik * d.yukseklik
}

func main() {
	d1 := Dikdortgen{12, 2}
	d2 := Dikdortgen{9, 4}
	fmt.Println("d1 in alanı: ", alan(d1))
	fmt.Println("d2 nin alanı: ", alan(d2))
}

Yukarıdaki örnek bir Dikdortgen'in alanını hesaplayabilir. Burada alan isimli fonksiyonu kullanıyoruz, fakat bu fonksiyon Dikdortgen struct'ının bir method u değil(klasik nesne yönelimli dillerdeki sınıf nethodları gibi). Fark edebileceğiniz gibi fonksiyon ve struct iki bağımsız şeydir.

Şimdiye kadar sorun değil. Bununla birlikte, bir dairenin, karenin, beşgenin veya başka herhangi bir şeklin alanını da hesaplamanız gerekiyorsa, çok benzer adlara sahip ek fonksiyonlar eklemeniz gerekecektir.

Şekil 2.8 Fonksiyon ve struct arasındaki ilişki

Açıkçası bu hiç hoş değil. Ayrıca, alan fonksiyonu bir dairenin veya dikdörtgenin özelliği olmalıdır.

İşte method un devreye gireceği nokta burasıdır. method, bir türe/tipe bağlı fonksiyondur. func anahtar sözcüğünün, bu methodun ana gövdesi olan receiver adlı bit parametreye sahip olması haricinde, fonksiyonlara benzer bir sözdizimi vardır.

Aynı örneği kullanarak, Dikdortgen.Alan() çevresel bir fonksiyon olması yerine doğrudan Dikdortgen'e ait bir methoddur. Daha spesifik olarak, yukseklik, genislik ve Alan() hepsi Dikdortgen'e aittir.

Rob Pike'ın dediği gibi.

"Bir method, alıcı olarak adlandırılan ilk örtülü argüman olan bir fonksiyondur."

method sözdimi.

func (r ReceiverType) funcName(parameters) (results)

Örneğimizi method kullanarak değiştirelim.

package main

import (
	"fmt"
	"math"
)

type Daire struct {
	yaricap float64
}

type Dikdortgen struct {
	genislik, yukseklik float64
}

// method
func (daire Daire) Alan() float64 {
	return daire.yaricap * daire.yaricap * math.Pi
}

// method
func (dikdortgen Dikdortgen) Alan() float64 {
	return dikdortgen.genislik * dikdortgen.yukseklik
}

func main() {
	daire1 := Daire{10}
	daire2 := Daire{25}
	dikdortgen1 := Dikdortgen{9, 4}
	dikdortgen2 := Dikdortgen{12, 2}

	fmt.Println("daire1 in alanı: ", daire1.Alan())
	fmt.Println("daire2 nin alanı: ", daire2.Alan())
	fmt.Println("dikdortgen1 in alanı: ", dikdortgen1.Alan())
	fmt.Println("dikdortgen2 nin alanı: ", dikdortgen2.Alan())
}

Methodları kullanma notları.

  • Methodların adı aynıysa ancak aynı alıcıları paylaşmıyorlarsa, aynı değildirler.
  • Methodlar alıcılardaki alanlara erişebilirler.
  • Bir struct da method çağırmak için . kullanın, aynı şekilde alanları da çağırabilirsiniz.

Şekil 2.9 Methodlar farklı struct larda farklıdırlar.

Yukarıdaki örnekte Alan() methodu hem Dikdortgen hem de Daire'de mevcuttur, bu nedenle alıcıları Dikdortgen ve Daire'dir.

Önemsiz bir detay olarak bir method noktalı çizgi ile kullanılmışsa anlamı alıcıya referans olarak değil değer olarak geçirilmiştir demektir. Aralarındaki fark, bir methodun, alıcısı referansla geçildiğinde alıcının değerlerini değiştirebilmesi ve değer olarak geçildiğinde ise alıcının bir kopyasını almasıdır.

Alıcı sadece bir struct'mı olmalıdır? Tabii ki değil. Herhangibir tür/tip methodun alıcısı olabilir. Özelleştirilmiş türler/tipler hakkında kafanız karışabilir. struct özel bir tür/tip dir - daha birçok özelleştirilmiş tür/tip yer almaktadır.

Özelleştirilmiş bir tür/tip tanımlamak için aşağıdaki formatı kullanın.

type typeName typeLiteral

Özelleştirilmiş türler/tipler e örnekler:

type yas int
type fiyat float32
type aylar map[string]int

a := aylar {
	"Ocak":31,
	"Şubat":28,
	...
	"Aralık":31,
}

Özelleştirilmiş türlerin/tiplerin artık nasıl kullanılacağını biliyorsunuz. C programlama dilindeki typedef ifadesine benzer bir şekilde, yukarıdaki örnekte int yerine yas kullanıyoruz.

method hakkında konuşmaya geri dönelim.

Özelleştirilmiş türler/tipler de istediğiniz kadar method kullanabilirsiniz.

package main

import "fmt"

const (
	BEYAZ = iota
	SIYAH
	MAVI
	KIRMIZI
	SARI
)

type Kutu struct {
	genislik, yukseklik, derinlik float64
	renk Renk
}
type Renk byte
type KutuListesi []Kutu //kutu listesi

// method
func (kutu Kutu) Hacim() float64 {
	return kutu.genislik * kutu.yukseklik * kutu.derinlik
}

// işaretçi alıcılı method
func (k *Kutu) RenkAta(r Renk) {
	k.renk = r
}

// method
func (kl KutuListesi) EnBuyuklerininRengi() Color {
	h := 0.00
	r := Renk(BEYAZ)
	for _, k := range kl {
		if k.Hacim() > h {
			h = k.Hacim()
			r = k.renk
		}
	}
	return k
}

// method
func (kl KutuListesi) SiyahaBoya() {
	for i, _ := range kl {
		kl[i].RenkAta(SIYAH)
	}
}

// method
func (r Renk) String() string {
	strings := []string{"BEYAZ", "SIYAH", "MAVI", "KIRMIZI", "SARI"}
	return strings[r]
}

func main() {
	kutular := KutuListesi{
		Kutu{4, 4, 4, KIRMIZI},
		Kutu{10, 10, 1, SARI},
		Kutu{1, 1, 20, SIYAH},
		Kutu{10, 10, 1, MAVI},
		Kutu{10, 30, 1, BEYAZ},
		Kutu{20, 20, 20, SARI},
	}

	fmt.Printf("%d adet kutumuz var\n", len(kutular))
	fmt.Println("İlk kutunun hacmi ", kutular[0].Hacim(), "cm³")
	fmt.Println("Son kutunun rengi", kutular[len(kutular)-1].renk.String())
	fmt.Println("En büyük kutu", kutular.EnBuyuklerininRengi().String())

	// Hepsini siyaha boyayalım
	kutular.SiyahaBoya()

	fmt.Println("İkinci kutunun rengi", kutular[1].renk.String())
	fmt.Println("En büyüğü", kutular.EnBuyuklerininRengi().String())
}

Bazı sabitleri ve özelleştirilmiş tür/tipleri tanımlarız

  • Renk'i byte 'ın takma adı olarak kullanın.
  • Hacim, yukseklik, genislik, derinlik ve renk alanlarını içeren Kutu struct ını tanımlayın.
  • Kutu yu alanı olarak alan KutuListesi strruct ı tanımlayın.

Daha sonra özelleştirilmiş türlerimiz/tiplerimiz için bazı methodlar tanımladık.

  • Hacim() Kutu yu alıcısı olarak kullanır ve onun hacmini döndürür.
  • RenkAta(r Renk) Kutu'nun rengini değiştirir.
  • EnBuyuklerininRengi() en büyük hacimli Kutu'nun rengini döndürür.
  • SiyahaBoya() KutuListesi içindeki tüm Kutu'ların rengini SIYAH yapar.
  • String() Renk'i alıcısı olarak kullanır ve Renk adını string olarak döndürür.

Gereksinimlerimizi tanımlamak için kelimeler kullandığımız zaman daha açıklayıcı değil mi?

İşaretçiyi alıcı olarak kullanmak

RenkAta metoduna bir göz atalım. Alıcısı Kutunun bir işaretçisidir. Evet, *Kutuyu alıcı olarak kullanabilirsiniz. Neden burada bir işaretçi kullanıyoruz? Çünkü bu methodda Kutu'nun rengini değiştirmek istiyoruz. Dolayısıyla, bir işaretçi kullanmazsak, bu yalnızca Kutu'nun kopyasındaki değeri değiştirir.

Bir alıcının bir methodun ilk argümanı olduğunu görürsek, nasıl çalıştığını anlamak zor değildir.

Neden RenkAta() methodunda k.Renk = r yerine (*k).Renk = r kullanmadığımızı soruyor olabilirsiniz. Her iki kullanımda da sorun yok çünkü Go bu görevi nasıl gerçekleştireceğini bilir. Şimdi Go'nun daha büyüleyici olduğunu düşünmüyor musunuz?

Ayrıca SiyahaBoya methodunda da neden (&kl[i]).RenkAta(SIYAH) kullanıp kullanmamamız gerektiğini de sorabilirsiniz. Çünkü RenkAta methoduna bir işaretçi geçmişizdir zaten. Yine iki kullanımda Go için problem değil, ikisinin de nasıl yorumlanacağını bilir!

method kalıtımı

Son bölümde alanların kalıtımını öğrendik. Benzer şekilde Go'da method kalıtımı da vardır. Eğer anonim bir alanın methodları varsa, alanı içeren struct da ondaki tüm methodlara sahip olacaktır.

package main

import "fmt"

type Insan struct {
	ad  string
	yas   int
	telefon string
}

type Ogrenci struct {
	Insan  // anonymous field
	okul string
}

type Calisan struct {
	Insan
	sirket string
}

// Insan içinde bir method tanımı
func (i *Insan) Merhaba() {
	fmt.Printf("Merhaba, Benim adım %s. Bana %s nolu telefondan ulaşabilirsiniz.\n", i.ad, i.telefon)
}

func main() {
	murat := Calisan{Insan{"Murat", 45, "555 5555555"}, "Golang Inc"}
	adem := Ogrenci{Insan{"Adem", 25, "555 5555556"}, "MIT"}

	murat.Merhaba()
	adem.Merhaba()
}

Method Overriding

Eğer Calisan'ın kendi Merhaba methoduna sahip olmasını istiyorsak, Calisan'da aynı adı tasıyan bir method tanımlayabiliriz ve böylece Merhaba methodunu çağırdığımızda Insan içinde tanımlı olan method gizlenecektir.

package main

import "fmt"

type Insan struct {
	ad  string
	yas   int
	telefon string
}

type Ogrenci struct {
	Insan
	okul string
}

type Calisan struct {
	Insan
	sirket string
}

func (i *Insan) Merhaba() {
	fmt.Printf("Merhaba, Benim adım %s. Bana %s nolu telefondan ulaşabilirsiniz.\n", i.ad, i.telefon)
}

func (c *Calisan) Merhaba() {
	fmt.Printf("Merhaba, Benim adım %s, %s şirketinde çalışıyorum. Bana %s bu numaradan ulaşabilirsiniz.\n", c.ad,
		c.sirket, c.telefon) //Evet burada iki satıra ayırarak yazabilirsiniz.
}

func main() {
	murat := Calisan{Insan{"Murat", 45, "555 5555555"}, "Golang Inc"}
	adem := Ogrenci{Insan{"Adem", 25, "555 5555556"}, "MIT"}

	murat.Merhaba()
	adem.Merhaba()
}

Artık Nesne-yönelimli program yazabiliyorsunuz. methodların dışarıya açık olup olmayacağını(public/private) method isminin ilk harfini büyük/küçük yaparak sağlayabilirsiniz.

Links