OOP ในภาษา Go - การทำ Composition แทน Inheritance

 

ภาษา Go เป็นภาษาที่มีลักษณะเฉพาะหลายอย่าง แต่หนึ่งในลักษณะที่โดดเด่นคือการนำเสนอแนวคิดการเขียนโปรแกรมเชิงวัตถุ (OOP) ในรูปแบบที่แตกต่างจากภาษาโปรแกรมอื่นๆ เช่น Java หรือ C++. ภาษา Go เลือกที่จะใช้องค์ประกอบ (Composition) แทนการสืบทอด (Inheritance) ซึ่งเป็นหนึ่งในแนวคิดหลักของการเขียนโปรแกรมเชิงวัตถุแบบดั้งเดิม

 

ทำไมถึงเลือกใช้ Composition แทน Inheritance?

ก่อนที่จะกล่าวถึงรายละเอียดของ Composition ในภาษา Go เราควรเข้าใจก่อนว่าทำไมการใช้ Composition ถึงได้รับความนิยมใน Go และแม้กระทั่งในภาษาโปรแกรมและดีไซน์พัฒนาซอฟต์แวร์สมัยใหม่

1. ความยืดหยุ่นในการออกแบบ: Composition ช่วยให้สามารถรวมคุณลักษณะจากหลาย ๆ ส่วนเข้ามาในคลาสหรืออินสแตนซ์เดียวได้โดยไม่ต้องสร้างเครือข่ายการสืบทอดที่ซับซ้อน 2. การหลีกเลี่ยงปัญหาในแนวคิดการสืบทอด: การสืบทอดสามารถนำไปสู่ปัญหาความซับซ้อน เช่น "Fragile Base Class Problem" หรือการที่การเปลี่ยนแปลงในคลาสฐานกระทบต่อทุกคลาสที่สืบทอดมาจากมัน 3. สนับสนุนแนวคิด "ก้อนอิฐ": คือการสร้างระบบที่ประกอบไปด้วยหน่วยย่อยที่สามารถนำมาประกอบกันเพื่อเพิ่มฟีเจอร์ต่างๆ

 

Composition ใน Go ทำงานอย่างไร?

การทำ Composition ในภาษา Go ประกอบไปด้วยการใช้ Embedded Types หรือการฝังประเภท ซึ่งทำให้โครงสร้างข้อมูลสามารถมีพฤติกรรมคล้ายคลาสย่อยแต่ไม่ต้องอาศัยการสืบทอด นี่คือตัวอย่างการใช้งาน Composition ใน Go:

package main

import "fmt"

// Define a basic struct
type Animal struct {
	Name string
	Age  int
}

// Define another struct that will 'embed' the Animal struct
type Dog struct {
	Animal  // Embedding Animal
	Breed string
}

func (a Animal) Speak() {
	fmt.Printf("Hi, I'm %s and I'm %d years old.\n", a.Name, a.Age)
}

func main() {
	myDog := Dog{
		Animal: Animal{
			Name: "Buddy",
			Age:  5,
		},
		Breed: "Golden Retriever",
	}

	// Access methods and fields from embedded struct directly
	myDog.Speak()
	fmt.Println("I am a", myDog.Breed)
}

การใช้งาน Composition

ในตัวอย่างข้างต้น เราได้สร้างโครงสร้าง `Animal` และทำการฝังมันลงในโครงสร้าง `Dog` การฝังนี้ช่วยให้โครงสร้าง `Dog` สามารถเข้าถึงคุณสมบัติและฟังก์ชันของ `Animal` ได้ทันทีโดยไม่ต้องสืบทอด (Inherit)

ข้อดีของการใช้ Composition

1. ความง่ายในการบำรุงรักษา: เนื่องจากไม่มีการสืบทอดลำดับชั้นที่ซับซ้อน, ทำให้การบำรุงรักษาและการขยายระบบเป็นไปอย่างยืดหยุ่น 2. ส่งเสริมการใช้ซ้ำของโค้ด: สามารถใช้งานโค้ดเดิมในหลายๆ ส่วนได้ง่ายขึ้น 3. รักษาหลักการ Single Responsibility: ทำให้แต่ละส่วนของโค้ดมีหน้าที่เฉพาะตัว

การประยุกต์ใช้งาน Composition ในโปรเจคจริง

การใช้ Composition ในโปรเจคจริงสามารถนำไปใช้ในหลายสถานการณ์ โปรแกรมเมอร์สามารถวางโครงสร้าง objects ที่ซับซ้อนโดยใช้ block เล็กๆ ที่ถูกทดสอบการทำงานแยกกัน ทำให้แน่ใจได้ว่าส่วนประกอบต่างๆ ทำงานได้ดีตามที่คาดหวัง

ภาษา Go นั้นได้รับการออกแบบโดยใช้แนวคิดที่คาดหวังให้ง่ายต่อการพัฒนาและเสริมความยืดหยุ่นในการใช้งาน การเรียนรู้แนวคิด Composition และการฝังประเภทใน Go ถือเป็นทักษะที่สำคัญและเป็นประโยชน์สำหรับนักพัฒนาโปรแกรมที่ต้องการสร้างระบบซอฟต์แวร์ที่หลักแหลมและทนทาน

หากผู้อ่านสนใจต่อยอดการศึกษาหรือฝึกฝนด้านการเขียนโปรแกรมภาษา Go หรือภาษาอื่นๆ สามารถศึกษาเพิ่มเติมได้ที่ EPT (Expert-Programming-Tutor) โรงเรียนสอนเขียนโปรแกรมที่มีหลักสูตรและผู้เชี่ยวชาญพร้อมที่จะพาคุณยกระดับทักษะการเขียนโปรแกรมไปอีกขั้น!

 

 

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง

หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/