OOP: Properties and Methods

OOP: Properties and Methods

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

Properties คือตัวแปรที่เก็บข้อมูลของ Object ส่วน Methods คือฟังก์ชันที่กำหนดพฤติกรรมของ Object การใช้งาน Properties และ Methods อย่างถูกต้อง จะช่วยให้เราสร้าง code ที่มีความยืดหยุ่น, maintainable และ reusable มากยิ่งขึ้น

การประกาศ Properties

Properties คือตัวแปรที่ประกาศภายใน Class เพื่อเก็บข้อมูลที่เกี่ยวข้องกับ Object นั้นๆ ตัวอย่างเช่น ถ้าเรามี Class ชื่อ Car Properties ที่เกี่ยวข้องอาจจะเป็น $color, $model, $engineSize เป็นต้น

class Car {
  public $color;
  public $model;
  public $engineSize;
}

$myCar = new Car();
$myCar->color = "Red";
$myCar->model = "Toyota Camry";
$myCar->engineSize = 2.5;

echo "My car is a " . $myCar->color . " " . $myCar->model . " with a " . $myCar->engineSize . "L engine.";

ในตัวอย่างนี้ เราได้ประกาศ Properties $color, $model และ $engineSize เป็น public ซึ่งหมายความว่าสามารถเข้าถึงได้จากภายนอก Class ได้โดยตรง จากนั้นเราได้สร้าง Object $myCar และกำหนดค่าให้กับ Properties เหล่านั้น

การประกาศ Methods

Methods คือฟังก์ชันที่ประกาศภายใน Class เพื่อกำหนดพฤติกรรมที่ Object นั้นสามารถทำได้ ตัวอย่างเช่น Class Car อาจจะมี Methods startEngine(), accelerate(), brake() เป็นต้น

class Car {
  public $color;
  public $model;
  public $engineSize;

  public function startEngine() {
    echo "Engine started!\n";
  }

  public function accelerate() {
    echo "Accelerating...\n";
  }
}

$myCar = new Car();
$myCar->startEngine();
$myCar->accelerate();

ในตัวอย่างนี้ เราได้ประกาศ Methods startEngine() และ accelerate() ซึ่งเป็นฟังก์ชันที่ไม่มี Parameter และเมื่อเรียกใช้งาน จะแสดงข้อความที่เกี่ยวข้อง

Visibility: public, private, protected

Visibility modifiers (public, private, protected) เป็นเครื่องมือสำคัญในการควบคุมการเข้าถึง Properties และ Methods ของ Class การเลือก Visibility ที่เหมาะสมเป็นสิ่งสำคัญในการออกแบบ Class ที่ดีและปลอดภัย

• public: Properties และ Methods ที่ประกาศเป็น public สามารถเข้าถึงได้จากทุกที่ ไม่ว่าจะเป็นภายใน Class เอง, ภายนอก Class หรือจาก Class ที่สืบทอด (Inheritance)
• private: Properties และ Methods ที่ประกาศเป็น private สามารถเข้าถึงได้เฉพาะภายใน Class นั้นๆ เท่านั้น ไม่สามารถเข้าถึงได้จากภายนอก Class หรือจาก Class ที่สืบทอด
• protected: Properties และ Methods ที่ประกาศเป็น protected สามารถเข้าถึงได้ภายใน Class นั้นๆ และจาก Class ที่สืบทอดเท่านั้น ไม่สามารถเข้าถึงได้จากภายนอก Class โดยตรง

เหตุผลเชิงออกแบบ (Design Rationale):

การเลือก Visibility ที่เหมาะสมขึ้นอยู่กับวัตถุประสงค์ของการใช้งาน Property หรือ Method นั้นๆ โดยทั่วไปแล้ว เราควรใช้ private กับ Properties ที่เก็บข้อมูลภายในของ Object และไม่ต้องการให้ภายนอก Class สามารถแก้ไขได้โดยตรง การทำเช่นนี้จะช่วยให้เราสามารถควบคุมการเปลี่ยนแปลงข้อมูลของ Object ได้อย่างเข้มงวด และป้องกันการเกิดข้อผิดพลาด

ส่วน Methods ที่เป็นส่วนหนึ่งของ Interface ที่ Object ต้องการสื่อสารกับภายนอก ควรประกาศเป็น public เพื่อให้ Object อื่นๆ สามารถเรียกใช้งานได้

protected มักใช้ในกรณีที่ต้องการให้ Class ที่สืบทอดสามารถเข้าถึง Properties หรือ Methods บางอย่างได้ แต่ไม่ต้องการให้ภายนอก Class สามารถเข้าถึงได้โดยตรง

class BankAccount {
  private $balance = 0; // Balance is private

  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() { // Public method to access the private balance
    return $this->balance;
  }
}

$account = new BankAccount();
$account->deposit(100);
// $account->balance = 1000; // This will cause an error because $balance is private
echo "Balance: " . $account->getBalance() . "\n";

ในตัวอย่างนี้ $balance เป็น private ทำให้ไม่สามารถแก้ไขได้จากภายนอก Class แต่เราสามารถเพิ่มหรือลด $balance ได้ผ่าน Methods deposit() และ withdraw() และเข้าถึง $balance ได้ผ่าน Method getBalance() นี่คือหลักการของ Encapsulation ซึ่งเป็นหนึ่งในหลักการสำคัญของ OOP

แนวปฏิบัติที่ดี (Best Practices):

• Encapsulation: พยายามทำให้ Properties เป็น private และเข้าถึงผ่าน Methods ที่เป็น public (Getters และ Setters) เพื่อควบคุมการเข้าถึงและแก้ไขข้อมูล
• Information Hiding: ซ่อนรายละเอียดภายในของ Class และแสดงเฉพาะ Interface ที่จำเป็นต่อการใช้งาน
• Keep it Simple: ออกแบบ Class ให้มี Properties และ Methods ที่เกี่ยวข้องกับหน้าที่ของ Class นั้นๆ เท่านั้น

Trade-offs ของการใช้ Visibility

การเลือก Visibility มี trade-offs ที่ต้องพิจารณา:

• public:
  • ข้อดี: ง่ายต่อการใช้งานและการเข้าถึง
  • ข้อเสีย: ขาดการควบคุมการเข้าถึง, อาจทำให้เกิดข้อผิดพลาดได้ง่าย
• private:
  • ข้อดี: ควบคุมการเข้าถึงได้เข้มงวด, ป้องกันการเกิดข้อผิดพลาด
  • ข้อเสีย: อาจทำให้ code ซับซ้อนขึ้น, ต้องสร้าง Getters และ Setters เพิ่มเติม
• protected:
  • ข้อดี: อนุญาตให้ Class ที่สืบทอดเข้าถึงได้, แต่ยังคงป้องกันการเข้าถึงจากภายนอก
  • ข้อเสีย: อาจทำให้ code ซับซ้อนขึ้น, ต้องระมัดระวังในการออกแบบ Inheritance

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

ในบทต่อไป เราจะเรียนรู้เกี่ยวกับ Constructor และ Destructor ซึ่งเป็น Methods พิเศษที่ใช้ในการสร้างและทำลาย Object