การเลื่อนระดับเมธอด
สืบทอดเมธอดผ่านการฝัง
การเลื่อนระดับเมธอด เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
สืบทอดเมธอดผ่านการฝัง
เมื่อคุณฝังชนิดข้อมูล เมธอดของชนิดนั้นจะถูกเลื่อนขึ้นมาด้วย ชนิดข้อมูลภายนอกจึงเรียกใช้เมธอดเหล่านั้นได้ราวกับว่าเป็นผู้กำหนดเอง ซึ่งเป็นรูปแบบการสืบทอดของ Go
เมธอดที่ถูกเลื่อนขึ้น
Car ฝัง Engine และได้รับเมธอด Start มาใช้งานโดยไม่ต้องเขียนเพิ่ม
package main
import "fmt"
type Engine struct{}
func (Engine) Start() { fmt.Println("engine started") }
type Car struct{ Engine }
func main() {
c := Car{}
c.Start()
}เมธอดทำงานกับค่าที่ฝังอยู่
เมธอดที่ถูกเลื่อนขึ้นจะทำงานกับฟิลด์ที่ ฝังอยู่ ไม่ใช่สตรักต์ภายนอก เมธอดดังกล่าวจึงมองไม่เห็นฟิลด์อื่นของสตรักต์ภายนอก
package main
import "fmt"
type Counter struct{ n int }
func (c *Counter) Inc() { c.n++ }
func (c Counter) Get() int { return c.n }
type Widget struct{ Counter }
func main() {
w := Widget{}
w.Inc()
w.Inc()
fmt.Println(w.Get())
}การเขียนทับเมธอด
กำหนดเมธอดที่มีชื่อเดียวกันบนสตรักต์ภายนอกเพื่อ เขียนทับเมธอดที่ถูกเลื่อนขึ้น เมธอดของสตรักต์ภายนอกจะมีสิทธิ์เหนือกว่า
package main
import "fmt"
type Animal struct{}
func (Animal) Speak() string { return "..." }
type Dog struct{ Animal }
func (Dog) Speak() string { return "Woof" }
func main() {
fmt.Println(Dog{}.Speak())
}การเรียกใช้เวอร์ชันที่ฝังอยู่
แม้จะเขียนทับเมธอดแล้ว คุณก็ยังเข้าถึงเมธอดเดิมผ่านชื่อชนิดข้อมูลที่ฝังอยู่ได้
package main
import "fmt"
type Animal struct{}
func (Animal) Speak() string { return "generic" }
type Dog struct{ Animal }
func (d Dog) Speak() string { return "Woof + " + d.Animal.Speak() }
func main() {
fmt.Println(Dog{}.Speak())
}การเลื่อนเมธอดขึ้นกับอินเทอร์เฟซ
เนื่องจากเมธอดที่ถูกเลื่อนขึ้นเป็นส่วนหนึ่งของชุดเมธอดของชนิดข้อมูลภายนอก ชนิดข้อมูลภายนอกจึงสอดคล้องกับอินเทอร์เฟซได้โดยใช้เมธอดของชนิดข้อมูลที่ฝังอยู่
package main
import "fmt"
type Stringer interface{ String() string }
type Base struct{ name string }
func (b Base) String() string { return b.name }
type Wrapper struct{ Base }
func main() {
var s Stringer = Wrapper{Base{"hi"}}
fmt.Println(s.String())
}ชุดเมธอดของพอยน์เตอร์เทียบกับค่า
หากชนิดข้อมูลที่ฝังมีเมธอดที่ใช้ตัวรับพอยน์เตอร์ เฉพาะพอยน์เตอร์ที่ชี้ไปยังสตรักต์ภายนอก หรือค่าที่ระบุตำแหน่งได้เท่านั้น ที่จะได้รับเมธอดเหล่านั้นในชุดเมธอดของตน
การฝังเพื่อพฤติกรรมเริ่มต้น
ฝังชนิดข้อมูลที่มีเมธอดเริ่มต้นเหมาะสม แล้วเขียนทับเฉพาะไม่กี่เมธอดที่ต้องปรับแต่ง ซึ่งเป็นรูปแบบการใช้ซ้ำที่ทรงพลัง
package main
import "fmt"
type DefaultHandler struct{}
func (DefaultHandler) Handle() string { return "default" }
type CustomHandler struct{ DefaultHandler }
func (CustomHandler) Handle() string { return "custom" }
func main() {
fmt.Println(CustomHandler{}.Handle())
}ไม่มีพหุรูปแบบอย่างแท้จริง
ต่างจากการเขียนโปรแกรมเชิงวัตถุแบบดั้งเดิม เมธอดที่ฝังอยู่จะ ไม่ส่งการเรียกกลับไปยังเมธอดที่เขียนทับในสตรักต์ภายนอก Go ไม่มีการเลือกเรียกเมธอดเสมือนผ่านการฝัง
การเลื่อนขึ้นผ่านหลายระดับ
เมธอดจะถูกเลื่อนขึ้นต่อเนื่องกัน กล่าวคือ หาก A ฝัง B และ B ฝัง C, A ก็จะได้รับเมธอดของ C ด้วย ตราบใดที่ไม่มีความกำกวม
เมื่อการเลื่อนเมธอดขึ้นมีประโยชน์
- ใช้พฤติกรรมซ้ำโดยไม่ต้องเขียนใหม่
- ให้พฤติกรรมเริ่มต้นที่สามารถเขียนทับได้
- ทำให้อินเทอร์เฟซใช้งานได้ผ่านเมธอดที่ฝังอยู่
ตรวจสอบอย่างรวดเร็ว
ทดสอบความรู้เกี่ยวกับการเลื่อนเมธอดขึ้น
สรุป
คุณได้เรียนรู้การเลื่อนเมธอดขึ้นแล้ว
- เมธอดที่ฝังอยู่จะถูกเลื่อนขึ้นมายังชนิดข้อมูลภายนอก
- เมธอดของสตรักต์ภายนอกจะเขียนทับเมธอดที่ถูกเลื่อนขึ้น
- เข้าถึงเมธอดเดิมผ่านชื่อชนิดข้อมูลที่ฝังอยู่
- การเลื่อนเมธอดขึ้นช่วยให้อินเทอร์เฟซใช้งานได้ แต่ไม่มีการเลือกเรียกเมธอดเสมือน
เรียนรู้ Go ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 51
- บทเรียน
- 203
คำถามที่พบบ่อย
บทเรียน “การเลื่อนระดับเมธอด” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การเลื่อนระดับเมธอด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การเลื่อนระดับเมธอด”
สืบทอดเมธอดผ่านการฝัง คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การเลื่อนระดับเมธอด” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การฝังสตรักต์
- การฝังอินเทอร์เฟซ
- การเลื่อนระดับเมธอด
- การประกอบแทนการสืบทอด