C# - Enkapsulasi: Panduan untuk Pemula

Halo teman-teman, super bintang coding masa depan! Hari ini, kita akan memulai sebuah perjalanan menarik ke dunia C# dan menjelajahi salah satu konsep fundamentalnya: Enkapsulasi. Jangan khawatir jika Anda belum pernah menulis baris kode sebelumnya - saya disini untuk mengarahkan Anda setiap langkahnya. mari kita masuk ke dalam!

Apa Itu Enkapsulasi?

Sebelum kita masuk ke detilnya, mari kita pahami apa yang dimaksudkan oleh enkapsulasi. Bayangkan Anda memiliki sebuah kotak ajaib yang bisa melakukan hal-hal menakjubkan, tapi Anda tidak perlu tahu bagaimana kerjanya dalam - Anda hanya perlu tahu bagaimana menggunakannya. Itu saja enkapsulasi dalam bentuk ringkas!

Dalam C#, enkapsulasi adalah tentang membundelkan data (variabel) dan metode yang bekerja pada data itu dalam satu unit atau objek. Itu seperti membuat kapsul pelindung di sekitar kode Anda, sehingga dinamai "enkapsulasi".

Sekarang, mari kita jelajahi bagaimana C# implementasikan enkapsulasi melalui spesifikator akses.

Spesifikator Akses di C

Spesifikator akses adalah kata kunci yang menentukan ketersediaan sebuah kelas, metode, atau properti dalam kode Anda. Pahamiannya seperti level keamanan berbeda. C# menyediakan lima spesifikator akses utama:

1. Public
2. Private
3. Protected
4. Internal
5. Protected Internal

Mari kita rincikan satu per satu.

Spesifikator Akses Public

Kata kunci public seperti suatu "pass akses semua area". Ketika Anda mendeklarasikan suatu anggota sebagai public, itu dapat diakses dari semua bagian program Anda.

public class Person
{
public string Name { get; set; }

public void SayHello()
{
Console.WriteLine($"Hello, my name is {Name}!");
}
}

class Program
{
static void Main(string[] args)
{
Person person = new Person();
person.Name = "Alice";  // Mengakses properti public
person.SayHello();  // Memanggil metode public
}
}

Dalam contoh ini, baik Name maupun SayHello() adalah public, jadi kita dapat mengaksesnya langsung dari metode Main.

Spesifikator Akses Private

Sekarang, private seperti suatu "area khusus pegawai". Anggota private hanya dapat diakses dalam kelas yang sama.

public class BankAccount
{
private double balance;

public void Deposit(double amount)
{
if (amount > 0)
{
balance += amount;
}
}

public double GetBalance()
{
return balance;
}
}

class Program
{
static void Main(string[] args)
{
BankAccount account = new BankAccount();
account.Deposit(100);
// account.balance = 1000000;  // Ini akan menyebabkan kesalahan!
Console.WriteLine($"Balance: {account.GetBalance()}");
}
}

Di sini, balance adalah private, jadi kita tidak dapat mengaksesnya langsung dari luar kelas BankAccount. Kita harus menggunakan metode public seperti Deposit() dan GetBalance() untuk berinteraksi dengannya.

Spesifikator Akses Protected

protected dapat diakses dalam kelas yang sama dan oleh kelas turunan. Itu seperti suatu "bagian keluarga saja".

public class Animal
{
protected string name;

public Animal(string name)
{
this.name = name;
}

protected void Eat()
{
Console.WriteLine($"{name} is eating.");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name) { }

public void Bark()
{
Console.WriteLine($"{name} is barking!");  // Bisa mengakses anggota protected
Eat();  // Bisa memanggil metode protected
}
}

class Program
{
static void Main(string[] args)
{
Dog dog = new Dog("Buddy");
dog.Bark();
// dog.name = "Max";  // Ini akan menyebabkan kesalahan!
// dog.Eat();  // Ini juga akan menyebabkan kesalahan!
}
}

Dalam contoh ini, Dog dapat mengakses name dan metode Eat() dari kelas induk Animal, tapi kita tidak dapat mengakses ini langsung dari Main.

Spesifikator Akses Internal

internal dapat diakses dalam assembly yang sama (bayangkan assembly seperti sebuah file .dll atau .exe yang dikompilasi). Itu seperti suatu "area karyawan perusahaan saja".

// Dalam AssemblyOne.cs
internal class InternalClass
{
internal void InternalMethod()
{
Console.WriteLine("This is an internal method.");
}
}

// Dalam Program.cs (assembly yang sama)
class Program
{
static void Main(string[] args)
{
InternalClass obj = new InternalClass();
obj.InternalMethod();  // Ini bisa!
}
}

// Dalam assembly yang berbeda, ini tidak akan bekerja:
// InternalClass obj = new InternalClass();  // Kesalahan!

Spesifikator Akses Protected Internal

Akhirnya, protected internal adalah kombinasi dari protected dan internal. Itu dapat diakses dalam assembly yang sama atau oleh kelas turunan di assembly lain.

// Dalam AssemblyOne.cs
public class BaseClass
{
protected internal void ProtectedInternalMethod()
{
Console.WriteLine("This is a protected internal method.");
}
}

// Dalam AssemblyTwo.cs
public class DerivedClass : BaseClass
{
public void CallProtectedInternalMethod()
{
ProtectedInternalMethod();  // Ini bisa!
}
}

// Dalam Program.cs (AssemblyTwo)
class Program
{
static void Main(string[] args)
{
DerivedClass obj = new DerivedClass();
obj.CallProtectedInternalMethod();
// obj.ProtectedInternalMethod();  // Ini tidak akan bekerja!
}
}

Ringkasan Spesifikator Akses

Berikut adalah tabel ringkasan level akses:

Spesifikator Akses	Kelas Sama	Kelas Turunan (Assembly Sama)	Kelas Non-Turunan (Assembly Sama)	Kelas Turunan (Assembly Berbeda)	Kelas Non-Turunan (Assembly Berbeda)
Public	Ya	Ya	Ya	Ya	Ya
Private	Ya	Tidak	Tidak	Tidak	Tidak
Protected	Ya	Ya	Tidak	Ya	Tidak
Internal	Ya	Ya	Ya	Tidak	Tidak
Protected Internal	Ya	Ya	Ya	Ya	Tidak

Dan begitulah! Anda baru saja mengambil langkah pertama ke dunia enkapsulasi dalam C#. Ingat, enkapsulasi tentang mengontrol akses ke kode dan data Anda. Itu membantu Anda menulis program yang lebih aman, mudah dipelihara, dan fleksibel.

Sebagai Anda terus melanjutkan perjalanan coding Anda, Anda akan menemukan bahwa enkapsulasi menjadi kebiasaan. Itu seperti belajar menunggang sepeda - awalnya agak bergoyang, tapi segera Anda akan berjalan tanpa berpikir tentangnya!

Tetap latihan, tetap ciek, dan selamat coding!

Credits: Image by storyset