Belajar C# - Classes, Objects & OOP

#Pendahuluan

C# adalah bahasa yang berorientasi objek secara fundamental: hampir semua kode yang kalian tulis hidup di dalam class. Memahami OOP bukan sekadar hafal sintaks — ini tentang cara memodelkan domain bisnis menjadi unit-unit yang kohesif dan mudah dirawat.

Episode 4 membawa kalian dari konsep paling dasar hingga pola modern C#. Kita mulai dengan class dan object, lalu enkapsulasi, inheritance, polymorphism, abstract class, dan interface, kemudian menutup dengan record types yang mengubah cara C# menangani data. Semua contoh bisa kalian coba langsung dengan dotnet run.

Jika episode 3 adalah kosakata bahasa, episode 4 adalah tata bahasanya — struktur yang akan kalian pakai di hampir semua kode produksi.

#Class, Object, dan Constructor

#Membuat Class dan Instansiasi

Class adalah cetak biru, object adalah wujud nyatanya. Sebuah class mendefinisikan field, properties, dan method, lalu di-instansiasi dengan keyword new:

class Produk
{
    public string Nama { get; }
    public decimal Harga { get; }
 
    public Produk(string nama, decimal harga)
    {
        Nama = nama;
        Harga = harga;
    }
 
    public decimal HargaSetelahPajak() => Harga * 1.11m;
}
 
var p = new Produk("Kopi Gayo", 85_000m);
Console.WriteLine(p.HargaSetelahPajak());

#Constructor dan Object Initializer

Constructor menjamin object selalu dalam keadaan valid sejak lahir. Untuk class dengan banyak field, kalian bisa memakai object initializer alih-alih constructor berparametrik panjang:

var pesanan = new Pesanan
{
    Nomor = "INV-001",
    Total = 250_000m,
    Status = "Menunggu Pembayaran"
};
 
Console.WriteLine($"{pesanan.Nomor} | {pesanan.Total:C}");

Object initializer new Pesanan { Nomor = "INV-001" } membutuhkan properties dengan setter yang dapat diakses. Pola ini membuat kode kalian terbaca seperti deklarasi data.

#Enkapsulasi dan Access Modifiers

#Access Modifiers

Enkapsulasi berarti menyembunyikan detail internal dan hanya membuka antarmuka yang diperlukan. Modifier akses di C#:

• public: bisa diakses dari mana saja.
• private: hanya di dalam class itu sendiri.
• protected: class turunan masih bisa mengakses.
• internal: hanya dalam assembly yang sama.

#Properties dengan Validasi

Properties memberikan kontrol penuh saat nilai dibaca atau diubah, tanpa mengubah cara pemanggil berinteraksi:

class Rekening
{
    private decimal _saldo;
 
    public decimal Saldo
    {
        get => _saldo;
        private set
        {
            if (value < 0) throw new ArgumentException("Saldo tidak boleh negatif.");
            _saldo = value;
        }
    }
 
    public void Deposit(decimal jumlah) => Saldo += jumlah;
}

Perhatikan keyword private set di atas — pemanggil di luar class bisa membaca Saldo, tapi hanya method di dalam class yang bisa mengubahnya. Inilah enkapsulasi yang benar.

#Inheritance dan Polymorphism

#Pewarisan dan Overriding

C# mendukung inheritance tunggal: satu class hanya bisa menurunkan dari satu class dasar, namun bisa mengimplementasikan banyak interface. Method virtual bisa di-override oleh class turunan:

class Hewan
{
    public virtual string Suara() => "Hmm";
}
 
class Kucing : Hewan
{
    public override string Suara() => "Meow";
}
 
class Anjing : Hewan
{
    public override string Suara() => "Guk";
}

Polymorphism bekerja saat kalian memanggil method melalui tipe dasar — masing-masing object menjalankan versi miliknya sendiri.

#Abstract Class dan Interface

Abstract class menyediakan sebagian implementasi yang harus dilengkapi turunan. Interface hanya mendeklarasikan kontrak tanpa implementasi. Aturan praktis: gunakan abstract class untuk berbagi kode bersama, dan interface untuk mendefinisikan kemampuan:

interface IDeskripsi
{
    string Deskripsi();
}
 
abstract class AlatTulis
{
    public string Merk { get; set; }
    public abstract string Fungsi();
}
 
class Pulpen : AlatTulis, IDeskripsi
{
    public override string Fungsi() => "Menulis di atas kertas";
    public string Deskripsi() => $"Pulpen {Merk}";
}

Class Pulpen meng-extend satu class dan meng-implementasikan satu interface. Pattern ini adalah tulang punggung desain SOLID yang akan kita pakai di episode 16.

#Record Types dan Immutable Data

#Data yang Tidak Berubah

Untuk data yang tidak berubah (immutable), C# 9 memperkenalkan record. Record memberikan value equality otomatis — dua record dianggap sama jika semua propertinya sama — plus sintaks deklarasi yang ringkas:

record Alamat(string Jalan, string Kota, string KodePos);
 
record Pengguna
{
    public required string Nama { get; init; }
    public int Umur { get; init; }
}
 
var a = new Alamat("Jl. Merdeka 1", "Bandung", "40112");
var b = a with { Kota = "Jakarta" };
Console.WriteLine(a == new Alamat("Jl. Merdeka 1", "Bandung", "40112"));

Operator with membuat salinan record dengan satu atau beberapa nilai yang diubah — cara aman menangani data tanpa mutasi. Keyword required memaksa pemanggil mengisi property saat inisialisasi.

#Penutup

Inti yang harus dibawa pulang:

• Class adalah cetak biru; object diciptakan dengan new.
• Enkapsulasi dijaga dengan access modifiers dan properties ber-validasi.
• C# punya inheritance tunggal plus interface majemuk.
• Abstract class untuk berbagi implementasi; interface untuk kontrak.
• Record cocok untuk data immutable dengan value equality otomatis.

Di episode 5 selanjutnya kita memperluas kotak alat tipe: advanced types dan collections — struct, enum, tuple, nullable types, array, List, Dictionary, HashSet, dasar LINQ, serta nullable reference types untuk null safety.