PHP การซ่อนข้อมูลและ readonly



หัวใจของ OOP ที่ทำให้โค้ดดูแลง่ายคือ encapsulation — ซ่อนรายละเอียดข้างในไว้ เปิดเฉพาะสิ่งที่คนอื่นต้องใช้

ระดับการเข้าถึง 3 แบบ

คำเข้าถึงได้จาก
publicทุกที่
protectedในคลาสนี้ และคลาสลูกที่สืบทอด
privateในคลาสนี้เท่านั้น
<?php
declare(strict_types=1);

class Account
{
    public string $owner;
    protected string $accountType = 'saving';
    private float $balance = 0;

    public function deposit(float $amount): void
    {
        $this->balance += $amount;   // ok — อยู่ในคลาสเดียวกัน
    }
}

$acc = new Account();
$acc->owner = 'อร';           // ok — public
// echo $acc->balance;        // Error: Cannot access private property
// echo $acc->accountType;    // Error: Cannot access protected property

ทำไมต้อง private

ถ้า $balance เป็น public ใครก็เขียน $acc->balance = -99999; ได้ ทำให้อ็อบเจกต์อยู่ในสถานะที่เป็นไปไม่ได้ พอทำเป็น private แล้วบังคับให้ผ่านเมธอด เราควบคุมกฎได้:

<?php
class Account
{
    private float $balance = 0;

    public function deposit(float $amount): void
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException('ต้องฝากมากกว่า 0');
        }
        $this->balance += $amount;
    }

    public function withdraw(float $amount): void
    {
        if ($amount > $this->balance) {
            throw new RuntimeException('ยอดไม่พอ');
        }
        $this->balance -= $amount;
    }

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

ทุกการเปลี่ยนแปลง $balance ผ่านจุดที่ตรวจเงื่อนไข — ยอดติดลบเกิดขึ้นไม่ได้ นี่คือ “invariant” ที่คลาสรับประกัน

getter / setter

  • getter (getBalance()) — อ่านค่าออกไป อาจคำนวณหรือจัดรูปแบบก่อนคืน
  • setter (setEmail()) — เขียนค่าเข้า พร้อม validate
<?php
class User
{
    private string $email = '';

    public function setEmail(string $email): void
    {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException("อีเมลไม่ถูกต้อง: $email");
        }
        $this->email = strtolower($email);
    }

    public function getEmail(): string
    {
        return $this->email;
    }
}

$u = new User();
$u->setEmail('Somchai@Example.com');
echo $u->getEmail(), "\n";        // somchai@example.com

ไม่ใช่ทุก property ต้องมี getter/setter — ถ้าค่าไหนอ่าน/เขียนได้อิสระจริง ๆ ทำเป็น public ไปเลยก็ได้ อย่าสร้าง getter/setter เปล่า ๆ ที่แค่ส่งค่าผ่าน

readonly property (PHP 8.1+)

readonly = กำหนดค่าได้ครั้งเดียว (ตอน construct) หลังจากนั้นแก้ไม่ได้ เหมาะกับข้อมูลที่ไม่ควรเปลี่ยนตลอดชีวิตอ็อบเจกต์ เช่น id, วันที่สร้าง:

<?php
declare(strict_types=1);

class Order
{
    public function __construct(
        public readonly string $id,
        public readonly DateTimeImmutable $createdAt,
        public string $status = 'pending',
    ) {}
}

$order = new Order('ORD-001', new DateTimeImmutable());
echo $order->id, "\n";               // ORD-001
$order->status = 'paid';             // ok — status ไม่ readonly
// $order->id = 'ORD-999';           // Error: Cannot modify readonly property

ได้ประโยชน์ของ public (อ่านตรง ๆ ไม่ต้องมี getter) โดยไม่เสี่ยงถูกแก้

PHP 8.2 เพิ่ม readonly class ทำให้ทุก property เป็น readonly อัตโนมัติ — เหมาะกับคลาสประเภท value object / DTO:

<?php
readonly class Money
{
    public function __construct(
        public int $amount,        // เก็บเป็นสตางค์
        public string $currency,
    ) {}
}

private ใช้กับ method ด้วย

method ที่เป็นแค่ “ตัวช่วยภายใน” ควรเป็น private เพื่อบอกว่าไม่ใช่ส่วนที่คนอื่นควรเรียก:

<?php
class Invoice
{
    public function __construct(private array $items) {}

    public function total(): float
    {
        return $this->subtotal() + $this->vat();
    }

    private function subtotal(): float
    {
        return array_sum(array_column($this->items, 'price'));
    }

    private function vat(): float
    {
        return $this->subtotal() * 0.07;
    }
}

คนใช้คลาสนี้เห็นแค่ total() — subtotal() กับ vat() เป็นเรื่องภายใน จะเปลี่ยนวิธีคำนวณยังไงก็ได้โดยไม่กระทบคนอื่น

เรื่องที่คนมักพลาด

  • ทำทุก property เป็น public เพื่อความสะดวก แล้วภายหลังหาไม่เจอว่าโค้ดตรงไหนแก้ค่า — เริ่มจาก private ไว้ก่อน เปิดเมื่อจำเป็น
  • สร้าง getter/setter ครบทุก property แบบไม่มี logic — เท่ากับ public แต่โค้ดยาวกว่า ทำเฉพาะตัวที่ต้อง validate หรือคำนวณ
  • แก้ readonly property จากในเมธอดอื่นที่ไม่ใช่ constructor — แก้ได้เฉพาะตอน initialize ครั้งแรกในขอบเขตคลาสที่ประกาศ
  • readonly กับ property ที่เป็นอาร์เรย์ — แก้ทั้งตัวไม่ได้ แต่ $obj->arr[] = 1 ก็ยังไม่ได้เช่นกัน (ต้องสร้างอาร์เรย์ใหม่ทั้งก้อนแล้ว assign ตอน construct)
  • protected ทั้งที่ไม่มีคลาสลูก — ถ้าไม่มีการสืบทอด private สื่อเจตนาชัดกว่า
  • คิดว่า private = ปลอดภัยจากผู้ใช้ — มันคือกลไกช่วย “ออกแบบ” ไม่ใช่ security ยังเข้าถึงได้ผ่าน Reflection

สรุป

  • public ทุกที่, protected คลาสนี้+ลูก, private คลาสนี้เท่านั้น
  • ทำ property เป็น private แล้วเปิดผ่านเมธอดที่ตรวจเงื่อนไข → อ็อบเจกต์อยู่ในสถานะที่ถูกต้องเสมอ
  • getter/setter เฉพาะตัวที่ต้อง validate/คำนวณ ไม่ใช่ทุกตัว
  • readonly property กำหนดครั้งเดียวตอน construct — ได้ความสะดวกของ public โดยไม่เสี่ยงถูกแก้
  • method ตัวช่วยภายในควรเป็น private

บทถัดไปว่าด้วยการสืบทอด (extends), parent::, final, และ abstract class — วิธีแชร์โค้ดระหว่างคลาสที่มีความสัมพันธ์แบบ “เป็นชนิดหนึ่งของ”