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, fonksiyonlar benzer bir sözdizimi vardı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 yerine doğrudan Dikdortgen'e aittir. Daha spesifik olarak, `yukseklik`, `genislik` ve `Alan()` hepsi Dikdortgen'e aittir.
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.
Figure 2.9 Methodlar farklı struct larda farklıdırlar.
Şekil 2.9 Methodlar farklı struct larda farklıdırlar.
Yukarıdaki örnakte Alan() methodu hem Dikdortgen hem de Daire'de mevcuttur, bu nedenle alıcıları Dikdortgen ve Daire'dir.
Yukarıdaki örnekte Alan() methodu hem Dikdortgen hem de Daire'de mevcuttur, bu nedenle alıcıları Dikdortgen ve Daire'dir.
One thing that's worth noting is that the method with a dotted line means the receiver is passed by value, not by reference. The difference between them is that a method can change its receiver's values when the receiver is passed by reference, and it gets a copy of the receiver when the receiver is passed by value.
Ö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.
...
...
@@ -200,7 +200,7 @@ func main() {
fmt.Println("En büyük kutu", kutular.EnBuyuklerininRengi().String())
Bazı sabitleri ve özelleştirilmiş tür/tipleri tanımlarız
-`Renk`'i `byte` 'ın takma adı olarak kullanın.
-`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.
...
...
@@ -231,88 +231,88 @@ Bir alıcının bir methodun ilk argümanı olduğunu görürsek, nasıl çalı
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?
You may also be asking whether we should use `(&kl[i]).RenkAta(SIYAH)` in `SiyahaBoya` because we pass a pointer to `RenkAta`. Again, either one is OK because Go knows how to interpret it!
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!
### Inheritance of method
### method kalıtımı
We learned about inheritance of fields in the last section. Similarly, we also have method inheritance in Go. If an anonymous field has methods, then the struct that contains the field will have all the methods from it as well.
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 Human struct {
name string
age int
phone string
type Insan struct {
ad string
yas int
telefon string
}
type Student struct {
Human // anonymous field
school string
type Ogrenci struct {
Insan // anonymous field
okul string
}
type Employee struct {
Human
company string
type Calisan struct {
Insan
sirket string
}
// define a method in Human
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
// 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() {
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
murat := Calisan{Insan{"Murat", 45, "555 5555555"}, "Golang Inc"}
If we want Employee to have its own method `SayHi`, we can define a method that has the same name in Employee, and it will hide `SayHi` in Human when we call it.
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 Human struct {
name string
age int
phone string
type Insan struct {
ad string
yas int
telefon string
}
type Student struct {
Human
school string
type Ogrenci struct {
Insan
okul string
}
type Employee struct {
Human
company string
type Calisan struct {
Insan
sirket string
}
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
func (i *Insan) Merhaba() {
fmt.Printf("Merhaba, Benim adım %s. Bana %s nolu telefondan ulaşabilirsiniz.\n", i.ad, i.telefon)
}
func (e *Employee) SayHi() {
fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
e.company, e.phone) //Yes you can split into 2 lines here.
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() {
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
murat := Calisan{Insan{"Murat", 45, "555 5555555"}, "Golang Inc"}
You are able to write an Object-oriented program now, and methods use rule of capital letter to decide whether public or private as well.
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.
