Contoh 1: Antarmuka Kosong Golang
Mulailah dengan antarmuka kosong{} yang disebut sebagai antarmuka di Go. Ini menunjukkan tipe yang dapat menyimpan segala jenis nilai. Berikut ini adalah kode sumber untuk antarmuka kosong di Go:
kemasan utamaimpor 'fmt'
jenis Marks Calculator antarmuka {}
fungsi utama () {
dulu m Kalkulator Tanda
fmt . Println ( M )
}
Di sini, kami menyediakan kode di mana antarmuka 'MarksCalculator' tidak memiliki tanda tangan metode tertentu karena kosong. Akibatnya, itu tidak menyediakan fungsionalitas apa pun. Selanjutnya, kita memiliki fungsi main() dari antarmuka kosong ini di mana variabel “m” bertipe MarksCalculator dideklarasikan. Karena antarmuka kosong, 'm' dapat menampung nilai apa pun dari jenis apa pun. Dalam hal ini, 'm' tidak diinisialisasi, sehingga memiliki nilai nol untuk jenisnya yang merupakan 'nihil' untuk antarmuka. Ketika “m” dicetak menggunakan “fmt.Println” itu menghasilkan “nil” ke konsol.
Keluaran yang diambil adalah 'nihil' seperti yang diharapkan dari kode sumber sebelumnya:
Contoh 2: Implementasi Antarmuka Golang
Bagian ini mendemonstrasikan implementasi antarmuka Golang. Suatu tipe harus menawarkan implementasi untuk setiap metode yang ditentukan dalam antarmuka agar dapat mengimplementasikannya di Go. Berikut ini adalah kode sumber untuk implementasi antarmuka:
kemasan utama
impor (
'fmt'
)
jenis Vokal antarmuka {
Cari Vokal () [] sajak
}
jenis MyStr rangkaian
fungsi ( st MyStr ) Cari Vokal () [] sajak {
dulu vokal [] sajak
untuk _ , sajak := jangkauan st {
jika sajak == 'A' || sajak == 'Dia' || sajak == 'Saya' || sajak == 'HAI' || sajak == 'di dalam' {
vokal = menambahkan ( vokal , sajak )
}
}
kembali vokal
}
fungsi utama () {
String Baru := MyStr ( 'Antarmuka GoLang' )
dulu v1 Vokal
v1 = String Baru
fmt . Cetakf ( 'Vokal adalah %c' , v1 . Cari Vokal ())
}
Di sini, kode mendefinisikan antarmuka bernama 'Vokal' yang menentukan satu metode SearchVowels() yang mengembalikan potongan rune (ketik int32). Antarmuka memungkinkan tipe apa pun yang mengimplementasikan tanda tangan metode ini untuk ditugaskan ke variabel tipe antarmuka. Kemudian, tipe 'MyStr' baru dideklarasikan yang merupakan alias untuk string tipe yang mendasarinya. Ini berarti bahwa 'MyStr' mewarisi semua metode string tetapi merupakan tipe yang berbeda.
Setelah itu, kami mengimplementasikan metode SearchVowels() untuk tipe “MyStr”. Metode ini memindai karakter string input demi karakter dan memeriksa apakah setiap karakter adalah vokal (“a”, “e”, “i”, “o”, atau “u”). Jika sebuah karakter adalah vokal, itu ditambahkan ke potongan vokal.
Di dalam fungsi main(), variabel “NewString” dari tipe “MyStr” dibuat dengan nilai “GoLang Interfaces”. Selanjutnya, variabel “v1” bertipe “Vokal” dideklarasikan. Karena 'MyStr' mengimplementasikan metode SearchVowels() yang didefinisikan dalam antarmuka 'Vokal', 'NewString' dapat ditetapkan ke 'v1'.
Output menampilkan semua larik vokal yang ditemukan dalam string yang ditentukan:
Contoh 3: Antarmuka Golang Stringer
Selain itu, Golang memiliki antarmuka 'Stringer' yang telah ditentukan sebelumnya dalam paket 'fmt'. Ini memungkinkan tipe kustom untuk mengontrol representasi stringnya ketika diformat dengan kata kerja “%v” dalam fungsi pencetakan paket “fmt”. Berikut ini adalah contoh kode untuk antarmuka stringer dari Go:
kemasan utamaimpor (
'fmt'
)
jenis Murid struct {
Nama rangkaian
Derajat rangkaian
}
fungsi ( Siswa ) Rangkaian () rangkaian {
kembali fmt . Sprintf ( '%s adalah (n)%s' , S . Nama , S . Derajat )
}
fungsi utama () {
s1 := Murid { 'Elena Gilbert' , 'Ilmu Komputer' }
s2 := Murid { 'Carolina Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Di sini, kode terlebih dahulu mengimpor paket yang diperlukan yaitu 'fmt' untuk dicetak ke konsol. Kemudian, kita mendefinisikan tipe struct 'Student' dengan dua field: 'Name' dan 'Degree'. Struktur ini mewakili informasi siswa. Selanjutnya, metode String() untuk tipe “Student” dibuat. Metode ini memiliki penerima tipe 'Student' dan mengembalikan sebuah string. Metode “String()” adalah metode khusus di Go yang digunakan untuk menyesuaikan representasi string dari suatu objek saat dicetak. Dalam hal ini, metode “String()” memformat dan mengembalikan string yang menyertakan nama dan gelar siswa.
Selanjutnya, kita memiliki fungsi main() di mana dua variabel, s1 dan s2 bertipe “Student”, dideklarasikan dan diinisialisasi dengan informasi mahasiswa. Terakhir, kode menggunakan fungsi fmt.Println() untuk mencetak nilai s1 dan s2. Karena metode String() didefinisikan untuk tipe “Student”, Go secara otomatis memanggil metode ini saat mencetak objek “Student”. Metode String() memformat informasi siswa menggunakan fungsi “fmt.Sprintf()” dan mengembalikan string yang telah diformat.
Output berikut mencetak objek dari tipe 'Student' dari antarmuka stringer:
Contoh 4: Antarmuka Sakelar Tipe Golang
Kemudian muncul antarmuka sakelar tipe Go. Sakelar tipe adalah struktur kontrol yang memungkinkan kita untuk memeriksa tipe dinamis dari nilai antarmuka. Ikuti kode sumber antarmuka sakelar tipe:
kemasan utamaimpor 'fmt
func MyFunction(antarmuka F1{}) {
beralih F1.(tipe) {
kasus int:
fmt.Println(' Jenis : int , Nilai : ', F1.(kamu))
rangkaian kasus:
fmt.Println(' \nKetik : rangkaian , Nilai : ', F1.(string))
kasus mengapung64:
fmt.Println(' \nKetik : float64 , Nilai : ', F1.(float64))
bawaan:
fmt.Println(' \nJenis tidak valid ')
}
}
func main() {
Fungsiku(' Tutorial Antarmuka Golang ')
Fungsiku(89.7)
Fungsiku (benar)
}
Di sini, kode yang diberikan mendefinisikan fungsi “MyFunction” yang mengambil parameter “F1” dari tipe “interface{}”. Ini menunjukkan bahwa 'F1' dapat menerima nilai dari jenis apa pun. Di dalam fungsi, pernyataan switch digunakan dengan 'F1.(type)' untuk memeriksa jenis nilai yang diteruskan ke 'MyFunction'. Sintaks '.(type)' digunakan dalam saklar tipe untuk mendapatkan tipe dinamis yang mendasari nilai antarmuka. Perhatikan bahwa sakelar kasus di sini menangani tiga jenis khusus: 'int', 'string', dan 'float64'. Jika tipe 'F1' cocok dengan salah satu dari kasus ini. Itu mencetak tipe dan nilai yang sesuai menggunakan pernyataan tipe (F1.(int), F1.(string), F1.(float64)). Jika tipe 'F1' tidak cocok dengan case yang ditentukan, case default dijalankan yang mencetak 'Tipe tidak valid'.
Setelah itu, di dalam fungsi main(), “MyFunction” dipanggil tiga kali dengan nilai yang berbeda: string, float64, dan Boolean (yang tidak ditangani dalam pernyataan switch).
Keluaran menampilkan demonstrasi antarmuka sakelar dengan pernyataan tipe:
Contoh 5: Beberapa Antarmuka Golang
Selain itu, Go menawarkan banyak antarmuka yang memungkinkannya menyediakan serangkaian perilaku yang berbeda tergantung pada konteksnya. Fitur ini disebut 'beberapa antarmuka' atau 'komposisi antarmuka'. Kode berikut menunjukkan implementasi beberapa antarmuka:
kemasan utamaimpor 'fmt'
jenis burung-burung antarmuka {
bernapas ()
terbang ()
}
jenis avians antarmuka {
memberi makan ()
}
jenis Di mana struct {
usia int
}
fungsi ( d mana ) bernapas () {
fmt . Println ( 'Merpati bernafas' )
}
fungsi ( d mana ) terbang () {
fmt . Println ( 'Merpati terbang' )
}
fungsi ( d mana ) memberi makan () {
fmt . Println ( 'Dove mengasuh bayi' )
}
fungsi utama () {
dulu b burung
D := Di mana {}
B = D
B . bernapas ()
B . terbang ()
dulu seekor burung
A = D
A . memberi makan ()
}
Di sini, kami mendefinisikan dua antarmuka: 'burung' dan 'unggas'. Antarmuka 'burung' mendeklarasikan dua metode: bernapas() dan terbang(). Sedangkan interface “avians” mendeklarasikan metode feed(). Kemudian, struct 'dove' mengimplementasikan semua metode antarmuka 'birds' dan 'avians'. Ini menyediakan implementasi untuk breath(), fly(), dan feed().
Selanjutnya, kita mendeklarasikan variabel “b” bertipe “birds” di dalam fungsi main(). Instance dari 'merpati' dibuat dan ditugaskan ke 'b' menggunakan penugasan b = d. Karena “dove” mengimplementasikan semua metode antarmuka “birds”, tugas ini valid.
Kemudian, metode breath() dan fly() dipanggil pada “b” yang bertipe “birds”. Demikian pula, variabel 'a' dari tipe 'unggas' dideklarasikan dan ditetapkan dengan turunan 'merpati' dari 'd'. Karena “dove” mengimplementasikan metode feed() yang didefinisikan dalam antarmuka “avians”, penetapan ini juga valid. Metode feed() dipanggil pada “a” yang bertipe “avians”. Karena 'a' menyimpan instance 'dove', metode feed() yang diimplementasikan oleh 'dove' akan dieksekusi.
Keluaran menunjukkan bahwa metode antarmuka dijalankan dengan benar:
Kesimpulan
Kami mempelajari dasar-dasar antarmuka Go dan memberikan contoh praktis untuk mengilustrasikan penggunaannya. Dengan mendefinisikan antarmuka dan mengimplementasikannya dengan tipe yang berbeda, kita dapat membuat program yang fleksibel dan dapat diperluas.