Polymorphism: ความสามารถในการปรับเปลี่ยนรูปแบบ

สวัสดีครับ! ในบทที่แล้ว เราได้เรียนรู้เรื่อง Interface และการ Implement Interface ซึ่งเป็นพื้นฐานสำคัญในการทำความเข้าใจกับ Polymorphism ในบทนี้ เราจะมาเจาะลึกถึง Polymorphism ซึ่งเป็นหนึ่งในหัวใจสำคัญของ Object-Oriented Programming (OOP) และเป็นเครื่องมือที่ช่วยให้โค้ดของเรายืดหยุ่นและขยายได้ง่ายขึ้น

Polymorphism คืออะไร?

คำว่า "Polymorphism" มาจากภาษากรีก แปลว่า "หลายรูปแบบ" (Many Forms) ในบริบทของการเขียนโปรแกรมเชิงวัตถุ Polymorphism หมายถึง ความสามารถของ Object ที่จะแสดงออกในรูปแบบที่แตกต่างกันได้ ขึ้นอยู่กับสถานการณ์ หรือกล่าวอีกนัยหนึ่งคือ Object หนึ่งตัวสามารถถูกมองว่าเป็น Object ของ Class อื่นได้

ลองนึกภาพง่ายๆ ว่าคุณมีรีโมททีวี (Object) ที่สามารถใช้ควบคุมทีวี (Class ทีวี) และเครื่องเล่นดีวีดี (Class เครื่องเล่นดีวีดี) ได้ รีโมททีวีตัวเดียวกันสามารถทำงานกับอุปกรณ์ที่แตกต่างกันได้ นี่แหละคือ Polymorphism!

Polymorphism ช่วยให้เราเขียนโค้ดที่ทำงานได้กับ Object หลายประเภท โดยไม่ต้องแก้ไขโค้ดเดิม ทำให้โค้ดมีความยืดหยุ่นและง่ายต่อการบำรุงรักษา

Polymorphism ผ่าน Inheritance

Polymorphism สามารถทำได้ผ่าน Inheritance (การสืบทอดคุณสมบัติ) โดย Class ลูก (Child Class) สามารถแทนที่ Class แม่ (Parent Class) ได้

ตัวอย่าง:

<?php

class Animal {
  public function makeSound() {
    echo "Generic animal sound\n";
  }
}

class Dog extends Animal {
  public function makeSound() {
    echo "Woof!\n";
  }
}

class Cat extends Animal {
  public function makeSound() {
    echo "Meow!\n";
  }
}

// ฟังก์ชันที่รับ Animal Object และเรียก makeSound()
function animalSound(Animal $animal) {
  $animal->makeSound();
}

$animal = new Animal();
$dog = new Dog();
$cat = new Cat();

animalSound($animal); // Output: Generic animal sound
animalSound($dog);    // Output: Woof!
animalSound($cat);    // Output: Meow!

?>

คำอธิบาย:

เรามี Class แม่ชื่อ `Animal` ซึ่งมี Method `makeSound()` ที่แสดงเสียงของสัตว์ทั่วไป
เรามี Class ลูกสอง Class คือ `Dog` และ `Cat` ซึ่งสืบทอดมาจาก `Animal` และทำการ Override Method `makeSound()` เพื่อให้แสดงเสียงของสุนัขและแมวตามลำดับ
ฟังก์ชัน `animalSound()` รับ `Animal` Object เป็น Parameter ซึ่งหมายความว่าเราสามารถส่ง `Animal`, `Dog`, หรือ `Cat` Object เข้าไปได้
เมื่อเราเรียก `animalSound()` ด้วย Object ที่แตกต่างกัน มันจะแสดงผลลัพธ์ที่แตกต่างกัน นี่คือ Polymorphism!

กรณีใช้งานจริง:

สมมติว่าเรากำลังสร้างระบบจัดการการแจ้งเตือน (Notification System) เราอาจมี Class แม่ชื่อ `Notification` และ Class ลูก เช่น `EmailNotification`, `SMSNotification`, และ `PushNotification` แต่ละ Class ลูกจะ Override Method `send()` เพื่อส่งการแจ้งเตือนด้วยวิธีที่แตกต่างกัน เราสามารถเขียนโค้ดที่รับ `Notification` Object และเรียก `send()` โดยไม่ต้องรู้ว่าเป็นการแจ้งเตือนประเภทใด

ข้อผิดพลาดที่พบบ่อย:

การลืม Override Method ใน Class ลูก: หากเราลืม Override Method `makeSound()` ใน Class `Dog` หรือ `Cat` มันจะใช้ Method ของ Class แม่แทน ซึ่งอาจไม่ใช่สิ่งที่เราต้องการ

Polymorphism ผ่าน Interfaces

Polymorphism ยังสามารถทำได้ผ่าน Interfaces โดย Class ที่ Implement Interface เดียวกันสามารถถูกมองว่าเป็น Object ของ Interface นั้นได้

ตัวอย่าง:

<?php

interface Logger {
  public function log(string $message);
}

class FileLogger implements Logger {
  private $filename;

  public function __construct(string $filename) {
    $this->filename = $filename;
  }

  public function log(string $message) {
    file_put_contents($this->filename, $message . "\n", FILE_APPEND);
  }
}

class DatabaseLogger implements Logger {
  private $dbConnection;

  public function __construct(PDO $dbConnection) {
    $this->dbConnection = $dbConnection;
  }

  public function log(string $message) {
    // Code สำหรับบันทึก Log ลง Database
    $stmt = $this->dbConnection->prepare("INSERT INTO logs (message) VALUES (?)");
    $stmt->execute([$message]);
  }
}

// ฟังก์ชันที่รับ Logger Object และเรียก log()
function logMessage(Logger $logger, string $message) {
  $logger->log($message);
}

// ตัวอย่างการใช้งาน
$fileLogger = new FileLogger("app.log");
$dbLogger = new DatabaseLogger(new PDO("mysql:host=localhost;dbname=mydb", "user", "password"));

logMessage($fileLogger, "This is a log message from FileLogger.");
logMessage($dbLogger, "This is a log message from DatabaseLogger.");

?>

คำอธิบาย:

เรามี Interface ชื่อ `Logger` ซึ่งกำหนด Method `log()`
เรามี Class สอง Class คือ `FileLogger` และ `DatabaseLogger` ซึ่ง Implement Interface `Logger` และ Implement Method `log()` ในแบบที่แตกต่างกัน
ฟังก์ชัน `logMessage()` รับ `Logger` Object เป็น Parameter ซึ่งหมายความว่าเราสามารถส่ง `FileLogger` หรือ `DatabaseLogger` Object เข้าไปได้
เมื่อเราเรียก `logMessage()` ด้วย Object ที่แตกต่างกัน มันจะบันทึก Log ด้วยวิธีที่แตกต่างกัน นี่คือ Polymorphism!

กรณีใช้งานจริง:

สมมติว่าเราต้องการบันทึก Log ของ Application เราสามารถสร้าง Interface `Logger` และ Implement Class ต่างๆ เช่น `FileLogger`, `DatabaseLogger`, และ `APILogger` แต่ละ Class จะบันทึก Log ไปยังที่ที่แตกต่างกัน เราสามารถเปลี่ยนวิธีการบันทึก Log ได้ง่ายๆ โดยไม่ต้องแก้ไขโค้ดหลักของ Application

ข้อผิดพลาดที่พบบ่อย:

การไม่ Implement Method ทั้งหมดใน Interface: หากเราไม่ Implement Method `log()` ใน Class `FileLogger` หรือ `DatabaseLogger` PHP จะแสดง Error

สรุป

Polymorphism เป็นแนวคิดที่สำคัญใน OOP ที่ช่วยให้โค้ดของเรายืดหยุ่นและขยายได้ง่ายขึ้น เราสามารถทำ Polymorphism ได้ผ่าน Inheritance และ Interfaces โดย Class ลูกสามารถแทนที่ Class แม่ได้ และ Class ที่ Implement Interface เดียวกันสามารถถูกมองว่าเป็น Object ของ Interface นั้นได้

หวังว่าบทความนี้จะช่วยให้คุณเข้าใจ Polymorphism ได้ดียิ่งขึ้น ในบทต่อไป เราจะมาเรียนรู้เรื่อง Traits ซึ่งเป็นอีกหนึ่งเครื่องมือที่ช่วยในการจัดการ Code Reuse อย่างมีประสิทธิภาพ แล้วพบกันครับ!