การเขียนโปรแกรมเชิงวัตถุใน GO

คำถามแรกๆ ที่อยู่ในใจของโปรแกรมเมอร์ที่กำลังพิจารณาเปลี่ยนจากภาษาการเขียนโปรแกรมเชิงวัตถุ เช่น Java และ C# ไปเป็น Golang ก็คือพวกเขาสามารถนำหลักการเชิงวัตถุแบบเดียวกันไปใช้กับ Go ได้หรือไม่ สำหรับคำตอบสำหรับคำถามนี้ เราสามารถดูที่คำถามที่พบบ่อยของ go.dev;

Go เป็นภาษาเชิงวัตถุหรือไม่?

ใช่และไม่. แม้ว่า Go จะมีประเภทและวิธีการและอนุญาตให้ใช้รูปแบบการเขียนโปรแกรมเชิงวัตถุ แต่ก็ไม่มีลำดับชั้นของประเภท แนวคิดของ "อินเทอร์เฟซ" ใน Go ให้แนวทางที่แตกต่างออกไปซึ่งเราเชื่อว่าใช้งานง่ายและในบางวิธีก็เป็นแบบทั่วไปมากกว่า นอกจากนี้ยังมีวิธีในการฝังประเภทในประเภทอื่นเพื่อให้คลาสย่อยคล้ายคลึงกัน แต่ไม่เหมือนกัน ยิ่งไปกว่านั้น วิธีการใน Go นั้นมีความทั่วไปมากกว่าใน C++ หรือ Java โดยสามารถกำหนดให้กับข้อมูลประเภทใดก็ได้ แม้แต่ประเภทที่ฝังไว้ เช่น จำนวนเต็มธรรมดาที่ “ไม่มีกล่อง” พวกเขาไม่ได้จำกัดอยู่เพียงโครงสร้าง (คลาส)

นอกจากนี้ การไม่มีลำดับชั้นของประเภททำให้ "วัตถุ" ใน Go ให้ความรู้สึกเบากว่าในภาษาเช่น C++ หรือ Java มาก

ในบทความนี้ เราจะพูดถึงวิธีการนำแนวคิดการเขียนโปรแกรมเชิงวัตถุไปใช้ Go

การห่อหุ้ม

การห่อหุ้มช่วยให้ข้อมูลปลอดภัยจากการรบกวนจากภายนอก ในภาษา oop สิ่งนี้ทำได้ในระดับอ็อบเจ็กต์โดยใช้ตัวแก้ไขการเข้าถึง แต่ใน Golang จะทำในระดับแพ็คเกจ

Go ไม่มีตัวแก้ไขการเข้าถึง เช่น สาธารณะ ส่วนตัว หรือที่ได้รับการป้องกัน แต่มีฟิลด์ที่ส่งออกและไม่ได้ส่งออกแทน ความแตกต่างนี้มาจากตัวอักษรตัวแรกของตัวแปร ตัวพิมพ์เล็กหมายถึงยังไม่ได้ส่งออก ทุนหมายถึงการส่งออก คุณสามารถนึกถึงความแตกต่างนี้เป็นส่วนตัวหรือสาธารณะ

ข้อแตกต่างที่เราเห็นก็คือไม่มีคลาสแต่เรามีโครงสร้างแทน เหตุผลก็คือ Go ออกมาเป็นทางเลือกสำหรับ C และ C++ และโครงสร้างส่วนใหญ่จะใช้ในภาษาเหล่านั้น

สิ่งเหล่านี้คือการมองเห็นระดับแพ็คเกจ ดังนั้นตัวแปรที่ขึ้นต้นด้วยตัวอักษรพิมพ์เล็กจึงไม่สามารถมองเห็นได้จากภายนอกแพ็คเกจที่ตัวแปรนั้นอยู่

มรดก

ใน OOP โปรแกรมคอมพิวเตอร์ได้รับการออกแบบในลักษณะที่ทุกสิ่งเป็นวัตถุที่มีปฏิสัมพันธ์ระหว่างกัน การสืบทอดเป็นส่วนสำคัญของภาษา OOP ซึ่งช่วยให้คุณสมบัติของคลาสหนึ่งได้รับการสืบทอดจากอีกคลาสหนึ่ง โดยพื้นฐานแล้วจะช่วยในการนำโค้ดกลับมาใช้ใหม่และสร้างความสัมพันธ์ระหว่างคลาสต่างๆ

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

ในตัวอย่างข้างต้น โครงสร้างรถยนต์ถูกฝังโดยโครงสร้างอื่นโดยไม่ระบุชื่อ

ซึ่งหมายความว่าเราสามารถเข้าถึงเขตข้อมูลได้โดยตรง วิธีนี้คล้ายกับสิ่งที่เราคุ้นเคยในด้าน OOP

ในตัวอย่างรถจักรยานยนต์ เรากำหนดโครงสร้างหนึ่งให้กับอีกสนามหนึ่ง ที่นี่สามารถเข้าถึงได้ผ่านคุณลักษณะของมัน

ความแตกต่างนี้กำหนดวิธีที่เราเข้าถึงข้อมูล แต่ทั้งสองทำงานเป็นวิธีการสืบทอดที่ถูกต้อง

ผู้รับเหมา

ตัวสร้างเป็นฟังก์ชันพิเศษสำหรับการสร้างอ็อบเจ็กต์ที่คล้ายกันหลายอินสแตนซ์ในภาษา oop ตามคลาสอย่างน่าเชื่อถือ

ไม่มีคำจำกัดความเฉพาะสำหรับการเริ่มต้นใน GO แต่เราสามารถทำได้เช่นเดียวกันโดยการเขียนฟังก์ชัน

ฟังก์ชัน NewCustomer ด้านบนทำงานเหมือนกับตัวสร้างในภาษา oop

โปรดทราบว่ามีแนวคิดเกี่ยวกับค่าเริ่มต้นหรือค่าว่างใน Go ทุกอย่างเริ่มต้นกับบางสิ่งบางอย่าง

type Customer struct {
   Name string // " "
   Age  int    // 0
}

ข้อผิดพลาดนี้เรียกว่า “NullReferenceException” ใน C#, “NullPointerException” ใน Java และที่ไม่มีการกำหนดค่าใด ๆ ขณะเตรียมใช้งาน จะไม่ปรากฏใน GO

โพลีมอร์ฟิซึม

Golang รองรับความหลากหลายผ่านอินเทอร์เฟซเท่านั้น ประเภทจะใช้อินเทอร์เฟซหากมีการกำหนดคำจำกัดความสำหรับวิธีการทั้งหมดที่ประกาศไว้ในอินเทอร์เฟซ

ในตัวอย่างข้างต้น Guitar ใช้อินเทอร์เฟซของ Instrument โดยให้คำจำกัดความสำหรับวิธีการ Play ซึ่งเป็นวิธีการเดียวที่ประกาศไว้ในอินเทอร์เฟซ

อีนัมส์

Enum เป็นประเภทข้อมูลที่มีประสิทธิภาพสำหรับ Enumerated Data ในภาษา oop ในด้านไป เราสามารถใช้เฉพาะค่าคงที่และกำหนดค่าที่เพิ่มขึ้นโดยการใช้ส่วนน้อยเท่านั้น แม้ว่าประโยชน์ของการใช้ Enum ก็คือเราไม่จำเป็นต้องออกคำสั่งอย่างชัดเจน

ข้อมูลทั่วไป

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

ในตัวอย่างข้างต้น ฟังก์ชัน PlayInstrument ยอมรับค่าใดๆ ที่เป็นไปตามสัญญาของอินเทอร์เฟซ "Instrument"

บทสรุป

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

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