การใช้งาน polymorphism in OOP concept ในภาษา Scala แบบง่ายๆ พร้อมตัวอย่าง CODE 3 ตัวอย่าง และอธิบายการทำงาน และยกตัวอย่าง usecase ในโลกจริง

การใช้ Polymorphism ใน OOP (Object-Oriented Programming) เป็นหัวใจสำคัญที่ช่วยให้โปรแกรมสามารถรับมือกับข้อมูลได้หลากหลายรูปแบบ โดยไม่ต้องเขียนโค้ดซ้ำหลายครั้ง เพื่อให้เห็นภาพชัดเจนยิ่งขึ้น วันนี้ผมจะพาท่านผู้อ่านไปสำรวจการใช้งาน Polymorphism ในภาษา Scala โดยจะให้ตัวอย่างโค้ด 3 ตัวอย่างและอธิบายการทำงาน พร้อมทั้งอธิบายถึง usecase ในโลกจริงที่เกี่ยวข้อง

ความหมายของ Polymorphism

Polymorphism ใน OOP คือความสามารถในการรับรู้วัตถุ(objects) หลายรูปแบบจากหนึ่งตัวตน (interface) ที่เดียวกัน นั่นหมายความว่า เมื่อเราออกแบบคลาส(class) หรืออินเทอร์เฟซ(interface) แบบหนึ่งเราสามารถใช้วัตถุที่หลากหลายแต่มีลักษณะพื้นฐานร่วมกันผ่านทางวิธีการ(interaction) นั้นได้

ตัวอย่างโค้ดใน Scala และการทำงาน

ตัวอย่างที่ 1: Abstract Class และการ Extend

abstract class Animal {
  def speak(): Unit
}

class Dog extends Animal {
  def speak() { println("Bark") }
}

class Cat extends Animal {
  def speak() { println("Meow") }
}

val dog: Animal = new Dog
val cat: Animal = new Cat

dog.speak()  // Output: Bark
cat.speak()  // Output: Meow

ในตัวอย่างนี้เรามี `Animal` เป็น abstract class ที่มีวิธีการ `speak` โดยไม่มีการกำหนดรายละเอียดของวิธีการนั้น จากนั้น `Dog` และ `Cat` ได้ทำการสืบทอด(extend) `Animal` และกำหนดการทำงานของ `speak` เป็นของตัวเอง Polymorphism อยู่ที่การที่เราสร้าง object ของ `Animal` แต่สามารถอ้างอิง(รับรู้)ไปยัง `Dog` หรือ `Cat` ได้

ตัวอย่างที่ 2: Trait และการ Implement

trait Shape {
  def area(): Double
}

class Circle(radius: Double) extends Shape {
  def area(): Double = 3.14 * radius * radius
}

class Rectangle(width: Double, height: Double) extends Shape {
  def area(): Double = width * height
}

val circle: Shape = new Circle(5)
val rectangle: Shape = new Rectangle(4,6)

println(circle.area())  // Output: 78.5
println(rectangle.area())  // Output: 24.0

ในตัวอย่างนี้ `Shape` เป็น trait ที่กำหนดการมี `area` `Circle` และ `Rectangle` จะ implement `Shape` และให้คำนิยามหรือการคำนวณพื้นที่ที่แตกต่างกัน การใช้ Polymorphism ทำให้เราสามารถรับรู้วัตถุที่แตกต่างผ่าน `Shape` และเรียกใช้ `area` ได้เหมือนกัน

ตัวอย่างที่ 3: Type Parameterization กับ Generics

def printListElements[T](list: List[T]): Unit = {
  list.foreach(e => println(e))
}

printListElements(List(1, 2, 3))  // Output: 1 2 3
printListElements(List("apple", "banana", "cherry"))  // Output: apple banana cherry

ในตัวอย่างนี้ `printListElements` เป็นฟังก์ชันที่มี type parameter `[T]` ที่สามารถทำงานกับ `List` ของข้อมูลประเภทใดๆ ทำให้เราสามารถใช้ฟังก์ชันเดียวกันกับ list ของข้อมูลประเภทต่างๆ ได้

Usecase ในโลกจริง

หนึ่งใน usecase สำคัญของ Polymorphism คือการพัฒนา library หรือ framework ที่ต้องการให้ผู้ใช้งานสามารถ customize การทำงานในส่วนที่จำเป็นได้ ในขณะที่ยังคงมีโครงสร้างพื้นฐานเดิมอยู่ เช่น การสร้าง GUI library ที่นักพัฒนาสามารถสร้างปุ่ม(buttons) ที่มีลักษณะพิเศษ แต่ยังคงฟังก์ชันพื้นฐานของปุ่มไว้

สรุปสิ่งที่ได้เรียน

การเรียนการใช้ Polymorphism ใน Scala ที่ EPT (Expert-Programming-Tutor) จะทำให้นักเรียนสามารถออกแบบโปรแกรมที่มีความยืดหยุ่นสูง นักเรียนจะได้เรียนทักษะที่จำเป็นในการพัฒนาแอปพลิเคชันในหลายๆ โดเมน ไม่ว่าจะเป็นพัฒนาเกม, ซอฟต์แวร์แบงก์คิง, หรือแม้กระทั่งระบบควบคุมการผลิตในโรงงาน หากคุณเป็นผู้ที่หลงใหลในการเรียนรู้ด้านการเขียนโปรแกรม การเรียนรู้ Scala และ Polymorphism ที่ศูนย์ EPT จะเปิดประตูไปสู่โอกาสใหม่ๆ ในการเป็นนักพัฒนาซอฟต์แวร์อย่างแท้จริง

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

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