Pemrograman Berorientasi Objek di Bahasa C#
Pemrograman Berorientasi Objek di Bahasa C#
Pemrograman Berorientasi Objek (Object-Oriented Programming, OOP) adalah paradigma pemrograman yang menggunakan objek sebagai dasar utama dalam mengorganisir program. OOP bertujuan untuk memecah program menjadi modul-modul yang lebih kecil, yang disebut dengan objek, yang memiliki data (atribut/properti) dan fungsi (metode) yang saling berhubungan.
Objek-objek ini didasarkan pada class yang mendefinisikan cetak biru (template) untuk membuat objek-objek serupa.
Terdapat empat pilar utama dalam OOP, yaitu:
Encapsulation (Enkapsulasi)
Inheritance (Pewarisan)
Polymorphism (Polimorfisme)
Abstraction (Abstraksi)
Class: Cetak biru atau template untuk membuat objek. Class mendefinisikan atribut dan metode yang dimiliki oleh objek. Di C#, class dideklarasikan dengan kata kunci class.
Object: Instance dari class. Setelah class didefinisikan, kita dapat membuat objek dari class tersebut dan menggunakan data serta metode yang dideklarasikan di dalamnya.
Contoh:
public class Mobil
{
// Atribut (fields)
public string merk;
public int tahun;
// Metode (methods)
public void TampilkanInfo()
{
Console.WriteLine($"Merk: {merk}, Tahun: {tahun}");
}
}
class Program
{
static void Main(string[] args)
{
// Membuat objek dari class Mobil
Mobil mobilSaya = new Mobil();
mobilSaya.merk = "Toyota";
mobilSaya.tahun = 2020;
// Menggunakan metode objek
mobilSaya.TampilkanInfo();
}
}
Enkapsulasi adalah proses menyembunyikan data internal dari akses langsung dari luar dan hanya memperbolehkan interaksi melalui metode yang disediakan. Di C#, enkapsulasi diimplementasikan menggunakan modifier akses seperti private, public, protected, dan internal.
Contoh:
public class BankAccount
{
// Field privat yang tidak bisa diakses langsung dari luar
private double balance;
// Metode publik untuk mengakses balance
public double GetBalance()
{
return balance;
}
public void Deposit(double amount)
{
if (amount > 0)
{
balance += amount;
}
}
}
class Program
{
static void Main(string[] args)
{
BankAccount account = new BankAccount();
account.Deposit(1000);
Console.WriteLine($"Saldo: {account.GetBalance()}");
}
}
Di sini, field balance disembunyikan dari akses langsung, dan hanya dapat diubah menggunakan metode Deposit dan diambil menggunakan metode GetBalance.
Pewarisan memungkinkan suatu class baru (subclass/child class) untuk mewarisi atribut dan metode dari class yang sudah ada (superclass/parent class). C# menggunakan simbol : untuk mendefinisikan pewarisan.
Contoh:
public class Hewan
{
public void Makan()
{
Console.WriteLine("Hewan sedang makan.");
}
}
// Class Kucing mewarisi class Hewan
public class Kucing : Hewan
{
public void Suara()
{
Console.WriteLine("Kucing mengeong.");
}
}
class Program
{
static void Main(string[] args)
{
Kucing kucingSaya = new Kucing();
kucingSaya.Makan(); // Memanggil metode dari class Hewan
kucingSaya.Suara(); // Memanggil metode dari class Kucing
}
}
Pada contoh di atas, class Kucing mewarisi semua metode dan atribut dari class Hewan, sehingga metode Makan dapat digunakan oleh objek Kucing.
Polimorfisme memungkinkan satu metode atau atribut memiliki banyak bentuk. Ada dua jenis polimorfisme:
Polimorfisme waktu kompilasi (Compile-time polymorphism) atau overloading.
Polimorfisme waktu eksekusi (Run-time polymorphism) atau overriding.
a. Overloading (Metode dengan Nama yang Sama tetapi Tanda Tangan Berbeda)
Overloading terjadi ketika dua atau lebih metode dalam satu class memiliki nama yang sama tetapi dengan parameter yang berbeda.
Contoh:
public class Calculator
{
// Overloading metode Tambah
public int Tambah(int a, int b)
{
return a + b;
}
public double Tambah(double a, double b)
{
return a + b;
}
}
class Program
{
static void Main(string[] args)
{
Calculator calc = new Calculator();
Console.WriteLine(calc.Tambah(2, 3)); // Memanggil metode Tambah(int, int)
Console.WriteLine(calc.Tambah(2.5, 3.5)); // Memanggil metode Tambah(double, double)
}
}
b. Overriding (Menimpa Metode dari Parent Class)
Overriding adalah proses mendefinisikan ulang metode yang ada dalam superclass di subclass. Ini memungkinkan subclass untuk memberikan implementasi spesifik dari metode yang ada di superclass.
Contoh:
public class Hewan
{
public virtual void Suara()
{
Console.WriteLine("Hewan bersuara.");
}
}
public class Kucing : Hewan
{
// Overriding metode Suara
public override void Suara()
{
Console.WriteLine("Kucing mengeong.");
}
}
class Program
{
static void Main(string[] args)
{
Hewan hewan = new Hewan();
hewan.Suara(); // Output: Hewan bersuara.
Kucing kucing = new Kucing();
kucing.Suara(); // Output: Kucing mengeong.
}
}
Abstraksi adalah konsep menyembunyikan detail implementasi dari pengguna dan hanya menunjukkan fungsionalitas penting. Abstraksi dalam C# bisa diimplementasikan menggunakan abstract class atau interface.
a. Abstract Class
Class abstrak tidak bisa diinstansiasi dan bisa memiliki metode yang belum diimplementasikan (metode abstrak) serta metode yang sudah diimplementasikan.
Contoh:
public abstract class Bentuk
{
public abstract double HitungLuas(); // Metode abstrak
public void TampilkanInfo()
{
Console.WriteLine("Ini adalah bentuk.");
}
}
public class Lingkaran : Bentuk
{
public double Radius { get; set; }
public Lingkaran(double radius)
{
Radius = radius;
}
public override double HitungLuas()
{
return Math.PI * Radius * Radius;
}
}
class Program
{
static void Main(string[] args)
{
Lingkaran lingkaran = new Lingkaran(5);
Console.WriteLine($"Luas lingkaran: {lingkaran.HitungLuas()}");
}
}
b. Interface
Interface adalah blueprint yang hanya berisi deklarasi metode tanpa implementasi. Semua metode dalam interface harus diimplementasikan oleh class yang menggunakannya.
Contoh:
public interface IShape
{
double HitungLuas();
}
public class Persegi : IShape
{
public double Sisi { get; set; }
public Persegi(double sisi)
{
Sisi = sisi;
}
public double HitungLuas()
{
return Sisi * Sisi;
}
}
class Program
{
static void Main(string[] args)
{
Persegi persegi = new Persegi(4);
Console.WriteLine($"Luas persegi: {persegi.HitungLuas()}");
}
}
Class abstrak dapat memiliki metode yang diimplementasikan dan metode abstrak, sedangkan interface hanya berisi deklarasi metode.
Suatu class dapat mewarisi satu class abstrak, tetapi dapat mengimplementasikan banyak interface.
Modularitas: Program dipecah menjadi objek-objek kecil yang dapat dikelola secara individual.
Pemeliharaan Kode: Dengan adanya modularitas, pemeliharaan kode menjadi lebih mudah karena setiap modul (objek) dapat diperbaiki, ditingkatkan, atau diuji secara terpisah tanpa memengaruhi keseluruhan sistem.
Reuse Code (Penggunaan Ulang Kode): OOP memungkinkan penggunaan kembali kode melalui pewarisan (inheritance). Class yang sudah dibuat dapat digunakan kembali oleh class lain tanpa menulis ulang fungsionalitas yang sama.
Ekstensibilitas: Kode dapat dengan mudah dikembangkan dengan menambahkan class baru atau memperluas class yang ada tanpa mengubah kode yang sudah ada.
Keamanan: Dengan enkapsulasi, data disembunyikan dari akses langsung. Hanya metode yang diizinkan yang dapat mengakses dan memodifikasi data tersebut, sehingga memberikan keamanan lebih terhadap manipulasi data yang tidak sah.
Penerapan OOP dalam proyek nyata sangat umum, terutama dalam pengembangan aplikasi skala besar. Berikut adalah contoh sederhana dari penerapan OOP dalam aplikasi manajemen karyawan.
Contoh Aplikasi Manajemen Karyawan
// Class Karyawan sebagai superclass
public class Karyawan
{
public string Nama { get; set; }
public int Umur { get; set; }
public Karyawan(string nama, int umur)
{
Nama = nama;
Umur = umur;
}
public virtual void TampilkanInfo()
{
Console.WriteLine($"Nama: {Nama}, Umur: {Umur}");
}
}
// Class Manajer yang mewarisi class Karyawan
public class Manajer : Karyawan
{
public string Departemen { get; set; }
public Manajer(string nama, int umur, string departemen) : base(nama, umur)
{
Departemen = departemen;
}
// Overriding metode TampilkanInfo
public override void TampilkanInfo()
{
base.TampilkanInfo(); // Memanggil metode TampilkanInfo dari superclass
Console.WriteLine($"Departemen: {Departemen}");
}
}
// Class Staf yang mewarisi class Karyawan
public class Staf : Karyawan
{
public string Posisi { get; set; }
public Staf(string nama, int umur, string posisi) : base(nama, umur)
{
Posisi = posisi;
}
public override void TampilkanInfo()
{
base.TampilkanInfo();
Console.WriteLine($"Posisi: {Posisi}");
}
}
class Program
{
static void Main(string[] args)
{
// Membuat objek dari class Manajer dan Staf
Manajer manajer1 = new Manajer("Andi", 35, "Keuangan");
Staf staf1 = new Staf("Budi", 25, "Administrasi");
// Menampilkan informasi karyawan
manajer1.TampilkanInfo();
staf1.TampilkanInfo();
}
}
Penjelasan:
Karyawan adalah superclass yang mendefinisikan atribut dasar seperti Nama dan Umur serta metode TampilkanInfo.
Manajer dan Staf adalah subclass yang mewarisi Karyawan. Keduanya melakukan overriding pada metode TampilkanInfo untuk menampilkan informasi yang lebih spesifik sesuai dengan peran masing-masing.
Ini menunjukkan bagaimana pewarisan dan polimorfisme digunakan dalam proyek nyata untuk memodelkan entitas yang kompleks.
Pemrograman Berorientasi Objek (OOP) berbeda dengan Pemrograman Terstruktur dalam beberapa hal:
Pendekatan: Pemrograman Terstruktur berfokus pada fungsi dan data yang terpisah, sedangkan OOP menggabungkan data dan fungsi dalam objek.
Modularitas: OOP lebih modular karena objek dapat dipisahkan, diuji, dan digunakan ulang secara individual. Pemrograman Terstruktur lebih sulit mencapai modularitas pada skala besar.
Pewarisan: OOP memungkinkan pewarisan, di mana subclass dapat mewarisi dan menambah fungsi dari superclass, sedangkan Pemrograman Terstruktur tidak memiliki mekanisme pewarisan.
Pemrograman Berorientasi Objek (OOP) dalam C# menawarkan pendekatan yang kuat dan fleksibel dalam pengembangan perangkat lunak. Dengan konsep dasar seperti enkapsulasi, pewarisan, polimorfisme, dan abstraksi, OOP memudahkan pengembangan, pemeliharaan, dan pengembangan aplikasi skala besar.