Inteface
Interface adalah sebuah tipe data yang tidak memiliki implementasi secara langsung (abstrak). Pada sebuah inteface terdapat definisi-definisi function/method. Dalam pemrograman berorientasi objek, interface biasanya diimplementasikan pada sebuah class. Sedangkan di Golang, interface biasanya diimplementasikan pada struct.
Ketika kita ingin mengimplementasikan sebuah interface, kita harus membuat sebuah tipe data yang memiliki deklarasi yang sama seperti interfacenya.
Contoh interface:
type Engine interface {
ShowName() string
Start() string
Stop() string
}
Pada contoh tersebut kita membuat sebuah interface Engine yang memiliki dua buah function yaitu Start dan Stop. Setelah interface dibuat, kita bisa menggunakannya sebagai tipe data seperti biasa. Berikut ini contohnya:
package main
type Engine interface {
ShowName() string
Start() string
Stop() string
}
func CheckEngine(engine Engine) {
fmt.Println("Engine name:", engine.ShowName())
fmt.Println("Check start engine:", engine.Start())
fmt.Println("Check stop engine:", engine.Stop())
}
Dari contoh kode di atas, kita menggunakan interface Engine sebagai tipe data parameter engine di function CheckEngine. Karena interface Engine memiliki function Start dan Stop, maka kita bisa menggunakan function tersebut dalam function CheckEngine.
Implementasi Interface
Cara mengimplementasikan interface di Golang agak sedikit berbeda dengan bahasa OOP lain. Dalam pemrograman berorientasi objek, kita harus secara eksplisit menyebutkan interface yang ingin kita implementasikan. Sedangkan di Golang, setiap tipe data yang sesuai (memiliki semua method yang ada pada interface) dengan suatu interface akan secara otomatis dianggap mengimplementasikan interface tersebut. Oleh karena itu, kita tidak perlu mengimplementasikan interface secara manual.
Berikut ini contoh kodenya:
package main
import "fmt"
// Membuat interface engine
type Engine interface {
ShowName() string
Start() string
Stop() string
}
// Membuat function yang menerima parameter engine
func CheckEngine(engine Engine) {
fmt.Println("Engine name:", engine.ShowName())
fmt.Println("Check start engine:", engine.Start())
fmt.Println("Check stop engine:", engine.Stop())
}
// Membuat struct
type MyEngine struct {
Name string
}
// Membuat struct method untuk ShowName
func (myEngine MyEngine) ShowName() string {
return myEngine.Name
}
// Membuat struct method untuk Start
func (myEngine MyEngine) Start() string {
return "Engine start..."
}
// Membuat struct method untuk Stop
func (myEngine MyEngine) Stop() string {
return "Engine stop..."
}
func main() {
// Mendeklarasikan variabel engine1 bertipe struct MyEngine
var engine1 MyEngine
engine1.Name = "V8"
// karena MyEngine sudah memiliki semua method/function yang sama dengan
// interface Engine, maka secara otomatis telah mengimplementasikan interface tersebut dan
// bisa kita gunakan untuk mengisi parameter pada function CheckEngine
CheckEngine(engine1)
}
output dari kode diatas jika dijalankan adalah sebagai berikut:
Engine name: V8
Check start engine: Engine start...
Check stop engine: Engine stop...
Interface Kosong
Sesuai dengan namanya, interface kosong adalah sebuah interface yang tidak memiliki method apapun. Sebelumnya kita sudah tahu bahwa di dalam Golang, semua tipe data yang sama dengan suatu interface akan secara otomatis dianggap mengimplementasikan interface tersebut. Hal ini juga berlaku untuk interface kosong. Karena interface kosong tidak memiliki method, maka secara otomatis semua tipe data akan mengimplementasikan interface kosong.
Konsep interface kosong ini hampir sama seperti bahasa OOP lain contohnya seperti Java. Ji dalam bahasa Java, terdapat sebuah class utama: java.lang.Object yang merupakan parent/induk dari semua class yang ada. Sedangkan di Golang, interface kosong inilah yang menjadi induk dari semua tipe data yang ada.
Secara sederhana, interface kosong ini bisa kita anggap sebagai tipe data apapun.
Penggunaan Interface Kosong
Banyak function bawaan Golang yang menggunakan interface kosong. Salah satunya adalah function Println dari package fmt. Kalau kamu masih ingat di materi-materi sebelumnya, kita sudah beberapa kali menggunakan function Println yang kita isi dengan data number, string, struct, dan lain-lain. Hal ini bisa kita lakukan karena memang tipe data pada parameter function Println adalah sebuah interface kosong.
Contoh kode:
package main
import "fmt"
func ReturnAny(i int) interface{} {
if i == 1 {
return "string"
} else if i == 2 {
return 0
} else {
return true
}
}
func main() {
// kembali tipe data string
fmt.Println(ReturnAny(1))
// kembali tipe data number
fmt.Println(ReturnAny(2))
// kembali tipe data boolean
fmt.Println(ReturnAny(3))
}
output:
string
0
true
Pada contoh kode tersebut, kita memiliki sebuah function bernama ReturnAny yang bisa mengembalikan macam-macam tipe data. Hal ini bisa kita lakukan karena kita menggunakan interface kosong pada tipe data kembaliannya. Kita tahu bahwa di Golang, semua tipe data adalah turunan atau implementasi dari interface kosong, sehingga string, 0, dan true dianggap tipe data yang sama.
Berikutnya: #32: Nil