Pemrograman MODUL 4

 

 OOP(Object Oriented-Programing)

Program:

Output:

 

 

 

Secara Garis Besar

 

Ya, ada konsep polimorfisme dalam kode tersebut. Polimorfisme adalah kemampuan suatu fungsi atau metode untuk bekerja dengan berbagai jenis objek. Dalam C++, polimorfisme dapat dicapai melalui penggunaan kelas dasar yang memiliki fungsi virtual, yang kemudian di-override oleh kelas turunan.

Mari kita tinjau kode Anda untuk melihat di mana konsep polimorfisme diterapkan:

1. *Kelas Dasar dan Fungsi Virtual:*
   cpp
   // Base class untuk bidang
   class Bidang {
   public:
       virtual double hitungLuas() = 0; // Pure virtual function untuk polimorfisme
   };
   
   Kelas Bidang memiliki fungsi virtual murni (hitungLuas). Ini berarti setiap kelas turunan harus mengimplementasikan fungsi ini. Ini adalah dasar dari polimorfisme, karena fungsi ini akan berperilaku berbeda tergantung pada objek mana yang memanggilnya.

2. *Kelas Turunan Meng-override Fungsi Virtual:*
   cpp
   // Derived class untuk segitiga
   class Segitiga : public Bidang {
   private:
       double alas;
       double tinggi;
   public:
       Segitiga(double a, double t) : alas(a), tinggi(t) {}

       double hitungLuas() {
           return (alas * tinggi) / 2;
       }
   };

   // Derived class untuk balok
   class Balok : public Bidang {
   private:
       int panjang;
       int lebar;
   public:
       Balok(int p, int l) : panjang(p), lebar(l) {}

       double hitungLuas() {
           return panjang * lebar;
       }
   };
   
   Segitiga dan Balok adalah kelas turunan dari Bidang dan masing-masing mengimplementasikan fungsi hitungLuas.

3. *Penggunaan Polimorfisme:*
   cpp
   int main() {
       // Membuat objek Segitiga dan Balok dengan pointer
       Bidang* segitiga = new Segitiga(5, 7);
       Bidang* balok = new Balok(15, 10);

       // Menghitung dan menampilkan luas segitiga dan balok
       cout << "Luas Segitiga: " << segitiga->hitungLuas() << " cm^2" << endl;
       cout << "Luas Balok: " << balok->hitungLuas() << " cm^2" << endl;

       return 0;
   }
   
   Dalam fungsi main, Anda membuat objek Segitiga dan Balok menggunakan pointer ke kelas dasar Bidang. Ketika Anda memanggil hitungLuas pada objek-objek ini, fungsi yang tepat dipanggil berdasarkan tipe objek yang sebenarnya, bukan tipe pointer (Bidang*). Ini adalah inti dari polimorfisme runtime.

Dengan demikian, kode Anda sudah menerapkan konsep polimorfisme dengan menggunakan kelas dasar yang memiliki fungsi virtual murni, dan kelas turunan yang meng-override fungsi tersebut, serta penggunaan pointer ke kelas dasar untuk memanggil fungsi yang di-override oleh kelas turunan.

Lebih Jelas Lagi:

Program ini merupakan contoh implementasi konsep polimorfisme dalam C++ menggunakan kelas abstrak dan pewarisan. Berikut adalah penjelasan langkah demi langkah dari program tersebut:

1. *Definisi Kelas Abstrak Bidang*:
    - Kelas Bidang adalah kelas dasar (base class) yang mendefinisikan fungsi virtual murni hitungLuas(). Fungsi virtual murni ini memaksa kelas-kelas turunan untuk mengimplementasikan fungsi tersebut.
    cpp
    class Bidang {
    public:
        virtual double hitungLuas() = 0; // Pure virtual function untuk polimorfisme
    };
    

2. *Definisi Kelas Segitiga*:
    - Kelas Segitiga adalah kelas turunan dari Bidang. Kelas ini memiliki dua atribut, yaitu alas dan tinggi.
    - Konstruktor Segitiga menginisialisasi nilai alas dan tinggi.
    - Fungsi hitungLuas dihitung berdasarkan rumus luas segitiga: \(\frac{1}{2} \times alas \times tinggi\).
    cpp
    class Segitiga : public Bidang {
    private:
        double alas;
        double tinggi;
    public:
        Segitiga(double a, double t) : alas(a), tinggi(t) {}

        double hitungLuas() {
            return (alas * tinggi) / 2;
        }
    };
    

3. *Definisi Kelas Balok*:
    - Kelas Balok adalah kelas turunan dari Bidang. Kelas ini memiliki dua atribut, yaitu panjang dan lebar.
    - Konstruktor Balok menginisialisasi nilai panjang dan lebar.
    - Fungsi hitungLuas dihitung berdasarkan rumus luas persegi panjang: \(panjang \times lebar\).
    cpp
    class Balok : public Bidang {
    private:
        int panjang;
        int lebar;
    public:
        Balok(int p, int l) : panjang(p), lebar(l) {}

        double hitungLuas() {
            return panjang * lebar;
        }
    };
    

4. *Fungsi main*:
    - Membuat objek Segitiga dan Balok menggunakan pointer ke kelas dasar Bidang.
    - Menggunakan pointer tersebut untuk memanggil fungsi hitungLuas dan menampilkan hasilnya.
    cpp
    int main() {
        // Membuat objek Segitiga dan Balok dengan pointer
        Bidang* segitiga = new Segitiga(5, 7);
        Bidang* balok = new Balok(15, 10);

        // Menghitung dan menampilkan luas segitiga dan balok
        cout << "Luas Segitiga: " << segitiga->hitungLuas() << " cm^2" << endl;
        cout << "Luas Balok: " << balok->hitungLuas() << " cm^2" << endl;

        // Membersihkan memori yang dialokasikan secara dinamis
        delete segitiga;
        delete balok;

        return 0;
    }
    

5. *Penjelasan Polimorfisme*:
    - Polimorfisme memungkinkan penggunaan satu antarmuka (kelas dasar Bidang) untuk berbagai implementasi (kelas turunan Segitiga dan Balok).
    - Meskipun objek segitiga dan balok didefinisikan sebagai pointer ke Bidang, fungsi yang dipanggil adalah fungsi hitungLuas yang diimplementasikan oleh kelas Segitiga dan Balok.

Secara keseluruhan, program ini menunjukkan cara menggunakan polimorfisme untuk menghitung luas berbagai bentuk geometris (segitiga dan persegi panjang) dengan memanfaatkan kelas dasar dan kelas turunan.

 

Penjelasan Flowchart

 

Untuk membuat flowchart yang menggambarkan alur dari program C++ tersebut, kita bisa mengikuti langkah-langkah berikut:

1. *Start*: Mulai program.
2. *Inisialisasi objek Segitiga*: Membuat objek Segitiga dengan alas 5 dan tinggi 7.
3. *Inisialisasi objek Balok*: Membuat objek Balok dengan panjang 15 dan lebar 10.
4. *Hitung Luas Segitiga*: Panggil metode hitungLuas() pada objek Segitiga untuk menghitung luas segitiga.
5. *Tampilkan Luas Segitiga*: Tampilkan hasil perhitungan luas segitiga.
6. *Hitung Luas Balok*: Panggil metode hitungLuas() pada objek Balok untuk menghitung luas balok.
7. *Tampilkan Luas Balok*: Tampilkan hasil perhitungan luas balok.
8. *End*: Akhiri program.

Berikut adalah ilustrasi flowchart tersebut:

+--------------------------+
|          Start           |
+-----------+--------------+
            |
            v
+-----------+--------------+
| Inisialisasi Segitiga    |
| alas = 5, tinggi = 7     |
+-----------+--------------+
            |
            v
+-----------+--------------+
| Inisialisasi Balok       |
| panjang = 15, lebar = 10 |
+-----------+--------------+
            |
            v
+-----------+--------------+
| Hitung Luas Segitiga     |
| luas = (alas * tinggi) /2|
+-----------+--------------+
            |
            v
+-----------+--------------+
| Tampilkan Luas Segitiga  |
+-----------+--------------+
            |
            v
+-----------+--------------+
| Hitung Luas Balok        |
| luas = panjang * lebar   |
+-----------+--------------+
            |
            v
+-----------+--------------+
| Tampilkan Luas Balok     |
+-----------+--------------+
            |
            v
+-----------+--------------+
|           End            |
+--------------------------+

Flowchart di atas secara garis besar menggambarkan alur utama dari program tersebut mulai dari inisialisasi objek, perhitungan luas, hingga menampilkan hasil perhitungan.

 

 

ZOOM

 File LA Modul 4 OOP

KLIK