Polymorphism

Ciri ketiga dari Object Oriented Programming adalah Polymorphism. Apakah polymorphism? Polymorphism adalah kemampuan dari object–object yang berbeda dalam sebuah class hirarki untuk melakukan fungsi (behavior) unik terhadap suatu respon message. Polymorphism mempunyai sifat single interface, multiple method. Hal ini dapat disebut juga kemampuan class menyembunyikan implementasi yg berbeda dalam interface yg sama. Polymorphism memungkinkan sebuah method yang mempunyai nama yang sama, namun tugas yang berbeda. Dengan polymorphism dimungkinkan suatu fungsi yang implementasi detilnya belum ada (isi fungsi belum ditulis). Fungsi tersebut akan dibuat virtual dan class yg berisi fungsi virtual akan menjadi abstract class / Abstract Data type (absract class biasanya adalah base class, dan tidak bisa dibuat instance).

Polymorphism sangat erat hubungannya dengan inheritance. Polymorphism dapat diimpelementasikan dengan 2 cara, yaitu Overloading Function (penggunaan kembali nama fungsi yang sama tapi dengan argumen yang berbeda) dan Overriding Function (sebuah fungsi dalam class turunan yang memiliki nama, return type dan argumen function yang sama dengan fungsi dalam class induk).

Polymorphism dibagi menjadi 2, yaitu trivial polymorphism dan trus polymorphism. Trivial polymorphism menggunakan overloading function dalam implementasinya, sedangkan pada true polymorphism, digunakan overriding function.

Contoh Polymorphism:
#include
class cA
{public: double A(double x)
{ return x*x;}
double B(double x)
{ return A(x)/5;}
double B(double x, double y) //Overloading Function/Trivial Polymorphism
{ return x/y;}
};
class cB: public cA
{public: double A(double x) //Overriding Function/True Polymorphism
{return x*x*x;}
};
void main()
{ cB oB;
cout << oB.B(10);
}

Inheritance (Lanjutan)

Pada Inheritance yang pertama, saya membahas tentang single inheritance. Pada bagian ini, saya akan membahas tentang multiple inheritance. Multiple Inheritance adalah sebuah kelas yang diturunkan dari beberapa kelas induk. Kelas turunan tersebut mewarisi karakteristik-karakteristik yang dimiliki oleh kelas-kelas induknya. Setiap kelas induk yang akan mewarisi karakteristiknya, dipisahkan dengan tanda koma(,) dan masing-masing kelas induk harus didahului dengan jenis aksesnya terlebih dahulu (private, protected, public).

Contoh:

class Pegawai
{ protected:
char NIP[10], Nama[30];
};
class Pendidikan
{ protected:
char Tingkat[20], Sekolah[80];
};
class Manajer : public Pegawai, public Pendidikan //Multiple Inheritance
{ private:
char Titel[20], Telpon[20];
};
class Peneliti : public Pegawai, public Pendidikan //Multiple Inheritance
{ private:
int Publikasi;
};
class Satpam : public Pegawai //Single Inheritance
{ };


Construcor dan Destructor pada Kelas Turunan
Constructor untuk kelas turunan perlu dibuat untuk melakukan inisialisasi kelas itu sendiri dan kelas induknya. Jika Constructor kelas induk memiliki parameter (argument), maka parameter Constructor kelas induk tersebut harus dimasukkan dalam Constructor kelas turunan. Destructor kelas turunan dijalankan dengan urutan yang terbalik dengan urutan Constructor, yaitu Destructor kelas turunan dijalankan terlebih dahulu baru destructor kelas induknya. Apabila kelas turunan memiliki lebih dari satu klas induk, setelah menjalankan destructor kelas turunan kemudian destructor kelas induk terakhir dijalankan sampai destructor kelas induk pertama dijalankan (sesuai dengan urutan terbalik dari penurunan kelas-kelas induk di dalam definisi kelas turunan tersebut).

Inheritance

Inherintance adalah proses pembentukan satu kelas baru (derived class) dari kelas lainnya (based class). Inheritance merupakan salah satu ciri dari object oriented programming. Dengan adanya inheritance, hal ini memungkinkan hal yang disebut dengan reusability (pendauran ulang suatu class agar dapat digunakan lagi di kedepannya). Kelas turunan mewarisi semua kemampuan yang dimiliki oleh kelas induk nya, dari data members maupun methods yang dideklarasikan dengan public atau protected (apabila private, maka tidak akan didapatkan oleh kelas turunan). Hubungan antar kelas turunan dan kelas induknya akan membentuk suatu hirarki kelas. Dalam OOP, perancangan hirarki kelas merupakan hal yang utama.

Ada 2 jenis inheritance, yaitu single inheritance dan multiple inheritance. Single berarti 1 kelas induk menhasilkan 1 atau lebih kelas turunan. Sedangkan multiple berarti 2 atau lebih kelas induk menhasilkan 1 atau lebih kelas turunan.

Pada perancangan hirarki kelas, kelas induk merupakan kelas yang mempunyai sifat (property) yang paling umum atau yang harus dimiliki oleh seluruh kelas turunannya. Sedangkan sifat yang khusus dimiliki oleh kelas-kelas turunannya, dimana sifat-sifat khusus tersebut digunakan untuk meningkatkan sifat atau kemampuan dari kelas induknya.

Contoh single inheritance:
class Mobil
{ protected: int roda;
};
class Kijang : public Mobil
{ protected: char tipe[20];
};

Anggota kelas induk dapat diakses hanya oleh anggota kelas turunan apabila jenis akses dari anggota kelas induk adalah public atau protected (private tidak dapat diakses).
Anggota protected suatu kelas tetap tidak dapat diakses oleh fungsi / kelas lainnya dalam program yang tidak menjadi anggota kelas turunan tersebut.

Array & Pointer of Class

Array pada C++ tidak terdapat range checking sehingga apabila kita compile, tidak akan ada error/warning sama sekali, tetapi ketika kita melakukan pengisian lebih dari array yang telah disediakan, maka akan terjadi error. Dan juga dalam penggunaannya, kita tidak dapat mengbandingkan yang 1 dengan yang lainnya (kecuali menggunakan function yang telah ada atau membandingkan isi array 1 demi 1) dan juga kita tidak dapat mengisi array secara langsung semuanya (harus mengisi 1 demi 1).
Sedangkan apabila kita mengimplemantasikan Array pada Class, maka akan dilakukan range checking terlebih dahulu. Jadi apabila terdapat isi array yang lebih, pada waktu dicompile akan terjadi warning/error. Dengan penggunaan Array pada Class, maka array dapat langsung dibandingkan dengan yang lainnya.
Pada implementasi Array pada class, juga dapat digunakan copy constructor agar dapat mengcopy object yang dibutuhkan.
Implementasi Pointer pada Class, apabila kita menggunakan Array, maka tempat yang disediakan akan terbatas sesuai dengan yang sudah kita alokasikan, tetapi apabila kita menggunakan pointer, kita dapat menggunakan sesuai kebutuhan kita. Alokasi memory pada array adalah static (sesuai dengan yang dialokasikan pada awal, apabila kurang, kita harus mengalokasikan lebih pada awalnya), sedangkan pada pointer alokasinya adalah dynamic (di mana alokasi memory sesuai dengan yang kita butuhkan).

Contoh implementasi pointer pada Class:
#include
class First
{ public:
int value;
First() {value = 0;}
int GetValue() {return value;}
};

class Second
{ int id;
public:
First *obj1;
Second() {id = 0;}
int GetName(){ return id;}
};

int main()
{ Second Obj2;
int num;
num = Obj2.GetName();
return 0;
}

Class (lanjutan)

Dalam menggunakan class dengan konsep enkapsulasi, sebaiknya untuk data member dimasukkan ke dalam private, agar data hanya bisa diakses oleh class tersebut. Sedangkan untuk function, diletakkan di public. Untuk data member, kenapa dimasukkan ke dalam private? Agar nilai-nilai dari data member tidak bisa diubah selain dari dalam class tersebut. Tapi kita tetap bisa mengambil/mengubah nilai yang berada di dalamnya dengan menggunakan setter dan getter. Berikut adalah contohnya:

#include
class data
{
private:
int no;
public:
int getNo() // getter
{
return(no);
}

void setNo(int x) // setter
{
no=x;
}

};


void main()
{
data obj;
obj.setNo(5);
cout << "Nilai dari No adalah: " << obj.getNo;
cout << endl;
cin.get();
}

Sebuah class dapat berisi object dari class lain (hal ini disebut dengan nested object). Member object disusun berurutan. Contohnya adalah class dengan member objects (host objects) berada setelah deklarasi class host object tersebut (perlu class prototype).

class B; // class prototype
class A
{ public: int i;
}
class B
{ public: int j;
A obj_A; //host object
}
B obj_B; // create object class B
Obj_B.Obj_A.i = 0; // inisialisasi member class A via object B


Tiap class member function memiliki hidden parameter -> pointer "this". This menunjuk kepada individual object. Pointer this dapat digunakan secara explicit.
Contoh penggunaan this:

class data
{
private:
int no;
public:
int getNo() // getter
{
return(no);
}

void setNo(int no) // setter
{
this->no=no; //dimaksudkan agar no yang berada di dalam class yang mendapat nilai
}

};

Class

Setelah membahas struct pada blog saya yang lalu, sekarang saya akan membahas class. Class sama seperti struct (mengelompokan data dan function ke dalam sebuah class/struct), perbedaannya adalah batasan aksesnya memiliki default private (sedangkan struct mempunyai default akses public).
contoh pembuatan class:
class Product
{ public:
int Prod_id;
char Prod_Name;
float Price;
int Stock_qty;
};
Product Brg1;

3 Access Level Class
Public:
Bagian class yang dapat diakses oleh umum baik dari dalam maupun dari luar class.
Protected:
Bagian class yang dapat diakses oleh linkungan internal class dan class turunannya.
Private:
Bagian class yang hanya dapat diakses oleh linkungan internal class itu sendiri.

Constructor dan Destructor
class Time
{ private:
int hour;
int minute;
int second;
public:
Time(); //constructor
void setTime( int, int, int );
void printUniversal();
void printStandard();
~Time(); //destructor
};

Constructor adalah member function yang pertama kali di kerjakan ketika satu object di create. Nama constructor harus sama dengan nama classnya dan digunakan untuk inisiasi object. Minimal harus ada 1 constructor dan bisa dioverload. Apalagi tidak ada constructor, maka compiler akan mengenerate default constructor untuk class tersebut

Destructor adalah member function yang di kerjakan ketika satu object di destroy / death (sebagai pengakhiran object). Nama destructor sama dengan nama class nya hanya ditambahkan tanda tilde (~) di awalannya dan digunakan untuk de-inisialisasi/dealokasi memori. Destructor hanya ada 1.


Deklarasi Object Class
Time timeObject; //object biasa
Time timeArray[ 10 ]; // object array
Time *timePtr; //object pointer
Time &timeRef = timeObject; // object reference

Struct

Struct merupakan jenis user define data type sehingga kita bisa meninisiasikan sebuah variabel dengan bermacam-macam bentuk data tidak seperti array yang hanya 1 jenis data type saja.
Cara mendeklarasikan struct adalah sebagai berikut:
struct Time // struct tag
{
int hour; // struct member
int minute; // struct member
int second; // struct member
};
dan cara untuk mendeklarasikannya adalah sebagai berikut:
Time timeObject; //variable biasa
Time timeArray[ 10 ]; // variable array
Time *timePtr; //variable pointer
Time &timeRef = timeObject; //reference

Cara untuk mengakses member struct adalah dengan menggunakan .(dot) apabila menggunakan variable basa, contohnya adalah cout << timeObject.hour;
Apabila menggunakan variable pointer/reference, digunakan ->(arrow) untuk mengakses datanya, contohnya adalah cout << timePtr->hour;

Nested Struct adalah struct yang terdapat didalam struct. Contohnya adalah sebagai berikut:
struct Date
{
int tgl;
int bln;
int thn;
};
struct Employee
{
int ID;
int Name;
Date hire;
};