Ví dụ 1: Golang Empty Interface
Bắt đầu với giao diện trống{} được gọi là giao diện trong Go. Nó chỉ ra một loại có thể lưu trữ bất kỳ loại giá trị nào. Sau đây là mã nguồn cho giao diện trống trong Go:
bưu kiện chủ yếunhập khẩu 'fmt'
kiểu Dấu Máy Tính giao diện {}
chức năng chủ yếu () {
đã từng là m MarksMáy tính
fmt . Println ( tôi )
}
Ở đây, chúng tôi cung cấp mã trong đó giao diện “MarksCalculator” không có bất kỳ chữ ký phương thức được chỉ định nào vì nó trống. Kết quả là, nó không cung cấp bất kỳ chức năng nào. Tiếp theo, chúng ta có hàm main() của giao diện trống này, nơi một biến “m” thuộc loại MarksCalculator được khai báo. Vì giao diện trống, nên “m” có thể chứa bất kỳ giá trị nào thuộc bất kỳ loại nào. Trong trường hợp này, “m” chưa được khởi tạo, do đó, nó có giá trị bằng 0 đối với loại của nó, giá trị “nil” đối với giao diện. Khi “m” được in bằng cách sử dụng “fmt.Println”, nó sẽ xuất “nil” ra bàn điều khiển.
Đầu ra được truy xuất là 'nil' như mong đợi từ mã nguồn trước đó:
Ví dụ 2: Golang Triển khai giao diện
Phần này trình bày việc triển khai giao diện Golang. Một loại phải cung cấp triển khai cho từng phương thức đã chỉ định trong một giao diện để triển khai nó trong Go. Sau đây là mã nguồn đã cho để triển khai giao diện:
bưu kiện chủ yếu
nhập khẩu (
'fmt'
)
kiểu nguyên âm giao diện {
tìm kiếm nguyên âm () [] chữ rune
}
kiểu MyStr sợi dây
chức năng ( st MyStr ) tìm kiếm nguyên âm () [] chữ rune {
đã từng là nguyên âm [] chữ rune
vì _ , chữ rune := phạm vi st {
nếu như chữ rune == 'Một' || chữ rune == 'Nó là' || chữ rune == 'Tôi' || chữ rune == 'O' || chữ rune == 'TRONG' {
nguyên âm = nối thêm ( nguyên âm , chữ rune )
}
}
trở lại nguyên âm
}
chức năng chủ yếu () {
Chuỗi mới := MyStr ( 'Giao diện GoLang' )
đã từng là nguyên âm v1
v1 = Chuỗi mới
fmt . inf ( 'Nguyên âm là %c' , v1 . tìm kiếm nguyên âm ())
}
Ở đây, mã định nghĩa một giao diện có tên là “Nguyên âm” chỉ định một phương thức duy nhất SearchVowels() trả về một lát của chữ rune (loại int32). Một giao diện cho phép bất kỳ loại nào triển khai chữ ký phương thức này được gán cho một biến của loại giao diện. Sau đó, một loại “MyStr” mới được khai báo là bí danh cho chuỗi loại bên dưới. Điều này có nghĩa là “MyStr” kế thừa tất cả các phương thức của chuỗi nhưng là một kiểu riêng biệt.
Sau đó, chúng tôi triển khai phương thức SearchVowels() cho loại “MyStr”. Phương thức này quét ký tự chuỗi đầu vào theo từng ký tự và kiểm tra xem mỗi ký tự có phải là một nguyên âm (“a”, “e”, “i”, “o” hoặc “u”). Nếu một ký tự là một nguyên âm, nó sẽ được thêm vào lát cắt nguyên âm.
Bên trong hàm main(), một biến “NewString” thuộc loại “MyStr” được tạo với giá trị “Giao diện GoLang”. Tiếp theo, một biến “v1” thuộc loại “Nguyên âm” được khai báo. Vì “MyStr” triển khai phương thức SearchVowels() được xác định trong giao diện “Vowels”, nên “NewString” có thể được gán cho “v1”.
Đầu ra hiển thị tất cả các mảng nguyên âm được tìm thấy trong chuỗi đã chỉ định:
Ví dụ 3: Giao diện Golang Stringer
Ngoài ra, Golang có giao diện “Stringer” được xác định trước trong gói “fmt”. Nó cho phép một loại tùy chỉnh kiểm soát biểu diễn chuỗi của nó khi được định dạng bằng động từ “%v” trong các chức năng in của gói “fmt”. Sau đây là mã ví dụ cho giao diện stringer của Go:
bưu kiện chủ yếunhập khẩu (
'fmt'
)
kiểu Học sinh cấu trúc {
Tên sợi dây
Bằng cấp sợi dây
}
chức năng ( sinh viên ) Sợi dây () sợi dây {
trở lại fmt . nước rút ( '%s là một(n) %s' , S . Tên , S . Bằng cấp )
}
chức năng chủ yếu () {
s1 := Học sinh { 'Elena gilbert' , 'Khoa học máy tính' }
s2 := Học sinh { 'Candice Caroline' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Ở đây, mã đầu tiên nhập gói cần thiết là “fmt” để in ra bàn điều khiển. Sau đó, chúng ta định nghĩa một kiểu cấu trúc “Sinh viên” với hai trường: “Tên” và “Bằng cấp”. Cấu trúc này đại diện cho thông tin của một sinh viên. Hơn nữa, một phương thức String() cho loại “Student” được tạo. Phương thức này có một bộ nhận kiểu “Student” và trả về một chuỗi. Phương thức “String()” là một phương thức đặc biệt trong Go được sử dụng để tùy chỉnh biểu diễn chuỗi của một đối tượng khi nó được in. Trong trường hợp này, phương thức “String()” định dạng và trả về một chuỗi bao gồm tên và bằng cấp của sinh viên.
Tiếp theo, chúng ta có hàm main() trong đó hai biến s1 và s2 kiểu “Sinh viên” được khai báo và khởi tạo với thông tin sinh viên. Cuối cùng, đoạn mã này sử dụng hàm fmt.Println() để in các giá trị của s1 và s2. Vì phương thức String() được định nghĩa cho kiểu “Student”, nên Go sẽ tự động gọi phương thức này khi in đối tượng “Student”. Phương thức String() định dạng thông tin của học sinh bằng cách sử dụng hàm “fmt.Sprintf()” và trả về chuỗi đã định dạng.
Đầu ra sau đây in đối tượng thuộc loại “Sinh viên” của giao diện stringer:
Ví dụ 4: Giao diện Golang Type Switch
Sau đó là giao diện chuyển đổi kiểu của Go. Công tắc loại là một cấu trúc điều khiển cho phép chúng ta kiểm tra loại động của một giá trị giao diện. Thực hiện theo mã nguồn của giao diện chuyển đổi loại:
bưu kiện chủ yếunhập khẩu 'fmt
func MyFunction(Giao diện F1{}) {
chuyển đổi F1.(loại) {
trường hợp int:
fmt.Println(' Kiểu : int , Giá trị : ', F1.(bạn))
chuỗi trường hợp:
fmt.Println(' \nLoại : sợi dây , Giá trị : ', F1.(chuỗi))
trường hợp float64:
fmt.Println(' \nLoại : phao64 , Giá trị : ', F1.(float64))
mặc định:
fmt.Println(' \nType không hợp lệ ')
}
}
hàm chính () {
MyFunction(' Hướng dẫn giao diện Golang ')
MyFunction(89.7)
Chức năng của tôi (đúng)
}
Tại đây, mã được cung cấp xác định hàm “MyFunction” nhận tham số “F1” của loại “giao diện{}”. Điều này chỉ ra rằng “F1” có thể chấp nhận một giá trị thuộc bất kỳ loại nào. Bên trong hàm, một câu lệnh switch được sử dụng với “F1.(type)” để kiểm tra loại giá trị được truyền cho “MyFunction”. Cú pháp “.(type)” được sử dụng trong chuyển đổi loại để lấy loại động cơ bản của giá trị giao diện. Lưu ý rằng các trường hợp chuyển đổi ở đây xử lý ba loại cụ thể: “int”, “string” và “float64”. Nếu loại “F1” phù hợp với một trong những trường hợp này. Nó in loại và giá trị tương ứng bằng cách sử dụng các xác nhận loại (F1.(int), F1.(string), F1.(float64)). Nếu loại “F1” không khớp với bất kỳ trường hợp nào đã xác định, thì trường hợp mặc định sẽ được thực thi và in ra “Loại không hợp lệ”.
Sau đó, trong hàm main(), “MyFunction” được gọi ba lần với các giá trị khác nhau: một chuỗi, một float64 và một Boolean (không được xử lý trong câu lệnh switch).
Đầu ra hiển thị bản trình diễn giao diện chuyển đổi với các xác nhận loại:
Ví dụ 5: Nhiều giao diện Golang
Hơn nữa, Go cung cấp nhiều giao diện cho phép nó cung cấp các nhóm hành vi khác nhau tùy thuộc vào ngữ cảnh. Tính năng này được gọi là “nhiều giao diện” hoặc “kết hợp giao diện”. Đoạn mã sau minh họa việc triển khai nhiều giao diện:
bưu kiện chủ yếunhập khẩu 'fmt'
kiểu chim giao diện {
thở ()
bay ()
}
kiểu gia cầm giao diện {
cho ăn ()
}
kiểu Ở đâu cấu trúc {
tuổi int
}
chức năng ( d ở đâu ) thở () {
fmt . Println ( 'Bồ câu thở' )
}
chức năng ( d ở đâu ) bay () {
fmt . Println ( 'Bồ câu bay' )
}
chức năng ( d ở đâu ) cho ăn () {
fmt . Println ( 'Bồ câu nuôi con' )
}
chức năng chủ yếu () {
đã từng là b chim
đ := Ở đâu {}
b = đ
b . thở ()
b . bay ()
đã từng là một loài chim
Một = đ
Một . cho ăn ()
}
Ở đây, chúng tôi xác định hai giao diện: “chim” và “avian”. Giao diện ‘birds” khai báo hai phương thức: Breath() và Fly(). Trong khi giao diện “avians” khai báo phương thức feed(). Sau đó, cấu trúc “dove” thực hiện tất cả các phương thức của cả giao diện “birds” và “avian”. Nó cung cấp các triển khai cho Breath(), Fly() và Feed().
Tiếp theo, chúng ta khai báo biến “b” của kiểu “chim” trong hàm main(). Một thể hiện của “chim bồ câu” được tạo và gán cho “b” bằng cách sử dụng phép gán b = d. Vì “chim bồ câu” thực hiện tất cả các phương thức của giao diện “chim”, nên nhiệm vụ này là hợp lệ.
Sau đó, các phương thức breath() và fly() được gọi trên “b” thuộc loại “birds”. Tương tự, một biến “a” thuộc loại “avians” được khai báo và gán với thể hiện “dove” của “d”. Vì “dove” triển khai phương thức feed() được xác định trong giao diện “avians”, nên phép gán này cũng hợp lệ. Phương thức feed() được gọi trên “a” thuộc loại “avian”. Khi “a” giữ đối tượng “dove”, phương thức feed() do “dove” triển khai sẽ được thực thi.
Đầu ra cho thấy các phương thức của giao diện được thực thi chính xác:
Phần kết luận
Chúng tôi đã tìm hiểu kiến thức cơ bản về giao diện Go và cung cấp các ví dụ thực tế để minh họa cách sử dụng chúng. Bằng cách xác định các giao diện và triển khai chúng với các loại khác nhau, chúng ta có thể tạo các chương trình linh hoạt và có thể mở rộng.