Mendefinisikan dan Mengimplementasikan Interface
Pemenuhan implisit dan interface kosong
Mendefinisikan dan Mengimplementasikan Interface adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.
Apa Itu Antarmuka
Antarmuka dalam Go adalah sekumpulan tanda tangan metode. Tipe apa pun yang mengimplementasikan semua metode tersebut secara implisit memenuhi antarmuka — tidak diperlukan kata kunci implements. Hal ini disebut pengetikan struktural atau pengetikan berdasarkan perilaku.
Mendeklarasikan Antarmuka
Tentukan antarmuka dengan kata kunci type:
package main
import "fmt"
type Shape interface {
Area() float64
Perimeter() float64
}
type Circle struct{ Radius float64 }
func (c Circle) Area() float64 { return 3.14159 * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * 3.14159 * c.Radius }
func main() {
var s Shape = Circle{5}
fmt.Printf("Area: %.2f\n", s.Area())
}Pemenuhan Implisit
Tidak diperlukan deklarasi maksud. Jika suatu tipe memiliki metode yang tepat, tipe tersebut otomatis memenuhi antarmuka:
package main
import "fmt"
type Greeter interface{ Greet() string }
type English struct{}
func (e English) Greet() string { return "Hello" }
type Spanish struct{}
func (s Spanish) Greet() string { return "Hola" }
func say(g Greeter) { fmt.Println(g.Greet()) }
func main() {
say(English{})
say(Spanish{})
}Antarmuka Kosong
interface{} (atau any dalam Go 1.18+) dipenuhi oleh setiap tipe. Antarmuka ini digunakan ketika tipe belum diketahui saat kompilasi:
package main
import "fmt"
func printAny(v any) { fmt.Printf("%T: %v\n", v, v) }
func main() {
printAny(42)
printAny("hello")
printAny([]int{1,2,3})
}Nilai Antarmuka
Nilai antarmuka menyimpan dua hal: tipe konkret dan nilai konkret. Antarmuka nil memiliki keduanya bernilai nil:
package main
import "fmt"
type Animal interface{ Sound() string }
type Dog struct{}
func (d Dog) Sound() string { return "woof" }
func main() {
var a Animal
fmt.Println(a == nil) // true
a = Dog{}
fmt.Println(a == nil) // false
fmt.Println(a.Sound())
}Pemenuhan Beberapa Antarmuka
Suatu tipe dapat memenuhi beberapa antarmuka secara bersamaan:
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(string) }
type ReadWriter interface{ Reader; Writer }
type File struct{ content string }
func (f *File) Read() string { return f.content }
func (f *File) Write(s string) { f.content = s }
func main() {
var rw ReadWriter = &File{}
rw.Write("hello")
fmt.Println(rw.Read())
}Penetapan Antarmuka
Antarmuka yang lebih luas dapat menyimpan nilai konkret yang lebih khusus. Penetapan antara tipe antarmuka mengharuskan tipe konkretnya memenuhi keduanya:
package main
import "fmt"
type Stringer interface{ String() string }
type Point struct{ X, Y int }
func (p Point) String() string { return fmt.Sprintf("(%d,%d)", p.X, p.Y) }
func main() {
var s Stringer = Point{3, 4}
fmt.Println(s.String())
}Jebakan Antarmuka Nil
Antarmuka yang tidak nil dan menyimpan nilai konkret nil adalah NOT sama dengan nil:
package main
import "fmt"
type MyErr struct{}
func (e *MyErr) Error() string { return "oops" }
func bad() error {
var e *MyErr // nil pointer
return e // returns non-nil interface!
}
func main() {
err := bad()
fmt.Println(err == nil) // false — common gotcha
}Antarmuka Memungkinkan Pengujian
Mendefinisikan dependensi sebagai antarmuka memungkinkan penggantian implementasi nyata dengan tiruan dalam pengujian:
package main
import "fmt"
type EmailSender interface{ Send(to, body string) error }
type MockSender struct{ Sent []string }
func (m *MockSender) Send(to, body string) error {
m.Sent = append(m.Sent, to)
return nil
}
func notify(s EmailSender, addr string) { s.Send(addr, "hello") }
func main() {
mock := &MockSender{}
notify(mock, "a@b.com")
fmt.Println(mock.Sent) // [a@b.com]
}Terima Antarmuka, Kembalikan Struktur
Praktik terbaik Go: parameter fungsi sebaiknya berupa antarmuka (demi fleksibilitas), sedangkan tipe kembalian sebaiknya berupa tipe konkret (agar pemanggil mengetahui hasil yang diperoleh):
package main
type Logger interface{ Log(string) }
type FileLogger struct{}
func (f *FileLogger) Log(s string) {}
func NewFileLogger() *FileLogger { // returns concrete
return &FileLogger{}
}
func process(l Logger) {} // accepts interface
func main() { process(NewFileLogger()) }Buat Antarmuka Tetap Kecil
Pustaka standar Go mengutamakan antarmuka yang sangat kecil: io.Reader memiliki satu metode, dan io.Writer juga memiliki satu metode. Antarmuka kecil lebih mudah dikomposisikan dan dibuat tiruannya.
Pemeriksaan Singkat
Apakah suatu tipe perlu mendeklarasikan bahwa tipe tersebut mengimplementasikan antarmuka?
Rangkuman: Antarmuka
Hal-hal penting:
- Antarmuka mendefinisikan perilaku, bukan data
- Pemenuhan bersifat implisit — tidak ada kata kunci
implements - Antarmuka kosong (
any) menerima setiap tipe - Waspadai jebakan antarmuka nil
- Jaga agar antarmuka tetap kecil dan terfokus
Tugas Latihan
Tentukan antarmuka Storage dengan Save(key, value string) error dan Load(key string) (string, error). Implementasikan dengan MemStorage yang didukung oleh peta, lalu uji hasilnya.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Mendefinisikan dan Mengimplementasikan Interface” gratis?
Ya — teks lengkap “Mendefinisikan dan Mengimplementasikan Interface” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Mendefinisikan dan Mengimplementasikan Interface”?
Pemenuhan implisit dan interface kosong Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Go Academy?
Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.
Berapa lama pelajaran “Mendefinisikan dan Mengimplementasikan Interface” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?
Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Mendefinisikan dan Mengimplementasikan Interface
- Interface Pustaka Standar Inti
- Asersi Tipe dan Switch Tipe
- Komposisi Interface dan Praktik Terbaik