0Pricing
Go Academy · บทเรียน

การประกอบแทนการสืบทอด

ปรัชญาการออกแบบของ Go

การประกอบแทนการสืบทอด เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

ปรัชญาการออกแบบของ Go

Go จงใจไม่รวมการสืบทอดจากคลาส แนวทางที่เหมาะกับ Go คือ การประกอบ โดยสร้างพฤติกรรมจากการรวมชนิดข้อมูลและอินเทอร์เฟซขนาดเล็กเข้าด้วยกัน

เหตุใดจึงไม่ใช้การสืบทอด

ลำดับชั้นการสืบทอดที่ลึกจะเปราะบาง เพราะการเปลี่ยนแปลงในคลาสพื้นฐานอาจส่งผลต่อเนื่องอย่างคาดเดาไม่ได้ การประกอบช่วยให้ความสัมพันธ์ชัดเจนและยืดหยุ่น

ใช้แบบมี แทนแบบเป็น

แทนที่จะจำลองว่า «ผู้จัดการเป็นพนักงาน» ให้จำลองว่า «ผู้จัดการมีข้อมูลและความสามารถของพนักงาน» ผ่านการฝังหรือฟิลด์

package main

import "fmt"

type Employee struct{ Name string }

func (e Employee) Work() string { return e.Name + " works" }

type Manager struct {
	Employee
	Reports int
}

func main() {
	m := Manager{Employee{"Lin"}, 3}
	fmt.Println(m.Work(), "-", m.Reports, "reports")
}

เขียนโปรแกรมโดยยึดอินเทอร์เฟซ

กำหนดพฤติกรรมด้วยอินเทอร์เฟซขนาดเล็ก แล้วรับอินเทอร์เฟซเหล่านั้น การนำไปใช้งานจึงสับเปลี่ยนกันได้และเปลี่ยนหรือจำลองได้ง่าย

package main

import "fmt"

type Notifier interface{ Notify(msg string) }

type Email struct{}

func (Email) Notify(msg string) { fmt.Println("email:", msg) }

func alert(n Notifier, m string) { n.Notify(m) }

func main() {
	alert(Email{}, "deploy done")
}

สับเปลี่ยนการนำไปใช้งาน

เนื่องจากฟังก์ชันพึ่งพาอินเทอร์เฟซ คุณจึงส่งการนำไปใช้งานใด ๆ ก็ได้โดยไม่ต้องเปลี่ยนฟังก์ชัน

package main

import "fmt"

type Notifier interface{ Notify(msg string) }

type Email struct{}
type SMS struct{}

func (Email) Notify(m string) { fmt.Println("email:", m) }
func (SMS) Notify(m string)   { fmt.Println("sms:", m) }

func alert(n Notifier, m string) { n.Notify(m) }

func main() {
	alert(Email{}, "hi")
	alert(SMS{}, "hi")
}

รวมพฤติกรรม

ฝังส่วนประกอบขนาดเล็กหลายส่วนเพื่อประกอบชนิดที่มีความสามารถหลากหลายจากชิ้นส่วนอิสระที่ทดสอบได้

package main

import "fmt"

type Logger struct{}

func (Logger) Log(s string) { fmt.Println("log:", s) }

type Cache struct{ data map[string]string }

func (c Cache) Get(k string) string { return c.data[k] }

type Service struct {
	Logger
	Cache
}

func main() {
	s := Service{Cache: Cache{data: map[string]string{"k": "v"}}}
	s.Log("started")
	fmt.Println(s.Get("k"))
}

การฉีดการพึ่งพา

ส่งสิ่งที่ต้องพึ่งพา (ในรูปอินเทอร์เฟซ) เข้าไปในตัวสร้าง แทนการกำหนดสิ่งเหล่านั้นไว้ตายตัว นี่คือการประกอบที่นำมาใช้กับการเชื่อมส่วนประกอบ

package main

import "fmt"

type Store interface{ Save(s string) }

type MemStore struct{ items []string }

func (m *MemStore) Save(s string) { m.items = append(m.items, s) }

type App struct{ store Store }

func NewApp(s Store) *App { return &App{store: s} }

func main() {
	app := NewApp(&MemStore{})
	app.store.Save("x")
	fmt.Println("saved")
}

อินเทอร์เฟซขนาดเล็กได้เปรียบ

อินเทอร์เฟซยิ่งเล็ก ชนิดต่าง ๆ ก็ยิ่งมีคุณสมบัติตรงตามอินเทอร์เฟซนั้นมากขึ้น และยิ่งทดสอบได้ง่ายขึ้น อินเทอร์เฟซยิ่งใหญ่ นามธรรมก็ยิ่งอ่อนแอ

หลีกเลี่ยงคลาสฐานที่เปราะบาง

เมื่อไม่มีการสืบทอด ก็ไม่มีคลาสฐานให้พัง แต่ละส่วนที่ประกอบกันสามารถพัฒนาได้อย่างอิสระ ทำให้การยึดโยงลดลง

รับอินเทอร์เฟซ คืนสตรักต์

แนวทางทั่วไปของ Go คือ ฟังก์ชันรับอินเทอร์เฟซ (อินพุตที่ยืดหยุ่น) และคืนสตรักต์รูปธรรม (เอาต์พุตที่ชัดเจนและนำไปใช้ได้)

รายการตรวจสอบการประกอบ

  • จำลองแบบมี ไม่ใช่แบบเป็น
  • ฝังส่วนประกอบขนาดเล็ก
  • พึ่งพาอินเทอร์เฟซขนาดเล็ก
  • ฉีดสิ่งที่ต้องพึ่งพา

ตรวจสอบความเข้าใจ

ทดสอบความรู้เกี่ยวกับแนวคิดการประกอบของคุณ

สรุปทบทวน

คุณได้เรียนรู้แนวคิดการประกอบของ Go

  • ไม่มีการสืบทอด ให้ประกอบด้วยการฝังและอินเทอร์เฟซ
  • จำลองแบบมีแทนแบบเป็น
  • เขียนโปรแกรมโดยยึดอินเทอร์เฟซขนาดเล็กและฉีดสิ่งที่ต้องพึ่งพา
  • รับอินเทอร์เฟซและคืนสตรักต์

คำถามที่พบบ่อย

บทเรียน “การประกอบแทนการสืบทอด” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การประกอบแทนการสืบทอด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การประกอบแทนการสืบทอด”

ปรัชญาการออกแบบของ Go คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การประกอบแทนการสืบทอด” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การฝังสตรักต์
  2. การฝังอินเทอร์เฟซ
  3. การเลื่อนระดับเมธอด
  4. การประกอบแทนการสืบทอด
← กลับไปที่ Go Academy