Masukkan Password
39 Pengubah Akses (Access Modifiers)
Lecture ini membahas salah satu konsep penting dalam OOP TypeScript, yaitu access modifiers. Intinya adalah bagaimana kita mengatur siapa yang boleh mengakses atau mengubah property dan method di dalam sebuah class.
Kalau sebelumnya kita belajar bahwa sebuah class punya property dan method, sekarang kita belajar bahwa tidak semua property/method harus bisa diakses oleh semua orang.
1. Masalah yang ingin diselesaikan
Di lecture ini dibuat sebuah class Employee.
Misalnya employee memiliki:
name→ nama karyawansalary→ gajilocation→ lokasi kerjaisEligible→ apakah berhak mendapat kenaikan gajihikePercentage→ persentase kenaikan gaji
Secara sederhana:
class Employee {
name: string;
salary: number;
location: string;
isEligible: boolean;
hikePercentage: number;
constructor(
name: string,
salary: number,
location: string,
isEligible: boolean,
hikePercentage: number
) {
this.name = name;
this.salary = salary;
this.location = location;
this.isEligible = isEligible;
this.hikePercentage = hikePercentage;
}
}
Kemudian dibuat object:
const employee = new Employee(
"John Smith",
10000,
"London",
true,
20
);
Sekarang employee adalah sebuah instance/object dari class Employee.
2. Masalahnya: semua property bisa diakses dari luar
Karena kita belum memberikan access modifier apa pun, property-property tersebut secara default bersifat public.
Artinya kita bisa melakukan:
console.log(employee.salary);
Hasil:
10000
Bukan hanya membaca, kita juga bisa mengubahnya:
employee.salary = 20000;
Kemudian:
console.log(employee.salary);
Hasilnya:
20000
Padahal kita mungkin tidak ingin sembarang kode bisa mengubah salary.
3. Kenapa ini menjadi masalah?
Bayangkan kita punya sistem perusahaan.
Misalnya:
const employee = new Employee(
"John Smith",
10000,
"London",
true,
20
);
Kemudian ada programmer lain yang menulis:
employee.salary = 1000000;
Sekarang salary John berubah menjadi:
1,000,000
Padahal mungkin salary seharusnya hanya bisa ditentukan oleh sistem HR.
Inilah salah satu alasan kita membutuhkan access modifiers.
4. Apa itu Access Modifier?
Access modifier adalah aturan yang menentukan dari mana sebuah property atau method boleh diakses.
Dalam lecture ini dibahas dua access modifier:
public
private
Secara sederhana:
public
↓
boleh diakses dari mana saja
private
↓
hanya boleh diakses dari dalam class
5. public
public berarti property atau method tersebut boleh diakses dari mana saja.
Contoh:
class Employee {
public name: string;
constructor(name: string) {
this.name = name;
}
}
Kemudian:
const employee = new Employee("John");
console.log(employee.name);
Boleh.
Kita juga bisa mengubahnya:
employee.name = "Michael";
Boleh.
Jadi:
Employee class
│
├── name
│
└── PUBLIC
│
├── bisa diakses dari dalam class
│
└── bisa diakses dari luar class
6. private
Sekarang kita masuk ke bagian yang lebih penting.
Misalnya kita tidak ingin salary diakses dari luar class.
Kita bisa menulis:
class Employee {
public name: string;
private salary: number;
constructor(name: string, salary: number) {
this.name = name;
this.salary = salary;
}
}
Perhatikan:
private salary: number;
Dengan private, salary hanya boleh digunakan di dalam class Employee.
7. Apa yang terjadi kalau diakses dari luar?
Misalnya:
const employee = new Employee("John", 10000);
console.log(employee.salary);
TypeScript akan memberikan error.
Kurang lebih:
Property 'salary' is private
and only accessible within class 'Employee'.
Artinya:
Property
salarybersifat private dan hanya bisa diakses dari dalam classEmployee.
Jadi ini tidak boleh:
employee.salary = 20000;
Karena kita sedang mencoba mengakses salary dari luar class.
8. Gambaran sederhananya
Bayangkan sebuah rumah.
Public
Pintu depan rumah seperti sesuatu yang public.
Orang dari luar bisa mengaksesnya.
PUBLIC
Orang luar
↓
┌─────────────┐
│ RUMAH │
│ │
│ pintu ←──┼── bisa masuk
│ │
└─────────────┘
Private
Sekarang bayangkan brankas yang ada di dalam kamar pribadi.
Orang dari luar tidak boleh langsung mengaksesnya.
PRIVATE
Orang luar
│
X
│
┌───▼─────────────┐
│ RUMAH │
│ │
│ ┌────────┐ │
│ │BRANKAS │ │
│ └────────┘ │
│ │
└─────────────────┘
salary bisa kita anggap seperti brankas.
Kita tidak ingin:
employee.salary = 999999;
dilakukan sembarangan.
9. Tapi kalau private, bagaimana class bisa menggunakan salary?
Nah, ini penting.
private bukan berarti property tidak bisa digunakan sama sekali.
Private hanya berarti:
Tidak boleh diakses dari luar class.
Di dalam class sendiri, kita tetap boleh menggunakannya.
Contohnya:
class Employee {
private salary: number;
constructor(salary: number) {
this.salary = salary;
}
getSalary() {
return this.salary;
}
}
Perhatikan:
return this.salary;
Ini valid.
Kenapa?
Karena getSalary() berada di dalam class Employee.
Jadi:
Employee class
┌────────────────────────────┐
│ │
│ private salary │
│ ↑ │
│ │ │
│ getSalary() ───────────────┘
│ │
└────────────────────────────┘
↓
dari luar
❌ tidak boleh
10. this kembali digunakan
Di sini kita juga melihat konsep this yang sudah dipelajari sebelumnya.
Misalnya:
class Employee {
private salary: number;
constructor(salary: number) {
this.salary = salary;
}
getSalary() {
return this.salary;
}
}
this.salary berarti:
salary milik object Employee yang sedang digunakan.
Misalnya:
const employee = new Employee(10000);
Maka:
employee.getSalary();
di dalam getSalary():
this.salary
mengacu pada:
employee.salary
11. Kenapa lecture membuat getSalary()?
Karena kita ingin menyembunyikan property tertentu tetapi tetap menyediakan cara yang aman untuk menggunakannya.
Misalnya:
private salary: number;
Tidak bisa:
employee.salary
Tetapi kita bisa menyediakan:
getSalary()
Jadi:
employee.getSalary();
Misalnya hasilnya:
10000
Ini adalah salah satu ide penting dalam OOP:
Data tertentu disembunyikan, tetapi kita menyediakan method untuk berinteraksi dengannya.
Konsep seperti ini berkaitan dengan encapsulation.
12. Method getSalary() dalam lecture
Di lecture, getSalary() tidak sekadar mengembalikan salary.
Dia melakukan perhitungan terlebih dahulu.
Kurang lebih:
getSalary() {
if (this.isEligible) {
const hike =
this.salary * this.hikePercentage / 100;
return this.salary + hike;
}
return this.salary;
}
Mari kita pecah.
Bagian pertama
if (this.isEligible)
Artinya:
Apakah employee ini berhak mendapatkan kenaikan gaji?
Misalnya:
isEligible = true
Maka masuk ke dalam if.
Kemudian menghitung kenaikan
this.salary * this.hikePercentage / 100
Misalnya:
salary = 10,000
hikePercentage = 20
Maka:
10,000 × 20 / 100
= 2,000
Jadi kenaikannya:
2,000
Kemudian ditambahkan ke salary
this.salary + hike
Menjadi:
10,000 + 2,000
= 12,000
Jadi:
employee.getSalary();
menghasilkan:
12000
13. Kemudian lecture membuat getNewSalary()
Lecture kemudian memindahkan logic perhitungan ke method lain:
getNewSalary() {
const hike =
this.salary * this.hikePercentage / 100;
return this.salary + hike;
}
Kemudian:
getSalary() {
if (this.isEligible) {
return this.getNewSalary();
}
return this.salary;
}
Perhatikan:
this.getNewSalary()
Kembali kita menggunakan this.
Kenapa?
Karena getNewSalary() adalah method milik object/class tersebut.
14. Kenapa getNewSalary() dibuat private?
Nah, ini contoh penggunaan private untuk method, bukan hanya property.
Kita bisa menulis:
private getNewSalary() {
const hike =
this.salary * this.hikePercentage / 100;
return this.salary + hike;
}
Sekarang method tersebut hanya boleh dipanggil dari dalam class.
Misalnya ini:
class Employee {
private salary: number;
private getNewSalary() {
// ...
}
getSalary() {
return this.getNewSalary();
}
}
Boleh.
Karena:
getSalary()
│
↓
getNewSalary()
keduanya berada dalam Employee.
15. Tapi dari luar tidak boleh
Misalnya:
const employee = new Employee(...);
Kemudian:
employee.getNewSalary();
TypeScript akan error.
Karena:
getNewSalary()
adalah:
private
Jadi tidak terlihat/tersedia dari luar class.
16. Kenapa melakukan ini?
Ini sebenarnya desain yang sangat bagus.
Bayangkan kita punya API sederhana:
User dari luar
│
↓
getSalary()
│
↓
Employee
│
├── cek eligibility
│
├── hitung hike
│
├── ambil salary
│
└── return hasil
User cukup mengatakan:
employee.getSalary();
User tidak perlu tahu bagaimana proses internalnya.
Dia juga tidak bisa mengakses bagian internal tertentu.
Ini adalah salah satu ide dasar encapsulation:
Sembunyikan detail internal dan hanya expose bagian yang memang diperlukan.
17. Public vs Private
Ini bagian yang paling penting untuk diingat.
| Access Modifier | Dari dalam class | Dari luar class |
|---|---|---|
public | ✅ | ✅ |
private | ✅ | ❌ |
Contoh:
class Employee {
public name: string;
private salary: number;
constructor(name: string, salary: number) {
this.name = name;
this.salary = salary;
}
public getSalary() {
return this.salary;
}
private calculateSalary() {
return this.salary * 1.2;
}
}
Dari luar:
employee.name;
✅ boleh
employee.getSalary();
✅ boleh
employee.salary;
❌ tidak boleh
employee.calculateSalary();
❌ tidak boleh
18. Bagaimana kalau kita tidak menulis public?
Ini juga dibahas dalam lecture.
Misalnya kita menulis:
class Employee {
name: string;
getSalary() {
// ...
}
}
Tanpa menulis:
public
Property dan method tersebut secara default adalah public.
Jadi ini:
name: string;
secara konsep sama dengan:
public name: string;
Dan ini:
getSalary() {
// ...
}
sama dengan:
public getSalary() {
// ...
}
19. Jadi apakah harus selalu menulis public?
Tidak harus.
Kita bisa menulis:
class Employee {
name: string;
salary: number;
getSalary() {
// ...
}
}
Karena default-nya public.
Atau secara eksplisit:
class Employee {
public name: string;
public salary: number;
public getSalary() {
// ...
}
}
Keduanya pada dasarnya memiliki access level public.
Namun banyak programmer memilih menulis public jika ingin memperjelas maksud desain class.
20. Contoh class lengkap
Kalau kita gabungkan konsep lecture:
class Employee {
name: string;
private salary: number;
location: string;
isEligible: boolean;
private hikePercentage: number;
constructor(
name: string,
salary: number,
location: string,
isEligible: boolean,
hikePercentage: number
) {
this.name = name;
this.salary = salary;
this.location = location;
this.isEligible = isEligible;
this.hikePercentage = hikePercentage;
}
getSalary() {
if (this.isEligible) {
return this.getNewSalary();
}
return this.salary;
}
private getNewSalary() {
const hike =
this.salary * this.hikePercentage / 100;
return this.salary + hike;
}
}
Kemudian:
const employee = new Employee(
"John Smith",
10000,
"London",
true,
20
);
Kita bisa:
console.log(employee.name);
Hasil:
John Smith
Kita bisa:
console.log(employee.location);
Hasil:
London
Kita bisa:
console.log(employee.getSalary());
Hasil:
12000
Tetapi:
employee.salary = 20000;
❌ Error.
Dan:
employee.hikePercentage = 50;
❌ Error.
Serta:
employee.getNewSalary();
❌ Error.
21. Hal yang sangat penting: private bukan berarti “tidak pernah bisa disentuh”
Ini sering membingungkan pemula.
Misalnya:
private salary: number;
Bukan berarti salary tidak boleh digunakan sama sekali.
Yang benar:
salary
│
┌────────┴────────┐
│ │
Di dalam class Di luar class
│ │
✅ ❌
Jadi class sendiri masih bisa:
this.salary
Tetapi kode dari luar tidak bisa:
employee.salary
22. Analogi paling mudah: ATM
Bayangkan object BankAccount.
Ada:
balance
withdraw()
deposit()
Kita tentu tidak ingin user bebas melakukan:
account.balance = 999999999;
Karena itu bisa dibuat:
class BankAccount {
private balance: number;
constructor(balance: number) {
this.balance = balance;
}
getBalance() {
return this.balance;
}
deposit(amount: number) {
this.balance += amount;
}
withdraw(amount: number) {
this.balance -= amount;
}
}
User tidak langsung mengubah balance.
Dia menggunakan method yang disediakan:
account.deposit(1000);
atau:
account.withdraw(500);
Jadi class bisa mengontrol bagaimana data internal diubah.
23. Ini sebenarnya menuju konsep Encapsulation
Access modifier sangat erat hubungannya dengan encapsulation.
Secara sederhana:
Encapsulation adalah konsep membungkus data dan logic di dalam sebuah object/class serta mengontrol bagaimana bagian tersebut dapat diakses dari luar.
Contohnya:
Employee
┌─────────────────────────┐
│ │
│ name PUBLIC │ ← bisa diakses
│ location PUBLIC │ ← bisa diakses
│ getSalary() PUBLIC │ ← bisa dipanggil
│ │
│ salary PRIVATE │ ← disembunyikan
│ hikePercentage PRIVATE │ ← disembunyikan
│ getNewSalary() PRIVATE │ ← disembunyikan
│ │
└─────────────────────────┘
Jadi kita menentukan:
“Bagian mana yang boleh diketahui/digunakan oleh dunia luar?”
dan:
“Bagian mana yang merupakan urusan internal class?”
24. Cara berpikir yang bagus saat menentukan public/private
Saat membuat class, tanyakan:
Pertanyaan 1
Apakah bagian ini memang perlu digunakan oleh kode dari luar?
Kalau iya, mungkin:
public
Pertanyaan 2
Apakah ini hanya detail implementasi internal?
Kalau iya, mungkin:
private
Contohnya:
getSalary()
mungkin public karena kita ingin user meminta salary.
Tetapi:
calculateHike()
mungkin private karena itu hanya proses internal.
25. Ringkasan lecture
Konsep utama yang perlu kamu ingat:
1. Access modifier
Digunakan untuk menentukan siapa yang boleh mengakses property atau method.
2. public
public name: string;
Bisa diakses:
dari dalam class ✅
dari luar class ✅
3. private
private salary: number;
Bisa diakses:
dari dalam class ✅
dari luar class ❌
4. Tanpa access modifier
name: string;
Secara default:
public name: string;
5. Private tidak hanya untuk property
Method juga bisa private:
private getNewSalary() {
...
}
6. this tetap digunakan
Untuk mengakses property atau method milik object saat berada di dalam class:
this.salary
this.hikePercentage
this.getNewSalary()
🧠 Mental model paling sederhana
Kalau kamu ingin mengingat lecture ini dengan satu gambaran:
CLASS
│
├── PUBLIC
│ ├── bisa dilihat dari luar
│ ├── bisa dipanggil dari luar
│ └── bagian yang memang ingin kita expose
│
└── PRIVATE
├── hanya untuk internal class
├── tidak bisa diakses langsung dari luar
└── menyembunyikan detail implementasi
Atau kalimat super sederhananya:
public= “silakan akses dari luar.”private= “ini urusan internal class, jangan akses langsung dari luar.”
Dan inilah dasar penting sebelum masuk ke konsep OOP TypeScript yang lebih lanjut seperti protected, inheritance, getter/setter, abstract class, dan encapsulation.
Saya juga bisa membuat diagram visual alur public vs private supaya konsep ini lebih mudah diingat.