Contoh Program OOP C++ Modern: Konsep Kelas dan Pewarisan

Pemrograman Berorientasi Objek (Object-Oriented Programming/OOP) adalah paradigma pemrograman yang sangat dominan dalam pengembangan perangkat lunak modern, dan C++ adalah salah satu bahasa yang paling kuat untuk mengimplementasikannya. Inti dari OOP adalah penggunaan Kelas (Classes) dan Objek (Objects) untuk memodelkan entitas dunia nyata.

Dalam artikel ini, kita akan melihat contoh sederhana yang mengilustrasikan tiga pilar utama OOP: Enkapsulasi, Pewarisan (Inheritance), dan Polimorfisme, menggunakan sintaks C++ modern.

1. Enkapsulasi: Kelas Kendaraan

Enkapsulasi adalah penyembunyian detail implementasi internal sebuah objek, hanya mengekspos fungsionalitas melalui antarmuka publik. Kita definisikan kelas Kendaraan.

// Dalam file: kendaraan.hpp

#include <iostream>
#include <string>

class Kendaraan {
private:
    std::string nama;
    int kecepatan_maks;

public:
    // Konstruktor
    Kendaraan(std::string n, int km) : nama(n), kecepatan_maks(km) {}

    // Metode Publik (Interface)
    void tampilkanInfo() const {
        std::cout << "Kendaraan: " << nama << std::endl;
        std::cout << "Kecepatan Maks: " << kecepatan_maks << " km/jam" << std::endl;
    }

    // Getter (Akses aman ke data privat)
    std::string getNama() const {
        return nama;
    }
};
        

2. Pewarisan: Kelas Mobil

Pewarisan memungkinkan kelas baru (turunan/derived class) untuk mewarisi atribut dan metode dari kelas yang sudah ada (dasar/base class). Kelas Mobil akan mewarisi dari Kendaraan dan menambahkan properti spesifiknya, seperti jumlah roda.

// Dalam file: mobil.hpp (melanjutkan dari Kendaraan)

class Mobil : public Kendaraan {
private:
    int jumlah_pintu;

public:
    // Konstruktor Mobil memanggil konstruktor Kendaraan
    Mobil(std::string n, int km, int pintu) 
        : Kendaraan(n, km), jumlah_pintu(pintu) {}

    // Overriding (menggunakan metode dari kelas dasar)
    void tampilkanInfoLengkap() const {
        tampilkanInfo(); // Memanggil metode dari kelas Kendaraan
        std::cout << "Tipe: Mobil dengan " << jumlah_pintu << " pintu." << std::endl;
    }

    void klakson() const {
        std::cout << getNama() << " berbunyi: Miiip Miiip!" << std::endl;
    }
};
        

3. Polimorfisme Melalui Fungsi Virtual

Polimorfisme (banyak bentuk) memungkinkan objek dari kelas yang berbeda merespons panggilan metode yang sama dengan cara yang spesifik bagi mereka. Ini dicapai di C++ menggunakan fungsi virtual (virtual) dan pointer/referensi kelas dasar.

Mari kita tambahkan sebuah fungsi virtual ke kelas dasar kita dan definisikan perilaku uniknya di kelas turunan.

Implementasi Main Program (Menggabungkan Semuanya)

Untuk menunjukkan polimorfisme, kita akan membuat objek Mobil dan menunjuknya melalui pointer Kendaraan*.

// Dalam file: main.cpp (Memerlukan Kendaraan dan Mobil didefinisikan)

// MODIFIKASI KECIL PADA KENDARAAN UNTUK DEMO VIRTUAL:
// Tambahkan 'virtual' pada metode tampilkanInfo di Kendaraan

/*
class Kendaraan {
    ...
    virtual void tampilkanInfo() const { ... } 
    ...
};
*/

// MODIFIKASI KECIL PADA MOBIL UNTUK OVERRIDE:
// Tambahkan 'override' pada Mobil
/*
    void tampilkanInfo() const override {
        // Implementasi khusus mobil
    }
*/
// Untuk menjaga kode tetap singkat, kita fokus pada eksekusi main:

int main() {
    // 1. Inisialisasi Objek
    Mobil sedan("Toyota Avanza", 180, 4);

    // 2. Demonstrasi Pewarisan
    std::cout << "--- DEMO PEWARISAN ---" << std::endl;
    sedan.klakson();
    sedan.tampilkanInfoLengkap();
    std::cout << "----------------------" << std::endl << std::endl;

    // 3. Demonstrasi Polimorfisme
    // Pointer kelas dasar menunjuk objek kelas turunan
    Kendaraan* ptr_kendaraan = &sedan;

    std::cout << "--- DEMO POLIMORFISME ---" << std::endl;
    // Jika tampilkanInfo() adalah virtual, ini akan memanggil versi Mobil.
    // Tanpa virtual, ini akan memanggil versi Kendaraan (static binding).
    // Dalam contoh ini, kita asumsikan fungsi yang dipanggil sesuai dengan tipe pointer (Kendaraan*).
    ptr_kendaraan->tampilkanInfo(); 
    // Output yang diharapkan (jika virtual): Informasi yang sesuai dari Mobil/Kendaraan
    
    // Catatan: Untuk hasil polimorfisme yang benar, properti virtual harus diterapkan.
    // Dalam kasus non-virtual di atas, output akan mengikuti tipe pointer (Kendaraan).
    // Namun, ide dasarnya adalah menggunakan pointer umum untuk mengelola tipe spesifik.
    
    return 0;
}
        

Rangkuman Konsep OOP C++

Contoh di atas mencakup fondasi penting OOP dalam C++:

• Enkapsulasi: Data (nama, kecepatan_maks) disembunyikan di bagian private, hanya dapat diakses melalui metode publik.
• Pewarisan: Kelas Mobil mendapatkan semua properti dari Kendaraan tanpa perlu mendefinisikannya ulang.
• Polimorfisme: Konsep memungkinkan kita memperlakukan objek turunan seolah-olah mereka adalah objek dasar, yang sangat penting untuk fleksibilitas desain sistem yang besar.

Menguasai ketiga prinsip ini adalah langkah krusial untuk menulis kode C++ yang terstruktur, mudah dipelihara, dan dapat diskalakan.