Inteface
Interface adalah sebuah tipe data yang Tak Mempunyai 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 Mau mengimplementasikan sebuah interface, kita harus Membikin sebuah tipe data yang Mempunyai deklarasi yang sama seperti interfacenya.
Contoh interface:
type Engine interface {
ShowName() string
Start() string
Stop() string
}
Pada Contoh tersebut kita Membikin sebuah interface Engine yang Mempunyai dua buah function Yakni Start dan Stop. Setelah interface dibuat, kita Bisa menggunakannya sebagai tipe data seperti Normal. 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 Mempunyai function Start dan Stop, maka kita Bisa menggunakan function tersebut dalam function CheckEngine.
Implementasi Interface
Metode mengimplementasikan interface di Golang agak sedikit berbeda dengan bahasa OOP lain. Dalam pemrograman berorientasi objek, kita harus secara eksplisit menyebutkan interface yang Mau kita implementasikan. Sedangkan di Golang, setiap tipe data yang sesuai (Mempunyai Segala method yang Eksis pada interface) dengan suatu interface akan secara Mekanis dianggap mengimplementasikan interface tersebut. Oleh karena itu, kita Tak perlu mengimplementasikan interface secara manual.
Berikut ini Contoh kodenya:
package main
import "fmt"
// Membikin interface engine
type Engine interface {
ShowName() string
Start() string
Stop() string
}
// Membikin 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())
}
// Membikin struct
type MyEngine struct {
Name string
}
// Membikin struct method Kepada ShowName
func (myEngine MyEngine) ShowName() string {
return myEngine.Name
}
// Membikin struct method Kepada Start
func (myEngine MyEngine) Start() string {
return "Engine start..."
}
// Membikin struct method Kepada 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 Mempunyai Segala method/function yang sama dengan
// interface Engine, maka secara Mekanis telah mengimplementasikan interface tersebut dan
// Bisa kita gunakan Kepada mengisi parameter pada function CheckEngine
CheckEngine(engine1)
}
output dari kode diatas Apabila dijalankan adalah sebagai berikut:
Engine name: V8
Check start engine: Engine start...
Check stop engine: Engine stop...
Interface Hampa
Sesuai dengan namanya, interface Hampa adalah sebuah interface yang Tak Mempunyai method apapun. Sebelumnya kita sudah Paham bahwa di dalam Golang, Segala tipe data yang sama dengan suatu interface akan secara Mekanis dianggap mengimplementasikan interface tersebut. Hal ini juga berlaku Kepada interface Hampa. Karena interface Hampa Tak Mempunyai method, maka secara Mekanis Segala tipe data akan mengimplementasikan interface Hampa.
Konsep interface Hampa ini Nyaris sama seperti bahasa OOP lain contohnya seperti Java. Ji dalam bahasa Java, terdapat sebuah class Penting: java.lang.Object yang merupakan parent/induk dari Segala class yang Eksis. Sedangkan di Golang, interface Hampa inilah yang menjadi induk dari Segala tipe data yang Eksis.
Secara sederhana, interface Hampa ini Bisa kita anggap sebagai tipe data apapun.
Penggunaan Interface Hampa
Banyak function bawaan Golang yang menggunakan interface Hampa. Salah satunya adalah function Println dari package fmt. Kalau Engkau Tetap 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 Hampa.
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:
Pada Contoh kode tersebut, kita Mempunyai sebuah function bernama ReturnAny yang Bisa mengembalikan Corak-Corak tipe data. Hal ini Bisa kita lakukan karena kita menggunakan interface Hampa pada tipe data kembaliannya. Kita Paham bahwa di Golang, Segala tipe data adalah turunan atau implementasi dari interface Hampa, sehingga string, 0, dan true dianggap tipe data yang sama.
Berikutnya: #32: Nil