Merge pull request astaxie#1098 from genc-murat/master

Added section 2.5(Object-oriented) Turkish translation

Author: astaxie

tr/02.4.md

@@ -211,4 +211,4 @@ func main() {
 
 - [Rehber](preface.md)
 - Önceki bölüm: [Kontrol ifadeleri ve fonksiyonlar](02.3.md)
-- Sonraki bölüm: [Object-oriented](02.5.md)
+- Sonraki bölüm: [Nesne-Yönelim](02.5.md)

tr/02.5.md

@@ -0,0 +1,321 @@
+# 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.
+```Go
+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.
+
+![](images/2.5.rect_func_without_receiver.png?raw=true)
+
+Ş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.
+```Go
+func (r ReceiverType) funcName(parameters) (results)
+```
+Örneğimizi `method` kullanarak değiştirelim.
+```Go
+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.
+
+![](images/2.5.shapes_func_with_receiver_cp.png?raw=true)
+
+Ş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.
+```Go
+type typeName typeLiteral
+```
+Özelleştirilmiş türler/tipler e örnekler:
+
+```Go
+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.
+```Go
+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, `*Kutu`yu 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.
+```Go
+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.
+```Go
+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
+
+- [Rehber](preface.md)
+- Önceki bölüm: [struct](02.4.md)
+- Sonraki bölüm: [interface](02.6.md)