พื้นฐาน Object-Oriented Programming (OOP) ใน PHP

ยินดีต้อนรับสู่โลกของ Object-Oriented Programming (OOP) ใน PHP! หลังจากที่เราได้เรียนรู้เรื่อง Namespace ใน PHP ไปแล้ว ซึ่งเป็นเครื่องมือสำคัญในการจัดระเบียบโค้ด ตอนนี้เราจะมาเรียนรู้ OOP ซึ่งเป็น Paradigm การเขียนโปรแกรมที่ช่วยให้เราเขียนโค้ดได้เป็นระเบียบ, reusable และ maintainable มากยิ่งขึ้น

OOP เป็นแนวคิดที่มองทุกสิ่งทุกอย่างเป็น "วัตถุ" (Object) ซึ่งแต่ละวัตถุจะมีคุณสมบัติ (Properties) และพฤติกรรม (Methods) เป็นของตัวเอง ในบทนี้เราจะมาเรียนรู้พื้นฐานของ OOP ใน PHP และวิธีการนำไปใช้งานจริง

Classes และ Objects

Class คือพิมพ์เขียว (blueprint) หรือแม่แบบที่ใช้ในการสร้าง Object เปรียบเสมือนพิมพ์เขียวบ้านที่สถาปนิกใช้ในการสร้างบ้านจริง ส่วน Object คือสิ่งที่ถูกสร้างขึ้นมาจาก Class หรือก็คือบ้านที่สร้างขึ้นจากพิมพ์เขียวนั้นเอง

ใน PHP เราใช้ keyword class ในการสร้าง Class:

<?php

class Dog {
  // Properties (คุณสมบัติ)
  public $name;
  public $breed;

  // Methods (พฤติกรรม)
  public function bark() {
    echo "Woof!";
  }
}

?>

ในตัวอย่างนี้ เราได้สร้าง Class ชื่อ Dog ซึ่งมี Properties $name และ $breed และ Method bark() ที่จะแสดงข้อความ "Woof!"

ในการสร้าง Object จาก Class เราใช้ keyword new:

<?php

require_once 'Dog.php'; // สมมติว่า Class Dog ถูกเก็บไว้ในไฟล์ Dog.php

$myDog = new Dog();

?>

ตอนนี้ $myDog คือ Object ที่ถูกสร้างขึ้นจาก Class Dog เราสามารถเข้าถึง Properties และ Methods ของ Object ได้โดยใช้ Operator ->:

<?php

require_once 'Dog.php';

$myDog = new Dog();
$myDog->name = "Buddy";
$myDog->breed = "Golden Retriever";

echo "My dog's name is " . $myDog->name . " and it's a " . $myDog->breed . "."; // Output: My dog's name is Buddy and it's a Golden Retriever.
$myDog->bark(); // Output: Woof!

?>

ข้อผิดพลาดที่พบบ่อย: การลืม new เมื่อสร้าง Object จะทำให้เกิดข้อผิดพลาด Fatal error: Uncaught Error: Class 'Dog' not found หรือ Call to a member function bark() on null

Properties และ Methods

Properties คือตัวแปรที่เก็บข้อมูลเกี่ยวกับ Object ใน Class Dog ของเรา $name และ $breed คือ Properties

Methods คือฟังก์ชันที่กำหนดพฤติกรรมของ Object ใน Class Dog ของเรา bark() คือ Method

Visibility (การเข้าถึง)

Properties และ Methods สามารถมี Visibility ได้ 3 แบบ:

public: สามารถเข้าถึงได้จากทุกที่ ทั้งภายใน Class, ภายนอก Class และจาก Class ที่สืบทอด (Inheritance)
protected: สามารถเข้าถึงได้จากภายใน Class และจาก Class ที่สืบทอดเท่านั้น
private: สามารถเข้าถึงได้จากภายใน Class เท่านั้น

ตัวอย่าง:

<?php

class Dog {
  public $name;        // สามารถเข้าถึงได้จากทุกที่
  protected $breed;    // สามารถเข้าถึงได้จากภายใน Class และ Class ที่สืบทอด
  private $age;        // สามารถเข้าถึงได้จากภายใน Class เท่านั้น

  public function __construct($name, $breed, $age) {
    $this->name = $name;
    $this->breed = $breed;
    $this->age = $age;
  }

  public function getAge() {
    return $this->age; // สามารถเข้าถึง $age ได้จากภายใน Class
  }

  protected function getBreed() {
    return $this->breed; // สามารถเข้าถึง $breed ได้จากภายใน Class
  }
}

$myDog = new Dog("Buddy", "Golden Retriever", 5);
echo $myDog->name; // Output: Buddy (public)
// echo $myDog->breed; // Fatal error: Cannot access protected property Dog::$breed
// echo $myDog->age;   // Fatal error: Cannot access private property Dog::$age
echo $myDog->getAge(); // Output: 5 (public method ที่เข้าถึง private property)

?>

ข้อผิดพลาดที่พบบ่อย: พยายามเข้าถึง protected หรือ private Properties หรือ Methods จากภายนอก Class จะทำให้เกิดข้อผิดพลาด Fatal error: Cannot access protected property ... หรือ Fatal error: Cannot access private property ...

Constructor

Constructor คือ Method พิเศษที่จะถูกเรียกใช้โดยอัตโนมัติเมื่อมีการสร้าง Object จาก Class ใน PHP Constructor จะมีชื่อว่า __construct()

Constructor มักจะถูกใช้ในการกำหนดค่าเริ่มต้นให้กับ Properties ของ Object:

<?php

class Dog {
  public $name;
  public $breed;

  public function __construct($name, $breed) {
    $this->name = $name;
    $this->breed = $breed;
  }

  public function bark() {
    echo "Woof!";
  }
}

$myDog = new Dog("Buddy", "Golden Retriever");
echo $myDog->name; // Output: Buddy
echo $myDog->breed; // Output: Golden Retriever

?>

ข้อผิดพลาดที่พบบ่อย: การลืมกำหนด Constructor หรือกำหนด Constructor ผิดพลาด (เช่น ชื่อไม่ถูกต้อง) อาจทำให้ Object ไม่สามารถถูกสร้างได้อย่างถูกต้อง

Encapsulation

Encapsulation คือหลักการที่บอกว่าควรซ่อนรายละเอียดภายในของ Object ไว้ และให้ Object สื่อสารกันผ่าน Interface ที่กำหนดไว้เท่านั้น

Encapsulation ช่วยให้เราสามารถ:

ควบคุมการเข้าถึงข้อมูล: กำหนด Visibility ให้กับ Properties เพื่อป้องกันการแก้ไขข้อมูลโดยตรงจากภายนอก
ซ่อนความซับซ้อน: ซ่อนรายละเอียดการทำงานภายในของ Methods และให้ผู้ใช้งานเรียกใช้ Methods ผ่าน Interface ที่ง่ายต่อการใช้งาน
เปลี่ยนแปลงโค้ดได้ง่ายขึ้น: เมื่อรายละเอียดภายในถูกซ่อนไว้ เราสามารถเปลี่ยนแปลงโค้ดภายใน Class ได้โดยไม่กระทบกับโค้ดที่เรียกใช้ Class นั้น

ตัวอย่าง:

<?php

class BankAccount {
  private $balance = 0;

  public function deposit($amount) {
    if ($amount > 0) {
      $this->balance += $amount;
    }
  }

  public function withdraw($amount) {
    if ($amount > 0 && $amount <= $this->balance) {
      $this->balance -= $amount;
    }
  }

  public function getBalance() {
    return $this->balance;
  }
}

$account = new BankAccount();
// $account->balance = 1000; // Fatal error: Cannot access private property BankAccount::$balance
$account->deposit(500);
$account->withdraw(200);
echo "Balance: " . $account->getBalance(); // Output: Balance: 300

?>

ในตัวอย่างนี้ $balance เป็น Property ที่ถูกกำหนดให้เป็น private ซึ่งหมายความว่าไม่สามารถเข้าถึงได้จากภายนอก Class เราสามารถฝากและถอนเงินผ่าน Methods deposit() และ withdraw() เท่านั้น ซึ่งช่วยให้เราควบคุมการเปลี่ยนแปลง $balance ได้

กรณีใช้งานจริง: การสร้าง Class สำหรับจัดการข้อมูลผู้ใช้ โดยซ่อนข้อมูลส่วนตัว (เช่น รหัสผ่าน) ไว้ภายใน Class และให้เข้าถึงข้อมูลผ่าน Methods ที่กำหนดไว้เท่านั้น

ข้อผิดพลาดที่พบบ่อย: การไม่ใช้ Encapsulation และให้ Properties เป็น public ทั้งหมด อาจทำให้ข้อมูลของ Object ถูกแก้ไขโดยไม่ตั้งใจและนำไปสู่ปัญหาต่างๆ

ในบทนี้ เราได้เรียนรู้พื้นฐานของ Object-Oriented Programming (OOP) ใน PHP ได้แก่ Classes, Objects, Properties, Methods, Visibility และ Encapsulation ในบทต่อไป เราจะมาเรียนรู้เรื่อง Inheritance ซึ่งเป็นอีกหนึ่งแนวคิดสำคัญของ OOP ที่จะช่วยให้เราสร้าง Class ที่มีความสัมพันธ์กันและ reusable มากยิ่งขึ้น