Örnek 1: Golang Boş Arayüz
Go'da arayüz olarak adlandırılan boş arayüz{} ile başlayın. Her türlü değeri depolayabilen bir türü belirtir. Go'daki boş arayüzün kaynak kodu aşağıdadır:
paket anaiçe aktarmak 'fmt'
tip Puan Hesaplayıcı arayüz {}
işlev ana () {
öyleydi m Puan Hesaplayıcı
fmt . Yazdır ( M )
}
Burada, 'MarksCalculator' arayüzünün boş olduğu için belirtilen herhangi bir yöntem imzasının olmadığı kodu sağlıyoruz. Sonuç olarak, herhangi bir işlevsellik sağlamaz. Ardından, MarksCalculator türünde bir 'm' değişkeninin bildirildiği bu boş arabirimin main() işlevine sahibiz. Arayüz boş olduğundan, “m” herhangi bir türden herhangi bir değeri tutabilir. Bu durumda, 'm' sıfırlanmıştır, dolayısıyla türü için arayüzler için 'sıfır' olan sıfır değerine sahiptir. “fmt.Println” kullanılarak “m” yazdırıldığında, konsola “nil” çıktısı verir.
Alınan çıktı, önceki kaynak kodundan beklendiği gibi 'sıfır'dır:
Örnek 2: Arayüzün Golang Uygulaması
Bu bölüm, Golang arabiriminin uygulanmasını gösterir. Bir türün, Go'da uygulamak için belirtilen her yöntemin uygulamasını bir arabirimde sunması gerekir. Arayüz uygulaması için verilen kaynak kodu aşağıdadır:
paket ana
içe aktarmak (
'fmt'
)
tip Sesli harfler arayüz {
AraSesli harfler () [] rün
}
tip MyStr sicim
işlev ( st MyStr ) AraSesli harfler () [] rün {
öyleydi sesli harfler [] rün
için _ , rün := menzil st {
eğer rün == 'A' || rün == 'Bu' || rün == 'Ben' || rün == 'Ö' || rün == 'içinde' {
sesli harfler = eklemek ( sesli harfler , rün )
}
}
geri dönmek sesli harfler
}
işlev ana () {
YeniDize := MyStr ( 'GoLang Arayüzleri' )
öyleydi v1 Ünlüler
v1 = YeniDize
fmt . Yazdır ( 'Sesli harfler %c'dir' , v1 . AraSesli harfler ())
}
Burada kod, runenin bir dilimini döndüren (int32 yazın) SearchVowels() tek bir yöntemini belirten “Vowels” adlı bir arayüzü tanımlar. Bir arabirim, bu yöntem imzasını uygulayan herhangi bir türün arabirim türünün bir değişkenine atanmasını sağlar. Ardından, temel alınan tür dizesi için bir takma ad olan yeni bir 'MyStr' türü bildirilir. Bu, 'MyStr' dizgenin tüm yöntemlerini miras aldığı, ancak farklı bir tür olduğu anlamına gelir.
Ardından “MyStr” tipi için SearchVowels() methodunu uyguluyoruz. Bu yöntem, giriş dizesini karakter karakter tarar ve her karakterin sesli harf (“a”, “e”, “i”, “o” veya “u”) olup olmadığını kontrol eder. Bir karakter bir sesli harf ise, sesli harf dilimine eklenir.
main() fonksiyonu içerisinde “GoLang Interfaces” değeri ile “MyStr” türünde bir “NewString” değişkeni oluşturulur. Ardından, 'Ünlüler' türünde bir 'v1' değişkeni bildirilir. “MyStr”, “Vowels” arayüzünde tanımlanan SearchVowels() yöntemini uyguladığından, “NewString” “v1”e atanabilir.
Çıktı, belirtilen dizide bulunan tüm sesli harf dizisini görüntüler:
Örnek 3: Golang Stringer Arayüzü
Ek olarak Golang, 'fmt' paketinde önceden tanımlanmış 'Stringer' arayüzüne sahiptir. 'fmt' paketinin yazdırma işlevlerinde '%v' fiiliyle biçimlendirildiğinde, özel bir türün dize gösterimini kontrol etmesine izin verir. Go'nun stringer arabirimi için örnek kod aşağıdadır:
paket anaiçe aktarmak (
'fmt'
)
tip Öğrenci yapı {
İsim sicim
Derece sicim
}
işlev ( öğrenci ) Sicim () sicim {
geri dönmek fmt . Sprintf ( '%s, bir(n) %s'dir' , S . İsim , S . Derece )
}
işlev ana () {
s1 := Öğrenci { 'Elena Gilbert' , 'Bilgisayar Bilimi' }
s2 := Öğrenci { 'Carolin Candice' , 'BBA' }
fmt . Yazdır ( s1 )
fmt . Yazdır ( s2 )
}
Burada kod önce konsola yazdırmak için gerekli olan “fmt” paketini import eder. Ardından, iki alanlı bir yapı tipi “Öğrenci” tanımlarız: “Ad” ve “Derece”. Bu yapı bir öğrencinin bilgilerini temsil eder. Ayrıca, 'Öğrenci' türü için bir String() yöntemi oluşturulur. Bu yöntemin “Student” tipinde bir alıcısı vardır ve bir dizi döndürür. 'String()' yöntemi, yazdırıldığında bir nesnenin dize temsilini özelleştirmek için kullanılan Go'daki özel bir yöntemdir. Bu durumda, “String()” yöntemi, öğrencinin adını ve derecesini içeren bir diziyi biçimlendirir ve döndürür.
Ardından, 'Student' türünden s1 ve s2 olmak üzere iki değişkenin öğrenci bilgileriyle bildirildiği ve başlatıldığı main() işlevine sahibiz. Son olarak, kod s1 ve s2 değerlerini yazdırmak için fmt.Println() işlevini kullanır. 'Student' türü için String() yöntemi tanımlı olduğundan, Go, 'Student' nesnesini yazdırırken bu yöntemi otomatik olarak çağırır. String() yöntemi, 'fmt.Sprintf()' işlevini kullanarak öğrencinin bilgilerini biçimlendirir ve biçimlendirilmiş dizeyi döndürür.
Aşağıdaki çıktı, stringer arayüzünün 'Öğrenci' tipindeki nesneyi yazdırır:
Örnek 4: Golang Tipi Anahtar Arayüzü
Ardından Go'nun tip değiştirme arabirimi gelir. Tip anahtarı, bir arayüz değerinin dinamik tipini incelememizi sağlayan bir kontrol yapısıdır. Tip anahtarı arabiriminin kaynak kodunu izleyin:
paket anaiçe aktarmak 'fmt
func MyFunction(F1 arayüzü{}) {
anahtar F1.(tip) {
durum int:
fmt.Println(' Tip : int , Değer : ', F1.(siz))
durum dizisi:
fmt.Println(' \nTür : sicim , Değer : ', F1.(dize))
durum float64:
fmt.Println(' \nTür : şamandıra64 , Değer : ', F1.(float64))
varsayılan:
fmt.Println(' \nTür geçerli değil ')
}
}
ana fonksiyon() {
İşlevim(' Golang Arayüzleri Eğitimi ')
İşlevim(89.7)
İşlevim(doğru)
}
Burada sağlanan kod, 'interface{}' türünde bir 'F1' parametresi alan bir 'MyFunction' işlevini tanımlar. Bu, 'F1'in herhangi bir tür değeri kabul edebileceğini gösterir. Fonksiyon içinde, “F1.(type)” ile “MyFunction”a iletilen değerin tipini kontrol etmek için bir switch deyimi kullanılır. “.(type)” sözdizimi, bir arayüz değerinin temel dinamik tipini elde etmek için bir tip anahtarında kullanılır. Buradaki anahtar durumlarının üç özel türü ele aldığına dikkat edin: 'int', 'string' ve 'float64'. 'F1' tipi bu durumlardan biriyle eşleşirse. Tip iddialarını (F1.(int), F1.(string), F1.(float64)) kullanarak karşılık gelen tipi ve değeri yazdırır. 'F1' türü, tanımlanan durumların hiçbiriyle eşleşmiyorsa, 'Tür geçerli değil' yazan varsayılan durum yürütülür.
Bundan sonra, main() işlevi içinde 'MyFunction' farklı değerlerle üç kez çağrılır: bir dize, bir float64 ve bir Boolean (switch ifadesinde işlenmez).
Çıktı, tip iddialarıyla anahtar arayüzünün tanıtımını görüntüler:
Örnek 5: Golang Çoklu Arayüzleri
Ayrıca Go, bağlama bağlı olarak farklı davranış kümeleri sağlamasına izin veren birden çok arabirim sunar. Bu özelliğe “çoklu arayüz” veya “arayüz bileşimi” denir. Aşağıdaki kod, çoklu arabirim uygulamasını gösterir:
paket anaiçe aktarmak 'fmt'
tip kuşlar arayüz {
nefes almak ()
uçmak ()
}
tip kuşlar arayüz {
beslemek ()
}
tip Nerede yapı {
yaş int
}
işlev ( d nerede ) nefes almak () {
fmt . Yazdır ( 'Güvercin nefes alır' )
}
işlev ( d nerede ) uçmak () {
fmt . Yazdır ( 'güvercin uçar' )
}
işlev ( d nerede ) beslemek () {
fmt . Yazdır ( 'Güvercin yavruları besliyor' )
}
işlev ana () {
öyleydi b kuşlar
D := Nerede {}
B = D
B . nefes almak ()
B . uçmak ()
öyleydi bir kuş
A = D
A . beslemek ()
}
Burada iki arayüz tanımlıyoruz: 'kuşlar' ve 'kuşlar'. 'Kuşlar' arayüzü iki yöntem bildirir: Breath() ve fly(). “avians” arabirimi ise feed() yöntemini bildirir. Ardından, 'güvercin' yapısı hem 'kuşlar' hem de 'kuşlar' arabirimlerinin tüm yöntemlerini uygular. Breath(), fly() ve feed() için uygulamaları sağlar.
Daha sonra, main() fonksiyonu içinde “birds” tipinin “b” değişkenini bildiririz. Bir 'güvercin' örneği oluşturulur ve b = d ataması kullanılarak 'b' ye atanır. “güvercin”, “kuşlar” arayüzünün tüm yöntemlerini uyguladığından, bu atama geçerlidir.
Daha sonra “birds” türünden “b” üzerinde Breath() ve fly() metotları çağrılır. Benzer şekilde, “avians” tipi bir “a” değişkeni, “d” nin “güvercin” örneği ile bildirilir ve atanır. 'dove', 'avians' arayüzünde tanımlanan feed() yöntemini uyguladığı için bu atama da geçerlidir. feed() yöntemi, “avians” türünden “a” üzerinde çağrılır. “a”, “güvercin” örneğini tuttuğundan, “güvercin” tarafından uygulanan feed() yöntemi yürütülür.
Çıktı, arabirim yöntemlerinin doğru şekilde yürütüldüğünü gösterir:
Çözüm
Go arayüzlerinin temellerini öğrendik ve kullanımlarını göstermek için pratik örnekler sağladık. Arayüzleri tanımlayarak ve farklı tiplerle uygulayarak esnek ve genişletilebilir programlar oluşturabiliriz.