Mengenal Visibility di PHP: Public, Private, dan Protected

Dalam dunia pemrograman berorientasi objek (OOP), konsep visibility atau access modifier adalah salah satu pondasi penting yang menentukan bagaimana suatu properti atau metode dalam sebuah kelas dapat diakses. Di PHP, terdapat tiga jenis visibility utama: public, private, dan protected. Masing-masing memiliki aturan serta fungsi yang berbeda, dan pemahaman yang benar terhadap konsep ini akan sangat membantu dalam menulis kode yang rapi, terstruktur, serta lebih aman.

---

Public: Akses Tanpa Batasan

Sebelum kita masuk ke pembahasan yang lebih kompleks, mari kita mulai dengan yang paling terbuka: public. Modifier ini memberikan kebebasan penuh terhadap properti atau metode untuk diakses dari mana saja. Artinya, baik dari dalam kelas, luar kelas, maupun oleh turunan kelas, elemen dengan visibility public bisa dipanggil tanpa hambatan.

Misalnya, jika Anda mendefinisikan sebuah metode public function getData(), maka metode tersebut bisa diakses oleh objek yang dibuat dari kelas itu, bahkan dari luar file tempat kelas tersebut berada. Inilah mengapa public sering digunakan untuk fungsi-fungsi yang memang ditujukan sebagai API atau layanan utama dari sebuah kelas.

Namun, kebebasan ini juga memiliki konsekuensi. Karena bisa diakses oleh siapa saja, maka perubahan atau manipulasi data juga bisa dilakukan dari luar. Jika tidak dirancang dengan hati-hati, penggunaan public dapat menyebabkan celah keamanan atau data yang tidak konsisten. Maka, meskipun terlihat praktis, Anda tetap perlu menimbang dengan bijak kapan harus membuat properti atau metode menjadi public.

---

Private: Menjaga Kerahasiaan Internal

Berbeda dengan public, modifier private adalah kebalikannya. Jika sebuah properti atau metode ditandai sebagai private, maka hanya bisa diakses dari dalam kelas itu sendiri. Bahkan kelas turunan sekalipun tidak dapat menyentuh properti atau metode ini.

Contoh penggunaannya biasanya ditemui pada data sensitif atau logika internal yang tidak boleh diketahui atau dimanipulasi dari luar. Misalnya, jika Anda sedang membuat kelas User, mungkin ada properti seperti password yang sebaiknya bersifat private. Dengan begitu, Anda bisa memastikan bahwa data ini tidak akan pernah dimanipulasi secara langsung oleh pihak eksternal.

Untuk mengelola data yang private, biasanya programmer menyediakan metode getter dan setter yang sifatnya public. Dengan begitu, ada jalur yang lebih terkontrol bagi pihak luar untuk mengakses atau mengubah nilai. Hal ini penting agar perubahan data tetap bisa dilakukan, namun dengan validasi dan aturan tertentu.

---

Protected: Perlindungan untuk Keluarga Sendiri

Di antara public dan private, ada level ketiga yaitu protected. Modifier ini bisa dibilang seperti pagar yang hanya bisa dibuka oleh keluarga dekat. Artinya, properti atau metode dengan visibility protected bisa diakses dari dalam kelas itu sendiri dan juga oleh kelas turunan, tetapi tidak bisa diakses langsung dari luar.

Contoh kasusnya adalah ketika Anda membuat sebuah parent class yang memiliki metode dasar, dan Anda ingin metode tersebut dapat digunakan atau dimodifikasi oleh child class, tapi tidak ingin terekspos secara bebas ke dunia luar.

Misalnya, sebuah kelas Database mungkin memiliki metode protected function connect(). Dengan begitu, kelas turunan seperti MySQLDatabase atau PostgreSQLDatabase bisa memanggil metode tersebut untuk membuat koneksi, tapi objek dari kelas Database tidak bisa mengakses connect() secara langsung dari luar. Konsep ini sangat berguna untuk menjaga struktur kode tetap rapi, namun tetap fleksibel untuk diwariskan.

---

Perbandingan Praktis: Public vs Private vs Protected

Agar lebih mudah dipahami, mari kita lihat contoh singkat:

class Produk {
    public $nama;
    private $harga;
    protected $diskon;

    public function __construct($nama, $harga, $diskon) {
        $this->nama = $nama;
        $this->harga = $harga;
        $this->diskon = $diskon;
    }

    public function getHarga() {
        return $this->harga - ($this->harga * $this->diskon / 100);
    }
}

class Elektronik extends Produk {
    public function getDiskon() {
        return $this->diskon; // Bisa diakses karena protected
    }
}

$produk = new Produk("Laptop", 10000000, 10);
echo $produk->nama;          // Bisa diakses (public)
// echo $produk->harga;      // Error, karena private
// echo $produk->diskon;     // Error, karena protected
echo $produk->getHarga();    // Bisa diakses melalui metode public

Pada contoh di atas:

• nama adalah public, sehingga bisa diakses langsung dari luar kelas.
• harga adalah private, hanya bisa diakses di dalam kelas Produk.
• diskon adalah protected, hanya bisa diakses di dalam kelas Produk dan kelas turunannya (Elektronik).

---

Dampak pada Desain dan Arsitektur Kode

Penggunaan visibility tidak hanya soal aturan teknis, tapi juga berhubungan erat dengan desain perangkat lunak. Jika semua properti dibuat public, maka kelas menjadi rapuh dan sulit dikontrol. Perubahan kecil dari luar bisa menyebabkan bug besar. Sebaliknya, jika terlalu banyak menggunakan private, maka kelas bisa terasa kaku dan sulit diperluas.

Oleh karena itu, protected sering menjadi pilihan kompromi yang baik ketika Anda merancang sistem yang perlu diwariskan. Sementara private cocok untuk data yang sifatnya benar-benar internal, dan public digunakan untuk fungsi-fungsi utama yang memang ingin Anda ekspos.

Prinsip umum yang sering dipakai adalah “encapsulation”, yaitu menyembunyikan detail implementasi dan hanya menampilkan antarmuka yang penting saja. Dengan begitu, kelas menjadi lebih aman, lebih mudah dikelola, dan lebih fleksibel jika sewaktu-waktu ada perubahan.

---

Tabel Perbandingan Singkat Visibility di PHP

Agar lebih mudah membandingkan perbedaan mendasar antara public, private, dan protected, berikut adalah tabel ringkas:

Visibility	Bisa diakses dari dalam kelas	Bisa diakses dari luar kelas	Bisa diakses oleh kelas turunan
Public	✔ Ya	✔ Ya	✔ Ya
Private	✔ Ya	✘ Tidak	✘ Tidak
Protected	✔ Ya	✘ Tidak	✔ Ya

Tabel ini memudahkan kita memahami gambaran umum, meskipun pada implementasinya sering kali dipadukan dengan metode getter dan setter untuk memberikan akses terbatas.

---

Studi Kasus: Aplikasi Login Sederhana

Bayangkan Anda membuat sebuah sistem login. Anda mungkin punya kelas User dengan properti username, password, dan metode login().

class User {
    public $username;
    private $password;

    public function __construct($username, $password) {
        $this->username = $username;
        $this->password = password_hash($password, PASSWORD_DEFAULT);
    }

    public function login($password) {
        if (password_verify($password, $this->password)) {
            return "Login berhasil!";
        }
        return "Login gagal!";
    }
}

Dalam kasus ini:

• username dibuat public karena memang sering dibutuhkan secara terbuka.
• password dibuat private agar tidak bisa diakses sembarangan.
• Metode login() dibuat public karena harus bisa dipanggil dari luar untuk proses autentikasi.

Dengan desain seperti ini, Anda bisa menjaga agar data sensitif tetap aman, namun tetap memberikan akses yang diperlukan.

---

Studi Kasus Lanjutan: Sistem E-Commerce

Bayangkan kita sedang mengembangkan aplikasi e-commerce sederhana. Di dalamnya, terdapat kelas Produk yang akan digunakan untuk menampilkan barang, menghitung harga setelah diskon, serta menjaga data harga agar tidak bisa sembarangan diubah.

class Produk {
    public $nama;
    private $harga;
    protected $stok;

    public function __construct($nama, $harga, $stok) {
        $this->nama = $nama;
        $this->harga = $harga;
        $this->stok = $stok;
    }

    public function getHarga() {
        return "Rp " . number_format($this->harga, 0, ',', '.');
    }

    protected function kurangiStok($jumlah) {
        if ($this->stok >= $jumlah) {
            $this->stok -= $jumlah;
            return true;
        }
        return false;
    }
}

class Keranjang {
    private $items = [];

    public function tambahProduk(Produk $produk, $jumlah) {
        $this->items[] = [
            'produk' => $produk,
            'jumlah' => $jumlah
        ];
    }

    public function checkout() {
        foreach ($this->items as $item) {
            echo "Membeli " . $item['produk']->nama . " sebanyak " . $item['jumlah'] . "<br>";
        }
    }
}

Dalam studi kasus ini:

• Properti nama dibuat public agar bisa ditampilkan langsung ke pengguna.
• Properti harga bersifat private sehingga tidak bisa dimanipulasi langsung, melainkan hanya melalui getHarga().
• Properti stok bersifat protected agar hanya bisa dikelola oleh kelas itu sendiri atau turunan, misalnya jika nanti ada kelas Gudang yang ingin memodifikasi stok.

Pendekatan ini membuat sistem lebih aman sekaligus terorganisir, karena setiap properti memiliki jalur akses yang sesuai.

---

Kapan Sebaiknya Menggunakan Public, Private, dan Protected?

Pemilihan visibility tidak ada aturan baku yang kaku, tetapi ada beberapa praktik umum yang bisa dijadikan acuan:

1. Gunakan public untuk metode yang memang akan menjadi antarmuka utama kelas. Misalnya login(), getHarga(), atau checkout().
2. Gunakan private untuk data yang sifatnya sensitif atau logika internal yang tidak boleh disentuh pihak lain. Misalnya password, apiKey, atau metode encryptData().
3. Gunakan protected ketika Anda ingin memberi keleluasaan bagi kelas turunan untuk mengakses atau memodifikasi data, tanpa membiarkannya terekspos ke luar.

Dengan aturan sederhana ini, kode akan lebih aman, terstruktur, dan mudah dikembangkan oleh tim lain di masa depan.

---

Contoh Pola Getter dan Setter

Salah satu cara populer untuk mengontrol akses properti private adalah dengan menyediakan getter dan setter. Pola ini membantu memastikan data hanya berubah sesuai aturan yang kita buat.

class Produk {
    private $harga;

    public function setHarga($harga) {
        if ($harga > 0) {
            $this->harga = $harga;
        } else {
            throw new Exception("Harga harus lebih besar dari 0");
        }
    }

    public function getHarga() {
        return $this->harga;
    }
}

$produk = new Produk();
$produk->setHarga(50000);  // Aman karena tervalidasi
echo $produk->getHarga();  // Output: 50000

Dengan cara ini, data internal tetap terlindungi, tetapi tetap fleksibel untuk diakses melalui jalur resmi yang kita sediakan.

---

Dampak Jangka Panjang dalam Pengembangan

Di proyek kecil, perbedaan public, private, dan protected mungkin terasa sepele. Namun, ketika aplikasi tumbuh besar dan dikerjakan oleh banyak orang, penerapan visibility yang benar akan sangat menentukan kualitas kode.

Bayangkan sebuah aplikasi dengan ribuan baris kode dan ratusan kelas. Jika semua properti dibuat public, developer lain bisa dengan mudah mengakses dan mengubahnya. Ketika ada bug, mencari sumber masalah menjadi mimpi buruk karena data bisa berubah dari banyak titik. Sebaliknya, dengan menerapkan encapsulation yang baik, kita bisa membatasi titik akses, sehingga debugging dan pemeliharaan menjadi lebih mudah.

---

Analogi Sederhana: Rumah dan Akses Pintu

Untuk lebih memudahkan pemahaman, mari kita gunakan analogi rumah:

• Public seperti ruang tamu. Semua orang bisa masuk, melihat, bahkan berinteraksi.
• Private seperti kamar tidur. Hanya pemilik rumah yang boleh masuk.
• Protected seperti dapur. Anggota keluarga boleh masuk, tetapi tamu dari luar tidak bisa sembarangan masuk.

Dengan analogi ini, kita bisa membayangkan bahwa tidak semua bagian rumah (atau kelas dalam kode) boleh diakses sembarangan. Ada area publik, area semi-privat, dan area pribadi yang benar-benar dilindungi.