TUGAS 3 BP II - OOP

CONSTRUCTOR

        Class constructor merupakan suatu fungsi yang memiliki kegunaan khusus di dalam suatu class yang akan dipanggil (eksekusi) ketika objek suatu class dideklarasikan. Fungsi tersebut akan memiliki nama sama dengan nama classnya, seperti CKotak(), yang merupakan constructor untuk class CKotak. Fungsi tersebut tidak memiliki nilai kembalian dan kegunaan utama dari class constructor adalah memberikan nilai awal (inisialisasi dengan suatu nilai) kepada data anggota class.

CONTOH  SOURCE  CODE  PENGGUNAAN  CONSTRUCTOR

#include "iosream.h"
class CKotak
{
public:
    double m_panjang;    /* panjang dari suatu kotak */
    double m_lebar;        /* lebar dari suatu kotak */
    double m_tinggi;    /* tinggi dari suatu kotak */

    CKotak(double p, double l, double t)    /* definisi constructor */
    {
        m_panjang = p;     /* panjang dari suatu kotak */
        m_lebar = l;     /* lebar dari suatu kotak */
        m_tinggi = t;     /* tinggi dari suatu kotak */

        cout << endl << "Constructor dipanggil";
    }


    /* fungsi untuk menghitung volume kotak */
    double Volume()
    {
        return (m_panjang * m_lebar * m_tinggi);
    }


    /* fungsi untuk menghitung luas permukaan kotak */
    double LuasKotak()
    {
        return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
    }
};


void main()
{
    CKotak kotak1(15.0, 12.0, 6.0);        /* deklarasikan & inisialisasi kotak1 */
    CKotak kotak2(20.0, 10.0, 5.0);        /* deklarasikan & inisialisasi kotak2 */

    /* simpan hasil perhitungan luasan permukaan kotak */
    double Luas_Kotak = 0.0;

    Luas_Kotak = kotak1.LuasKotak();    /* luas permukaan kotak1 */

    cout << endl << endl << "Luas Permukaan kotak1 = " << Luas_Kotak;

    cout << endl << "Volume kotak1 = " << kotak1.Volume();

    cout << endl << endl << "Luas Permukaan kotak2 = " << kotak2.LuasKotak()
        << endl << "Volume kotak2 = " <<kotak2.Volume();

    cout <<endl <<endl << "Suatu objek dari CKotak akan menempati memori sebesar : "
        << sizeof kotak1 << " bytes" << endl << endl;

    return;
}

OUTPUT  PROGRAM

ANALISA  PROGRAM

        Dari contoh source code di atas dapat di analisa bahwa Constructor CKotak dibuat dengan memiliki tiga buah parameter yang masing-masing bertipe double, sesuai dengan banyaknya data anggota class. Masing-masing parameter akan digunakan untuk menginisialisasikan data anggota class untuk objek CKotak : m_panjang, m_lebar, dan m_tinggi. Pernyataan terakhir di dalam constructor tersebut merupakan stream cout yang digunakan untuk menunjukkan bahwa setiap kali objek CKotak dideklarasikan maka constructor dari class CKotak akan dipanggil.

        Di dalam fungsi main() dideklarasikan dua buah objek CKotak yaitu kotak1 dan kotak2 dan diinisialisasikan langsung dengan nilai-nilai tertentu, dimana teknik penulisannya serupa dengan teknik penulisan fungsi pemanggil yang melewatkan suatu argumen tertentu. Ketiga nilai yang dilewatkan tersebut diinisialisasikan dengan ketiga data anggota class yang bersesuaian : m_panjang, m_lebar, dan m_tinggi. Nilai-nilai (argumen-argumen) yang diinisialisasikan diletakkan di dalam sepasang tanda kurung setelah penulisan nama objek dilakukan. Kemudian, dilakukan perhitungan LuasKotak dan Volume untuk masing-masing objek. Penulisan / penambahan constructor tidak akan menambah ukuran suatu objek.

        Dua baris pertama dari output program merupakan hasil dari pemanggilan constructor CKotak yang terjadi pada saat dilakukannya deklarasi objek kotak1 dan kotak2. Constructor di dalam definisi class akan secara otomatis dipanggil ketika terdapat pendeklarasian objek CKotak sehingga jika terjadi proses inisialisasi di dalam pendeklarasian tersebut maka nilai argumen akan dilewatkan ke dalam constructor untuk diset dengan data anggota class dengan urutan yang bersesuaian.

DEFAULT CONSTRUCTOR

* Jika kita ingin mendeklarasikan suatu objek tanpa harus menginisialisasikannya, maka kita harus menggunakan Default Constructor.

Program di atas dapat dimodifikasi dengan menambahkan pernyataan :
       CKotak kotak3;
di bawah pendeklarasian objek kotak2.

        Disini kita mendeklarasikan suatu objek CKotak tanpa menginisialisasikannya dengan suatu nilai apapun. Jika program dikompilasi, maka kompiler akan menunjukkan pesan kesalahan seperti berikut :

        Arti dari pesan kesalahan tersebut adalah kompiler akan mencari suatu default constructor yang dimiliki oleh objek kotak3, yaitu constructor yang tidak memiliki argumen apapun. Karena tidak menemukan constructor yang sesuai untuk kotak3 (default constructor), pesan kesalahan akan ditampilkan. Untuk menghindari hal itu, di dalam definisi class harus ditambahkan sebuah default constructor, yaitu :

       //definisi default constructor
       CKotak()
       {     }
Sekarang, jika program dikompilasi ulang tidak akan ada lagi pesan kesalahan yang muncul.

CONTOH SOURCE CODE yang telah ditambahkan DEFAULT CONSTRUCTOR :

#include "iostream.h"

class CKotak
{
public:
    double m_panjang;    /* panjang dari suatu kotak */
    double m_lebar;        /* lebar dari suatu kotak */
    double m_tinggi;    /* tinggi dari suatu kotak */

    CKotak(double p, double l, double t)    /* definisi constructor */
    {
        m_panjang = p;     /* panjang dari suatu kotak */
        m_lebar = l;     /* lebar dari suatu kotak */
        m_tinggi = t;     /* tinggi dari suatu kotak */

        cout << endl << "Constructor dipanggil";
    }

    /* definisi default constructor */
    CKotak()
    {
        cout << endl << "Default Constructor dipanggil";
    }

    /* fungsi untuk menghitung volume kotak */
    double Volume()
    {
        return (m_panjang * m_lebar * m_tinggi);
    }

    /* fungsi untuk menghitung luas permukaan kotak */
    double LuasKotak()
    {
        return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
    }
};


void main()
{
    CKotak kotak1(15.0, 12.0, 6.0);        /* deklarasikan & inisialisasi kotak1 */
    CKotak kotak2(20.0, 10.0, 5.0);        /* deklarasikan & inisialisasi kotak2 */
    CKotak kotak3;        /* deklarasikan kotak3 */

    /* set data anggota objek kotak3 dengan nilai-nilai tertentu */
    kotak3.m_panjang = kotak1.m_panjang - 7.0;
    kotak3.m_lebar = kotak1.m_lebar / 3.0;
    kotak3.m_tinggi = kotak2.m_panjang / 5;

    /* simpan hasil perhitungan luasan permukaan kotak */
    double Luas_Kotak = 0.0;

    Luas_Kotak = kotak1.LuasKotak();    /* luas permukaan kotak1 */

    cout << endl << endl << "Luas Permukaan kotak1 = " << Luas_Kotak;

    cout << endl << "Volume kotak1 = " << kotak1.Volume();

    cout << endl << endl << "Luas Permukaan kotak2 = " << kotak2.LuasKotak()
        << endl << "Volume kotak2 = " <<kotak2.Volume();

    cout << endl << endl << "Luas Permukaan kotak3 = " << kotak3.LuasKotak()
        << endl << "Volume kotak3 = " << kotak3.Volume();

    cout <<endl <<endl << "Suatu objek dari CKotak akan menempati memori sebesar : "
        << sizeof kotak1 << " bytes" << endl << endl;

    return;
}

OUTPUT  PROGRAM

ANALISA  PROGRAM

        Dari contoh source code di atas dapat di analisa bahwa di dalam program tersebut telah memiliki sebuah default constructor di dalam definisi class CKotak dan tidak akan ada lagi pesan kompiler karena tidak ditemukannya default construtor seperti yang terlihat pada gambar di atas, di samping constructor, default constructor pun kini dipanggil dalam pendeklarasian objek kotak3. Ukuran objek masih tetap tidak berubah dengan penambahan default constructor. Satu aspek penting yang harus dicermati dalam contoh program kali ini bahwa constructor berlaku sebagai fungsi overloading. Kompiler akan secara otomatis memilih constructor yang sesuai dalam pendeklarasian objek.

MEMBERIKAN NILAI DEFAULT DI DALAM CONSTRUCTOR

        Parameter suatu fungsi dapat memiliki nilai default yang didefinisikan di dalam prototipe fungsi. Fungsi-fungsi, anggota class, termasuk constructor pun, dapat memiliki parameter default di dalam suatu definisi class. Jika definisi fungsi terdapat di dalam definisi class, nilai-nilai default untuk paramete-parameter fungsi dapat diletakkan di dalam header suatu fungsi. Tetapi, jika di dalam definisi class hanya terdapat prototipe fungsi, nilai default parameter fungsi harus ditulis di dalam prototipe fungsi tersebut.

Jika kita menginginkan agar objek untuk class CKotak memiliki ukuran-ukuran minimum adalah 1, maka constructor class CKotak akan menjadi seperti :

Jika program sudah dimodifikasi dengan pernyataan di atas, maka akan didapatkan pesan kesalahan kompiler :

         Hal tersebut dapat terjadi disebabkan kompiler tidak dapat menentukan yang mana dari kedua constructor tersebut yang dipanggil- constructor yang memiliki nilai default untuk parameter-parameternya atau constructor tidak menerima parameter apapun (default constructor). Dengan kata lain, pendeklarasian kotak3 akan membutuhkan suatu constructor tanpa parameter ataukah constructor yang dapat dipanggil tanpa menggunakan inisialisasi parameter-parameternya (constructor yang memiliki nilai default). Solusi alternatif dari masalah itu adalah dengan menghapus default constructor. Dalam hal ini, memberikan nilai default untuk parameter-parameter suatu constructor akan menyebabkan objek yang dideklarasikan tanpa inisialisasi suatu nilai secara otomatis akan memiliki nilai default, yaitu dalam kasus ini, nilai data anggota class akan sama dengan 1. Setelah default constructor di dalam definisi class CKotak dihapus, maka program sudah dapat dijalankan.

CONTOH  SOURCE  CODE  setelah  ditambahkan  NILAI  DEFAULT  untuk  parameter  CONSTRUCTOR  pada  Class  CKotak :

#include "iostream.h"

class CKotak    /* definisi class dengan jangkauan global */
{
public:
    double m_panjang;    /* panjang dari suatu kotak */
    double m_lebar;        /* lebar dari suatu kotak */
    double m_tinggi;    /* tinggi dari suatu kotak */


    /* definisi constructor */
    CKotak(double p = 1.0, double l = 1.0, double t = 1.0)
    {
        m_panjang = p;       /*      dapatkan      */
        m_lebar = l;       /*     nilai-nilai    */
        m_tinggi = t;       /* data anggota class */

        cout << endl << "Constructor dipanggil";
    }


    /* fungsi untuk menghitung volume kotak */
    double Volume()
    {
        return (m_panjang * m_lebar * m_tinggi);
    }


    /* fungsi untuk menghitung luas permukaan kotak */
    double LuasKotak()
    {
        return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
    }
};


void main()
{
    CKotak kotak3;        /* deklarasikan kotak3 */

    cout << endl << endl << "Luas Permukaan kotak3 = " << kotak3.LuasKotak()
        << endl << "Volume kotak3 = " << kotak3.Volume();

    cout <<endl <<endl << "Suatu objek dari CKotak akan menempati memori sebesar : "
        << sizeof kotak3 << " bytes" << endl << endl;

    return;
}

OUTPUT  PROGRAM

ANALISA  PROGRAM

        Dari contoh source code di atas dapat di analisa bahwa di dalam program tersebut, hanya dideklarasikan variabel kotak3 tanpa diikuti dengan inisialisasi suatu nilai apapun. Pada output di atas, terlihat bahwa constructor yang memiliki parameter-parameter dengan nilai default dipanggil dan dapat melakukan tugasnya yaitu menginisialisasikan data anggota class dari objek kotak3 dengan nilai-nilai default, yaitu 1.

        Penggunaan nilai default untuk parameter-parameter di dalam program tersebut hanyalah untuk ilustrasi. Di dalam kenyataan praktik pemrograman sehari-hari, akan sangat banyak alasan untuk tetap menggunakan suatu default constructor di dalam program, tetapi ada kalanya juga, kita tidak membutuhkan suatu default constructor sama sekali. Pemberian contoh ini hanya untuk menunjukkan kepada kita bahwa semua objek suatu class yang dideklarasikan pasti memiliki nilai inisialisasi.

MENGGUNAKAN DAFTAR INISIALISASI DI DALAM SUATU CONSTRUCTOR

        Sejauh ini, proses inisialisasi anggota suatu objek dilaksanakan di dalam class constructor secara eksplisit dengan menggunakan operator penugasan. Ada cara lain yang disebut " Dafatar Inisialisasi ". Sebagai contoh, jika kita ingin mengubah constructor di dalam class CKotak agar sesuai dengan versi tersebut maka dapat ditulis :

      /* Definisi constructor dengan memakai daftar inisialisasi
      CKotak(double p = 1.0, double l = 1.0, double t = 1.0) : m_panjang(p), m_lebar(l), m_tinggi(t)
     {
          cout << endl << "Constructor dipanggil";
     }

        Pada pernyataan-pernyataan di atas, nilai-nilai default tidak diset melalui pernyataan penugasan di dalam badan constructor, melainkan diset seperti halnya pelewatan suatu nilai sebagai argumen di dalam fungsi pemanggil. Setiap anggota dari daftar inisialisasi dipisahkan oleh tanda koma dan daftar inisialisasi tersebut berada di luar badan fungsi / constructor. Teknik inisialisasi seperti itu banyak dipraktikkan dalam pemrograman.

BENTUK  " DEFAULT "  COPY  CONSTRUCTOR

Deklarasikan dan inisialisasikan objek kotak1 yang bertipe CKotak seperti berikut :
     CKotak kotak1(3.5, 4.0, 1.7);

        Sekarang, kita buat lagi sebuah objek CKotak yang sama dengan objek sebelumnya dan kita inisialisasikan objek kotak ini dengan objek kotak1. Di dalam fungsi main() dilakukan duplikat informasi objek kotak3 dari objek kotak1 dengan menginisialisasikan objek kotak3 dengan objek kotak1.

CONTOH SOURCE CODE COPY CONSTRUCTOR

#include "iostream.h"

class CKotak    /* definisi class dengan jangkauan global */
{
public:

    /* definisi constructor dengan memakai daftar inisialisasi */
    CKotak(double p = 1.0, double l = 1.0, double t = 1.0) : m_panjang(p), m_lebar(l), m_tinggi(t)
    {
        cout << endl << "Constructor dipanggil";
    }


    /* fungsi untuk menghitung volume kotak */
    double Volume()
    {
        return (m_panjang * m_lebar * m_tinggi);
    }


    /* fungsi untuk menghitung luas permukaan kotak */
    double LuasKotak()
    {
        return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
    }

private:
    double m_panjang;    /* panjang dari suatu kotak */
    double m_lebar;        /* lebar dari suatu kotak */
    double m_tinggi;    /* tinggi dari suatu kotak */
};


int main(void)
{
    CKotak kotak1(3.5, 4.0, 1.7);
   
    /* deklarasikan & inisialisasikan kotak3 dengan kotak1 */
    CKotak kotak3 = kotak1;

    cout << endl << endl << "Luas Permukaan kotak3 = " << kotak3.LuasKotak()
        << endl << "Volume kotak3 = " << kotak3.Volume();

    cout << endl << endl << "Luas Permukaan kotak1 = " << kotak1.LuasKotak()
        << endl << "Volume kotak1 = " << kotak1.Volume() << endl << endl;
   
    return 0;
}

OUTPUT  PROGRAM

ANALISA PROGRAM

        Masing-masing kotak memiliki luas permukaan kotak dan volume yang sama. Tetapi jika diperhatikan, constructor hanya dipanggil sekali dalam penciptaan (pendeklarasian) objek kotak1. Bagaimana objek kotak3 dibuat ? Kasus itu serupa dengan pada saat kita membahas tidak adanya default constructor dalam pembuatan suatu objek. Pada kasus tersebut, kompiler memproduksi suatu versi default dari apa yang dikenal sebagai copy constructor. Objek kotak3 terbentuk karena adanya copy constructor. Dengan copy constructor, objek suatu class dapat dibentuk melalui proses inisialisasi dengan objek lain dari suatu class yang sama. Versi default copy constructor menciptakan suatu objek baru dengan mengopi dari objek yang sudah ada, anggota demi anggota.
        Cara penduplikasian suatu objek dengan copy constructor cukup memadai untuk kasus CKotak yang sederhana itu. Untuk class-class yang lebih kompleks, dimana terdapat array atau pointer di dalamnya, mekanisme copy constructor secara default tidak akan berlaku. Kita harus membuat sendiri suatu copy constructor yang sesuai dengan kebutuhan.

***********************************************************************************

***********************************************************************************

OVERRIDING

MATERI  TENTANG  OVERRIDING

* Istilah Overriding sangat erat kaitannya dengan konsep Inheritance dalam konsep pemrograman berorientasi objek / OOP.

* Overriding merupakan suatu keadaan dimana kelas anak dapat mengubah atau memodifikasi atau memperluas data dan method, pada kelas induk. Overriding merupakan redefinisi data dan method, maksudnya proses ini akan mengubah data dan method dari keduanya, kelas induk dan kelas anaknya. Sebelum melakukan overriding perlu diperhatikan bagaimana tingkat aksesibilitas data dan method tersebut. Overriding menyatakan suatu keadaan dimana method pada subclass menolak method pada parent classnya

* Peraturan pada Overriding :

Method yang terkena override (overriding method) tidak boleh mempunyai modiffer yang lebih luas aksesnya daripada method yang meng override (overriding method)

* Alasan melakukan Overriding :

   -  Mendefinisikan kembali method kelas induknya secara total. Hal ini menyebabkan virtual machine menjalankan method anak, bukan method milik induk.

   -  Menambahkan behaviour tertentu pada method kelas induknya

   -  Dapat menambahkan sifat / atribut pada kelas induknya

* Ciri - ciri  Overriding :
   -  Nama method harus sama
   -  Daftar parameter harus sama
   -  Return type harus sama

TEORI  TENTANG  OVERRIDING

        Ambil contoh kasus tentang class induk Mobil dan class turunannya CitiCar. Method naikkanKecepatan diwariskan ke class CitiCar. Kalau CitiCar tidak mendeklarasi dan menuliskan kembali method naikkanKecepatan, maka setiap kali method CitiCar.naikkanKecepatan dipanggil, maka yang dijalankan adalah method Mobil.naikkanKecepatan. Dalam kasus overriding, method naikkanKecepatan dideklarasi dan ditulis kembali di CitiCar. Ketika method CitiCar.naikkanKecepatan dipanggil, virtual machine akan menjalankan method milik CitiCar, meskipun di class induknya Mobil method yang sama telah dituliskan.

        Kalau ada method yang sama ditulis di CitiCar yaitu naikkanKecepatan, kemudian method Mobil.naikkanKecepatan dipanggil, siapa yang akan dijalankan? Milik CitiCar ataukah milik Mobil? Tentu saja miliknya Mobil dong! :) Inheritance adalah pewarisan sifat kebawah, bukan ke atas. Pemikiran seperti ini bisa di-counter dengan pengandaian seperti ini: Kalau misalnya class turunan dari Mobil lebih dari satu dan mereka sama-sama menuliskan kembali method naikkanKecepatan, punya siapa yang akan dipakai? Dari sini sebenarnya dapat disimpukan bahwa Overriding-nya jelas, mengacu pada satu class induk. Bayangkan bagaimana rumitnya kalau sebuah class mengizinkan multiple inheritance?

CONTOH  SOURCE  CODE

#include "iostream.h"
#include "conio.h"
using namespace std;

/*--------------------------------------------------------------
:   Nama Kelas :   convert_base                                              :
:   Tujuan : Menyediakan kelas dasar dengan virtual function    :
:   Kelas lain dapat diturunkan dari kelas ini dengan                  :
:   implementasi polymorphism                                                 :
----------------------------------------------------------------*/
class convert_base
{
protected:        /* atribut dari kelas dasar */
    double initial_value;
    double converted_value;

public:            /* fungsi dari kelas dasar */
    convert_base(double passed_value)      /* constructor */
    {
        initial_value = passed_value;
    }
    double get_initial()
    {
        return initial_value;
    }
    double get_converted()
    {
        return converted_value;
    }
    virtual void convert_it() = 0;        /* a PURE virtual function */
};    /* akhir dari kelas convert_base    */


/*--------------------------------------------
:  Nama Kelas :   kilos_miles                         :
:  Tujuan : konversi dari kilometers ke miles   :
----------------------------------------------*/
class kilos_miles : public convert_base
{
public:
    kilos_miles(double passed_value) : convert_base(passed_value) { }

    void convert_it()    /* meng-override virtual class convert_it() */
    {
        converted_value = initial_value * 0.6;
    }
};  /* akhir kelas kilos_miles */


/*--------------------------------------------
:  Nama Kelas :    miles_kilos                        :
:  Tujuan : konversi dari miles ke kilometers   :
----------------------------------------------*/
class miles_kilos : public convert_base
{
public:
    miles_kilos(double passed_value) : convert_base(passed_value) { }

    /*    Kode untuk fungsi konversi kilo ke miles
        1 kilometer = 0.6 miles                      */
    void convert_it()    /* meng-override virtual class convert_it() */
    {
        converted_value = initial_value * (1/0.6);
    }
};  /* akhir kelas miles_kilos */


/*------------------------------------------
:  Nama Kelas :    meters_yards                 :
:  Tujuan : konversi dari meters ke yards    :
-------------------------------------------*/
/*    Kode untuk membuat class yang mengonversi METER ke YARDS
    1 Yard = 36.0 / 39.0  Meter                                  */
class meter_yard : public convert_base
{
public:
    meter_yard (double passed_value): convert_base(passed_value) {    }
    void convert_it()
    {
        converted_value = (initial_value) * (39.0/36.0);
    }
};    /* akhir kelas meters_yards */


/*------------------------------------------
:  Nama Kelas :    yards_meters                :
:  Tujuan : konversi dari yards ke meters   :
-------------------------------------------*/
/*    Berikut kode untuk membuat kelas yang mengonversi YARD ke METER
    1 Meter = 39.0/36.0 Yard                                        */
class yard_meter : public convert_base
{
public:
    yard_meter (double passed_value) : convert_base(passed_value) {    }
    void convert_it()
    {
        converted_value = (initial_value) * (36.0/39.0);
    }
};    /* akhir kelas yards_meters */


/*************  Main Function Starts Here  ***********/
int main()
{
    kilos_miles kilos1(100.0);    /* membuat objek kilos_miles                  */
    kilos1.convert_it();        /* memanggil virtual function dari kelas tsb  */
    cout << endl;
    cout << endl << "Distance in kilometers is: " << kilos1.get_initial();
    cout << endl << "Distance in miles is: " << kilos1.get_converted();
    cout << endl;

    /*
        1. Membuat objek miles_to_kilos, dengan nilai awal 60
        2. Memanggil virtual function dari objek tsb
        3. Mencetak nilai awal dan nilai konversi
        Catatan: lihat kode untuk Kilos_to_miles di atas.
    */

    miles_kilos miles1(60.0);    /* membuat objek miles_to_kilos                  */
    miles1.convert_it();        /* memanggil virtual function dari kelas tsb  */
    cout << endl;
    cout << endl << "Distance in miles is: " << miles1.get_initial();
    cout << endl << "Distance in kilometers is: " << miles1.get_converted();
    cout << endl;

    /*
        1. Membuat objek Yards_to_Meters, dengan nilai awal 4.
        2. Mencetak nilai awal dan nilai konversi
    */

    yard_meter yard1(4.0);    /* membuat objek yard_meter                      */
    yard1.convert_it();        /* memanggil virtual function dari kelas tsb  */
    cout << endl;
    cout << endl << "Distance in yard is: " << yard1.get_initial();
    cout << endl << "Distance in meter is: " << yard1.get_converted();
    cout << endl;

    /*
        3. Gunakan kelas Meters_to_Yards, beri nilai awal 4
        4. Cetak nilai awal dan nilai konversi
    */

    meter_yard meter1(4.0);        /* membuat objek meter_yard                      */
    meter1.convert_it();        /* memanggil virtual function dari kelas tsb  */
    cout << endl;
    cout << endl << "Distance in meter is: " << meter1.get_initial();
    cout << endl << "Distance in yard is: " << meter1.get_converted();
    cout << endl;

    getch();
    return(0);
}    /* end main */

TUGAS BAHASA PEMROGRAMAN 2

OBJECT-ORIENTED PROGRAMMING (OOP)

PEMROGRAMAN BERORIENTASI OBJEK

       Pemrograman berorientasi objek atau Object-Oriented Programming (OOP) merupakan suatu pendekatan pemrograman yang menggunakan object dan class. Saat ini konsep OOP sudah semakin berkembang. OOP bukanlah sekedar cara penulisan sintaks program yang berbeda, namun lebih dari itu OOP merupakan cara pandang dalam menganalisa sistem dan permasalahan pemrograman. Dalam konsep object oriented akan kita temukan kata object dan class, class merupakan pola / template yang menggambarkan kumpulan object yang mempunyai sifat yang sama, perilaku, atau disebut dengan himpunan object sejenis. Sementara object adalah implementasi dari class.

       Sebagai contoh dalam pembangunan suatu gedung tentunya seorang arsitek akan menggunakan gambar desain gedung, dan kemudian akan dibuat gedung nyatanya. Dalam contoh ini gambar desain gedung dapat kita kategorikan sebagai class dan gedung nyatanya sebagai implementasi dari gambar gedung yang dapat kita kategorikan sebagai object. Dari suatu class dapat dibuat beberapa object yang sama.

KARAKTERISTIK UTAMA PEMROGRAMAN BERORIENTASI OBJEK (PBO)

       Object itu secara mudahnya dapat dikatakan terdiri dari property dan method. Konsep object oriented memiliki karakteristik utama yaitu :

1.  PENGKAPSULAN  (ENCAPSULATION)

           Salah satu keistimewaan C++ adalah pengkapsulan. Pengkapsulan adalah  mengkombinasikan suatu struktur dengan fungsi yang memanipulasinya untuk membentuk tipe data baru yaitu kelas (class). Enkapsulasi juga bisa diartikan sebagai suatu mekanisme untuk menyembunyikan atau memproteksi suatu proses dari kemungkinan interferensi atau penyalahgunaan dari luar sistem sekaligus menyederhanakan penggunaan system itu sendiri. Akses ke internal sistem diatur sedemikian rupa melalui seperangkat interface. Kelas akan menutup rapat baik data maupun kode. Akses item di dalam kelas dikendalikan. Pengendalian ini tidak hanya berupa data tetapi juga kode. Saat kelas akan digunakan, kelas harus sudah dideklarasikan. Yang penting, pemakai kelas mengetahui deskripsi kelas, tetapi bukan implementasinya. Bagi pemakai, detail internal kelas tidak penting. Konsep ini disebut penyembunyian informasi (information hiding).

           Untuk menggunakan kelas, kita perlu mengetahui sesuatu tentangnya. Kita perlu mengetahui fungsi apa yang bisa digunakan dan data apa saja yang dapat diakses. Fungsi yang dapat digunakan dan data yang dapat diakses disebut antarmuka pemakai (user interface). Antarmuka pemakai menceritakan bagaimana kelas berperilaku, bukan bagaimana kelas dibuat. Kita tidak perlu mengetahui implementasi kelas. Sekali kelas dibuat, kita bisa memakainya berulang-ulang. Bagi pandangan pemakai, kelas adalah kotak hitam dengan perilaku tertentu.

           Contoh kasus sepeda motor, pada sistem pemindahan gigi transmisi, maka pengendara tidak perlu tahu detail dari bagaimana proses pemindahan gigi itu dilakukan oleh mesin, cukup tahu bagaimana menekan gigi transmisi itu. Pedal gigi transmisi yang diinjak pengendara itu merupakan interface (antar muka) pengendara dengan sistem transmisi sepeda motor. Jadi, bisa dikatakan enkapsulasi adalah sebuah prinsip yang digunakan ketika membangun struktur program secara keseluruhan yang mana setiap komponen dari program dibungkus, pembungkusan properti dan operasi dalam satu even. Secara simple dapat kita katakan bahwa kita menyembunyikan keruwetan kode-kode program dalam suatu object.J.

2.  PEWARISAN  (INHERITANCE)

           Suatu kelas dapat diciptakan berdasarkan kelas lain. Kelas baru ini mempunyai sifat-sifat yang sama dengan kelas pembentuknya, ditambah sifat-sifat khusus lainnya. Dengan pewarisan kita dapat menciptakan kelas baru yang mempunyai sifat sama dengan kelas lain tanpa harus menulis ulang bagian-bagian yang sama. Pewarisan merupakan unsur penting dalam pemrograman berorientasi objek dan merupakan blok bangunan dasar pertama penggunaan kode ulang (code reuse).

           Jika tidak ada fasilitas pewarisan ini, maka pemrograman dalam C++ akan tidak banyak berbeda dengan pemrograman C, hanya perbedaan dalam pengkapsulan saja yang menggunakan kelas sebagai pengganti struktur. Yang perlu menjadi catatan di sini adalah bahwa data dan fungsi yang dapat diwariskan hanya yang bersifat public dan protected. Untuk data dan fungsi private tetap tidak dapat diwariskan. Hal ini disebabkan sifat protected yang hanya dapat diakses dari dalam kelas saja. Sifat pewarisan ini menyebabkan kelas-kelas dalam pemrograman berorientasi objek membentuk hirarki kelas mulai dari kelas dasar, kelas turunan pertama, kelas turunan kedua dan seterusnya.

           Sebagai manusia kita sebenarnya terbiasa untuk melihat objek yang berada di sekitar kita tersusun secara hierarki berdasarkan class-nya masing-masing. Dari sini kemudian timbul suatu konsep tentang pewarisan yang merupakan suatu proses dimana suatu class diturunkan dari class lainnya sehingga ia mendapatkkan ciri atau sifat dari class tersebut. Perhatikan contoh hirarki berikut ini :

           Dari hirarki di atas dapat dilihat bahwa, semakin ke bawah, class akan semakin bersifat spesifik. Class mamalia memiliki seluruh sifat yang dimiliki oleh binatang, demikian halnya juga Anjing, kucing dan Monyet memiliki seluruh sifat yang diturunkan dari class mamalia. Dengan konsep ini, karakteristik yang dimiliki oleh class binatang cukup didefinisikan dalam class binatang saja.

           Class mamalia tidak perlu mendefinisikan ulang apa yang telah dimiliki oleh class binatang, karena sebagai class turunannya, ia akan mendapatkan karakteristik dari class binatang secara otomatis. Demikian juga dengan class anjing, kucing dan monyet, hanya perlu mendefinisikan karakteristik yang spesifik dimiliki oleh class-nya masing-masing. Dengan memanfaatkan konsep pewarisan ini dalam pemrograman, maka hanya perlu mendefinisikan karakteristik yang lebih umum akan didapatkan dari class darimana ia diturunkan.

3.  POLYMORPHISM  (POLIMORFISME)

           Polimorfisme merupakan fitur pemrograman berorientasi objek yang penting setelah pengkapsulan dan pewarisan. Polimorfisme berasal dari bahasa Yunani, poly (banyak) dan morphos (bentuk). Polimorfisme menggambarkan kemampuan kode C++ berperilaku berbeda tergantung situasi pada waktu run (program berjalan). Konstruksi ini memungkinkan untuk mengadakan ikatan dinamis (juga disebut ikatan tunda, atau ikatan akhir). Kalau fungsi-fungsi dari suatu kelas dasar didefinisikan ulang atau ditindih pada kelas turunan, maka objek-objek yang dihasilkan hirarki kelas berupa objek polimorfik.

           Polimorfik artinya mempunyai banyak bentuk atau punya kemampuan untuk mendefinisi banyak bentuk. Polimorphism merupakan suatu kondisi dimana dua object atau lebih mempunyai antarmuka yang identik namun mempunyai perilaku berbeda. Polimorphisme memberikan satu aksi untuk satu nama yang dipakai bersama pada satu hirarki kelas, yang mana masing-masing kelas hirarki menerapkan cara yang sesuai dengan dirinya.

          Dalam PBO, konsep ini memungkinkan digunakannya suatu interface yang sama untuk memerintah objek agar melakukan aksi atau tindakan yang mungkin secara prinsip sama namun secara proses berbeda. Dalam konsep yang lebih umum sering kali polymorphism disebut dalam istilah satu interface banyak aksi.

           Pada contoh diatas clas dasar adalah class bentuk yang memiliki atribut berupa Luas dan operasi hitung luas, class tersebut dapat diturunkan kedalam berbagai macam class bentuk seperti Segitiga, Lingkaran, Persegi panjang. Class Segitiga, Lingkaran, Persegi panjang memiliki atribut “Luas” dari hasil penurunan class bentuk, akan tetapi operasi hitung luas pada masing masing class akan berbeda-beda, inilah yang disebut sebagai polymorphism.

KENDALI  AKSES  TERHADAP  KELAS

       Tugas kelas adalah untuk menyembunyikan informasi yang tidak diperlukan oleh pemakai. Ada tiga macam pemakai kelas :
               1. kelas itu sendiri
               2. pemakai umum
               3. kelas turunan

       Setiap macam pemakai mempunyai hak aksesnya masing-masing. Hak akses ini ditandai dengan kenampakan anggota kelas. Kelas pada C++ menawarkan tiga aras kenampakan anggota kelas (baik anggota data maupun fungsi anggota) :

1.  PRIVATE

           Anggota kelas private mempunyai kendali akses yang paling ketat. Dalam bagian private, hanya fungsi anggota dari kelas itu yang dapat mengakses anggota private atau kelas yang dideklarasikan sebagai teman (friend). Dengan kata lain, Atribut ini menunjukan bahwa fungsi atau method tidak dapat diakses oleh objek lain.

2.  PUBLIC

           Dalam bagian public, anggotanya dapat diakses oleh fungsi anggota kelas itu sendiri, instance kelas, fungsi anggota kelas turunan. Suatu kelas agar bisa diakses dari luar kelas, misalnya dalam fungsi main(), perlu mempunyai hak akses publik. Hak akses ini yang biasanya digunakan sebagai perantara antara kelas dengan dunia luar. Dengan kata lain, atribut ini menunjukan bahwa fungsi/method dapat diakses oleh objek lain.

3.  PROTECTED

           Suatu kelas dapat dibuat berdasarkan kelas lain. Kelas baru ini mewarisi sifat-sifat dari kelas dasarnya. Dengan cara ini bisa dibentuk kelas turunan dari beberapa tingkat kelas dasar. Bila pada kelas dasar mempunyai anggota dengan hak akses terproteksi, maka anggota kelas ini akan dapat juga diakses oleh kelas turunannya. Anggota kelas terproteksi dibentuk dengan didahului kata kunci protected. Pada bagian protected, hanya fungsi anggota dari kelas dan kelas-kelas turunannya yang dapat mengakses anggota. Dengan kata lain, Atribut ini menunjukan bahwa fungsi atau method hanya bisa diakses oleh objek itu sendiri atau objek lain yang merupakan subclassnya.

       Dalam pemrograman berorientasi objek, jika kita telah menentukan suatu objek tertentu, maka objek tersebut kita definisikan dalam bentuk tipe baru yang namanya kelas. Tipe data kelas didefinisikan dengan kata kunci (keyword) class, yang merupakan generalisasi dari pernyataan struct. Pernyataan struct secara umum digantikan dengan pernyataan class. Jika objek kotak dideklarasikan dalam bentuk kelas, maka deklarasinya mirip dengan struktur.

                    class tkotak
                    {
                           double panjang;
                           double lebar;
                           public:
                           void SetUkuran(double pj, double lb);
                           double Keliling();
                           double Luas();
                    };
                    tkotak kotak;

       Dalam deklarasi kelas tersebut, muncul kata public. Data atau fungsi yang dideklarasikan di bawah kata kunci public mempunyai sifat dapat diakses dari luar kelas secara langsung. Dalam deklarasi tersebut, variabel panjang dan lebar tidak bersifat public, sehingga tidak dapat diakses secara langsung dari luar kelas. Dengan demikian perintah-perintah di bawah ini tidak dapat dijalankan.

                    kotak.panjang = 10;
                    kotak.lebar = 7;
                    cout<<”Panjang : ”<<kotak.panjang<<endl;
                    cout<<”Lebar : “<<kotak.lebar<<endl;

       Dalam kelas, masing-masing data dan fungsi anggota diberi sifat tertentu. Jika semua anggota kelas bersifat public, maka kelas sama dengan struktur. Untuk dapat mengakses data panjang dan lebar pada kelas tkotak harus dilakukan oleh fungsi yang menjadi anggota kelas dan bersifat public.

       Pada deklarasi kelas tkotak, satu-satunya jalan untuk memberi nilai panjang dan lebar adalah dengan menggunakan fungsi SetUkuran(). Untuk mengambil nilai panjang dan lebar juga harus dilakukan oleh fungsi yang menjadi anggota kelas. Misalnya, kita definisikan fungsi GetPanjang() dan GetLebar() untuk mengambil nilai panjang dan lebar. Sebagai contoh :

//program class
#include<iostream.h>
#include<conio.h>
class tkotak
{
      double panjang;
      double lebar;
      public:
      void SetUkuran(double pj, double lb);
      double Keliling();
      double Luas();
      double GetPanjang();
      double GetLebar();
};

int main()
{
      tkotak kotak;
      kotak.SetUkuran(10,7);
      cout<<"Panjang : "<<kotak.GetPanjang()<<endl;
      cout<<"Lebar : "<<kotak.GetLebar()<<endl;
      cout<<"Keliling : "<<kotak.Keliling()<<endl;
      cout<<"Luas : "<<kotak.Luas()<<endl;
      getch();
      return 0;
}

void tkotak::SetUkuran(double pj, double lb)
{
      panjang = pj;
      lebar = lb;
}

double tkotak::Keliling()
{
      return 2*(panjang+lebar);
}

double tkotak::Luas()
{
      return panjang*lebar;
}

double tkotak::GetPanjang()
{
      return panjang;
}

double tkotak::GetLebar()
{
      return lebar;
}

Dapat dilihat dari contoh program, bentuk pendefinisian kelas adalah sebagai berikut :
                    Tipe Nama_Kelas::NamaFungsi()
                    {
                          IsiFungsi
                    }

Untuk mendefinisikan variabel kelas, digunakan deklarasi :
                    Nama_Kelas Nama_Variabel;

Contoh :

       Tkotak kotak;

KONSTRUKTOR  &  DESTRUKTOR

       Konstruktor adalah fungsi khusus anggota kelas yang otomatis dijalankan pada saat penciptaan objek (mendeklarasikan instance). Konstruktor ditandai dengan namanya, yaitu sama dengan nama kelas. Konstruktor tidak mempunyai tipe hasil, bahkan juga bukan bertipe void. Biasanya konstruktor dipakai untuk inisialisasi anggota data dan melakukan operasi lain seperti membuka file dan melakukan alokasi memori secara dinamis. Meskipun konstruktor tidak harus ada di dalam kelas, tetapi jika diperlukan konstruktor dapat lebih dari satu.

Tiga jenis konstruktor :

1. Konstruktor default : tidak dapat meneriman argumen, anggota data diberi nilai awal tertentu.

2. Konstruktor penyalinan dengan parameter : anggota data diberi nilai awal berasal dari parameter.

3. Konstruktor penyalinan objek lain : parameter berupa objek lain, anggota data diberi nilai awal dari objek lain.

       Destruktor adalah pasangan konstruktor. Pada saat program menciptakan objek secara otomatis konstruktor akan dijalankan, yang biasanya dimaksudkan untuk memberi nilai awal variabel private. Sejalan dengan ini, C++ menyediakan fungsi destruktor (penghancur atau pelenyap) yang secara otomatis akan dijalankan pada saat berakhirnya kehidupan objek. Fungsi destruktor adalah untuk mendealokasikan memori dinamis yang diciptakan konstruktor. Nama destructor sama dengan nama kelas ditambah awalan karakter tilde (~).

TUGAS BAHASA PEMROGRAMAN 2

SOURCE  CODE

#include "iostream.h"

class persegi_panjang
{
    private:
        float panjang;
        float lebar;
        float luas;

    public:

    void input()
    {
        cout<<"Masukkan panjang = ";
        cin>>panjang;
        cout<<"Masukkan lebar = ";
        cin>>lebar;
    }

    void hitung()
    {
        luas = panjang * lebar;
    }

    void output()
    {
        cout<<"Luas persegi panjang = "<<panjang<<" * "<<lebar<<" = ";
        cout<<luas<<endl<<endl;
    }
};


void main()
{
    cout<<endl<<"\t\t\t\" TUGAS  BAHASA  PEMROGRAMAN  2 \""<<endl<<endl<<endl;
    cout<<"Nama\t:   Nurani Septiwulan"<<endl;
    cout<<"NPM\t:   0834010083"<<endl;
    cout<<"Kelas\t:   TF-D"<<endl<<endl<<endl<<endl;

    persegi_panjang a;
    a.input();
    a.hitung();
    a.output();

}


OUTPUT




NURANI  SEPTIWULAN  /  0834010083  /  TF-D

Tugas Perbaikan Quiz

TUGAS  PERBAIKAN QUIZ BAB SORTING

Sorting array X = [18,3,9,8,28,2] dengan menggunakan algoritma Straight SELECTION SORT

NURANI  SEPTIWULAN  (0834010083 / C )