Encapsulation (OOP) pada C++

Ciri penting lainnya dari OOP adalah encapsulation. Encapsulation adalah
sebuah proses dimana tidak ada akses langsung ke data yang diberikan, bahkan
hidden. Jika ingin mendapat data, maka harus berinteraksi dengan objek yang
bertanggung jawab atas dara tersebut. Berikut cirri dari encapsulation:
1. Variabel dan method dalam suatu obyek dibungkus agar terlindungi
2. Untuk mengakses, variabel dan method yang sudah dibungkus tadi perlu
interface
3. Setelah variabel dan method dibungkus, hak akses terhadapnya dapat ditentukan.
4. Konsep pembungkusan ini pada dasarnya merupakan perluasan dari tipe data
struktur
Dua hal dalam enkapsulasi :
1. Information hiding
2. Menyediakan perantara (method) untuk mengakses data
Pada intinya, encapsulation adalah pemisahan antara bagian private dan
public pada sebuah objek. Atau, dapat dipandang sebagai pemisahan antara interface
(bagian private) dan implementation (bagian public).
Objek-objek lain yang hendak berinteraksi dengan objek ini akan mengirimkan
sebuah pesan (message) dan objek ini akan mengerjakan sesuatu dan mengirimkan
pesan balik sebagai jawaban jika diperlukan.
Keuntungan utama dari encapsulation tentu saja adalah penyembunyian
implementasi (implementation hiding). Dengan implementation hiding, kita dapat
memperbaiki bagaimana objek kita bekerja tanpa harus khawatir bagaimana
menginformasikan perubahan tersebut ke objek-objek yang lain. Selama kita tidak
merubah interface dari objek kita, objek-objek yang lain akan tetap dapat
menggunkan objek kita.
Contoh-8 //penggunaan encapsulation
#include <conio.h>
#include <iostream.h>
class satu_kandang
{
int kandang;
public:

void atur(int nilai);
int hasil(void);
};
void satu_kandang :: atur(int nilai)
{
kandang = nilai;
}
int satu_kandang :: hasil(void)
{
return kandang;
}
void main()
{
satu_kandang ayam1, ayam2, ayam3;
int bebek;
ayam1.atur(5);
ayam2.atur(7);
ayam3.atur(2);
bebek=20;
cout<<" Nilai dari ayam1 adalah "<<ayam1.hasil()<<endl;
cout<<" Nilai dari ayam2 adalah "<<ayam2.hasil()<<endl;
cout<<" Nilai dari ayam3 adalah "<<ayam3.hasil()<<endl;
cout<<" Nilai dari bebek adalah "<<bebek<<endl;
getch();
}

Output yang dihasilkan dari program contoh-8 di atas adalah:

Polymorphism (OOP) pada C++

Polymorphisms adalah kemampuan 2 buah object yang berbeda untuk
merespon pesan permintaan yang sama dalam suatu cara yang unik. Contoh, saya
melatih lumba-lumba saya dengan perintah untuk meloncat dan juga saya melatih
burung untuk merespon perintah saya untuk berkicau. Saya lakukan latihan untuk
merespon kepada mereka dengan perintah lisan. Melalui polymorphism saya tahu
bahwa anjing dan burung akan merespon dengan gonggongan atau kicauan.
Dengan cara dan kemampuan seperti ini, jenis akses tertentu dapat
diterapakan dengan berbagai cara oleh objek-objek yang memiliki tipe yang berbeda
atau memiliki banyak bentuk. Fungsi virtual merupakan dasar dari polymorphism
yang berkerja hanya dengan pointer-pointer dan referensi dan hanya
mendeklarasikan method sebagai virtual.
Adapun aturan dari virtual function sebagai berikut:
1. Virtual function harus anggota class.
2. Anggota class bukan anggota yang bersifat statis.
3. Anggota class dapat diakses dengan pointer objek.
4. Virtual function tidak dapat memiliki virtual constructor, akan tetapi dapat
berupa virtual destructor.
Contoh-7 //Penggunaan Polymorphism
#include <iostream.h>
#include <conio.h>
class HewanPeliharaan
{
public:
void lucu()
{
cout<<" Lucunya hewan peliharaan"<<endl;
}
virtual void makan()// anggota class
{
cout<<" Makan... dibutuhkan hewan peliharaan"<<endl;
}
};
class Jinak : public HewanPeliharaan
{

public:
void lucu()
{
cout<<" Lucu dan Jinak"<<endl;
}
virtual void makan()
{
cout<<" Diberi makan agar jinak"<<endl;
}
};
class Kucing : public Jinak
{
public:
void lucu()
{
cout<<" Lucunya kucing"<<endl;
}
virtual void makan()
{
cout<<" Makanan dibutuhkan Kucing"<<endl;
}
};
void main()
{
//definisi Objek Jinak dan Kucing puma
Jinak jinak;
Kucing puma;
//definisi pointer ke objek
HewanPeliharaan *hewan;
hewan=&jinak;
hewan->lucu();
hewan->makan();
cout<<" -----------------------------"<<endl;
hewan = &puma;
hewan->lucu();
hewan->makan();
getch();
}
Output yang dihasilkan dari program contoh-7 di atas adalah:

Inheritance (OOP) pada C++

Pada waktu mendeklarasikan suatu kelas, anda dapat menandai bahwa suatu
kelas berasal dari mana, yaitu dengan tanda titik dua (:) setelah nama kelas, tipe
asalnya bias berupa public atau yang lainnya dan dari kelas mana berasal. Berikut
penulisan sintaksisnya:
Class kucing_besar : Public predator
Contoh-6 //pengunaan inheritance
#include <iostream.h>
#include <conio.h>
enum KETURUNAN { PUMA, TUTUL, SINGA, MACAN };
class Predator
{
public:
// constructors
Predator():Usianya(10), Bobotnya(5){}
~Predator() {}

//accessors
int Umurnya() const {return Usianya; }
void SetUmur (int Umur) { Usianya = Umur; }
int Beratnya () const { return Bobotnya; }
void SetBerat(int Berat) { Bobotnya=Berat; }
// method lainnya
void Meraung() const { cout<< "Meraung ... suara
Predator!\n";}
void Tidur() const {cout<< "ssshhh… Predator Tidur.\n";}
protected:
int Usianya;
int Bobotnya;
};
class Kucing_besar : public Predator
{
public:
//constructors
Kucing_besar () : Keturunannya (SINGA) {}
~Kucing_besar() {}
//Accessors
KETURUNAN DptKeturunan() const {
return Keturunannya; }
void setKeturunan(KETURUNAN keturunan) {
Keturunannya = keturunan; }
//other methods
void Melompat() { cout<<" Melompat ...\n"; }
void Berburu() { cout<<" Berburu ... ingin makan \n"; }
private:
KETURUNAN Keturunannya;
};
int main()
{
Kucing_besar Sibelang;
Sibelang.Meraung();
Sibelang.Berburu();
cout<<" Umur Raja Hutan adalah: "<<Sibelang.Umurnya();
cout<<" Tahun Usianya \n";
getch();
}

Output yang dihasilkan dari program contoh-6 di atas adalah:

Array pada Kelas (OOP) pada C++

Anggota dari suatu kelas dapat pula berupa array. Berikut ini contoh anggota
dari suatu kelas yang berupa array.
Contoh-5 //Class dg Array & Fungsi
#include <conio.h>

#include <iostream.h>
class kerja
{
public :
char nik[10],nm[25];
int jam; double total;
float lembur(int l);
};
main()
{
int x,y,a=1,b=1;
double grand=0;
kerja kary[15];
cout<<endl<<"Jumlah Data :";cin>>y;
for(x=0;x<y;x++)
{
cout<<endl<<" Data Ke-:"<<a++<<endl;
cout<<" NIK :";cin>>kary[x].nik;
cout<<" Nama Karyawan :";cin>>kary[x].nm;
cout<<" Jumlah Jam :";cin>>kary[x].jam;
}
clrscr();
gotoxy(14,3);cout<<"Daftar Gaji Mingguan\n";
gotoxy(16,4);cout<<"Karyawan Honorer\n";
cout<<" -------------------------------------------------\n"
<<" No. NIK Nama Jumlah Upah Total\n"
<<" Karyawan Jam Lembur Gaji\n"
<<" -------------------------------------------------\n";
for(x=0;x<y;x++)
{
gotoxy(3,wherey());cout<<b++<<".";
gotoxy(7,wherey());cout<<kary[x].nik;
gotoxy(15,wherey());cout<<kary[x].nm;
gotoxy(30,wherey());cout<<kary[x].jam;
gotoxy(36,wherey());cout<<kary[x].lembur(kary[x].jam);
kary[x].total=(40*20000)+kary[x].lembur(kary[x].jam);
gotoxy(44,wherey());cout<<kary[x].total<<endl;
grand=grand+kary[x].total;
}
cout<<" -------------------------------------------------\n";
cout<<" Total Keseluruhan Karyawan :";
gotoxy(44,wherey());cout<<grand<<endl;
getch();
}
float kerja::lembur(int l)
{
if (l>40)
return(l-40)*30000;

else
return 0;
}

Output yang dihasilkan dari program contoh-5 di atas adalah:

Destruktor (OOP) pada C++

Destruktor merupakan suatu fungsi anggota yang dijalankan secara otomatis
manakala suatu objek akan terbebas dari memori karena lingkup keberadaannya telah
menyelesaikan tugasnya.
Destruktor harus mempunyai nama yang sama dengan kelas dan diawali
karakter tilde(~) atau karakter tak terhingga.
Destruktor digunakan secara khusus manakala suatu objek menggunakan
memori dinamis selama keberadaannya dan kemudian melepaskan memori itu
setelah tidak menggunakannya lagi.
Contoh-4 //Destruktor
#include <conio.h>
#include <iostream.h>
#include <string.h>
class motor
{
private :
char *merk;
float cc_mesin; long harga;
public :
motor(char *nama, float cc, long hrg);//konstruktor
~motor();//destruktor
void keterangan();
};
void main()
{
clrscr();
motor sport("Honda CBR",500,30500000);
motor matic("Honda Vario",125,14500000);
sport.keterangan();
matic.keterangan();

getch();
}
motor :: motor(char *nama, float cc, long hrg)
{
merk = new char[25];//merubah data karakter menjadi string
strcpy(merk,nama);
cc_mesin=cc;
harga=hrg;
}
motor :: ~motor()
{
delete [] merk;//menghapus memori karakter pd merk
}
void motor :: keterangan()
{
cout<<"\n Informasi Motor:"<<endl
<<" Merk = "<<merk<<endl
<<" CC Mesin = "<<cc_mesin<<endl
<<" Harga = "<<harga<<endl<<endl;
}

Output yang dihasilkan dari program contoh-4 di atas adalah:

Konstruktor (OOP) pada C++

Konstruktor (constructor) merupakan suatu fungsi dari anggota suatu kelas
yang memiliki nama yang sama dengan nama kelas fungsi itu berada.
Konstruktor ini digunakan untuk mengalokasikan ruang untuk suatu objek dan untuk
memberikan nilai awal.
Berikut contoh pendeklarasian suatu konstruktor di dalam sebuah kelas:
class hitung
{
private:
int a;
int b;

public:

int inta();
int intb();
hitung(int mudah); //deklarasi constructor
};
Contoh-3 //Konstruktor
#include <conio.h>
#include <iostream.h>
class bilangan
{
private :
int bulat;
double nyata;
public :
bilangan(); //konstruktor
void info();
};
void main()
{
clrscr();
bilangan a;
a.info();
bilangan b;
b.info();
getch();
}
bilangan :: bilangan()
{
cout<<"\n Konstruktor dijalankan ... "<<endl;
bulat = 5.2;
nyata = 3.6;
}
void bilangan :: info()
{
cout<<"\n Jenis Bilangan: "<<endl
<<" Bulat = "<<bulat<<endl
<<" Nyata = "<<nyata<<endl;
}

Output yang dihasilkan dari program contoh-3 di atas adalah:

B. Private pada Kelas (OOP) pada C++

Private digunakan pada kelas untuk memproteksi anggota-anggota tertentunya agar
tidak dapat diakses dari luar kelas secara langsung.
Contoh-2 //Penggunaan private pada class
#include <conio.h>
#include <iostream.h>
#define pi 3.14
class tabung
{
private :
int j,t;
float v,k;
public :
tabung();
void keluaran();
};
void main()
{
clrscr();
tabung s;
s.keluaran();

getch();
}
tabung :: tabung()
{
cout<<"\n Menghitung Tabung"<<endl
<<" -----------------"<<endl<<endl;
cout<<" Masukan Jari-jari = ";cin>>j;
cout<<" Masukan Tinggi = ";cin>>t;
v=(pi*j*j)*t;
k=(2*(pi*2*j))+t;
}
void tabung :: keluaran()
{
cout<<endl
<<" Volume Tabung = "<<v<<endl
<<" Keliling Tabung = "<<k<<endl;
}

Class OOP pada C++

Pengertian OOP
Object Oriented Programming atau yang lebih dikenal dengan OOP adalah
pemrograman yang menitikberatkan kepada objek-objek untuk menyelesaikan tugas
atau proses dari program tersebut. Sedangkan penitikberatkan ini dimaksudkan
adanya interaksi pengiriman nilai, pesan atau pernyataan antar objek. Kemudian
objek yang merespon hasil dari interaksi tersebut akan membentuk suatu tindakan
atau aksi (methode).

Pernyataan diatas digunakan untuk mendefinisikan variabel bernama sport.
Pada C++ variabel seperti sport berkedudukan sebagai variabel kelas yang biasa
disebut dengan objek.
Pada sebuah kelas, item-item di dalamnya bisa bersifat private atau public. Secara
default, semua item di dalam kelas bersifat private. Jadi tanpa menuliskan kata kunci
private, semua item di dalam kelas sudah private.


Karakterisitk OOP
Di dalam penggunaan konsep pemrograman yang berbasis objek atau yang
disebut Object Oriented Pemrograman (OOP), haruslah memiliki karakteirstik.
Adapun karakteristik tersebut adalah memiliki sifat turunan atau pewarisan
(Inheritance), satu nama memiliki banayak sifat atau perilaku (Polymorphism),
pembungkusan sifat dari objek yang berbeda (Encapsulation). Berikut akan
dijelaskan karakteristik OOP tersebut:


Inheritance
Inheritance memungkinkan programmer untuk "menurunkan" sebuah class
menjadi class lain yang lebih spesifik dan memiliki fungsi yang lebih komplit.
Inheritance merepresentasikan hubungan "seperti" atau "sejenis" (a kind of). Sebagai

contoh, sebuah perahu motor adalah seperti perahu namun dengan kemampuan lebih,
yakni memiliki motor. Contoh lain adalah kendaraan jenis mobil (sebagai super
class) dan memiliki tipe sport (sebagai subclass), bila digabung menjadi mobil sport.
Ketika kita menurunkan sebuah class dari class yang lain, class yang baru
akan mewarisi semua attribute dan method dari class yang sudah ada. Class yang
sudah ada disebut dengan base class atau super class atau parent class dan class
yang baru disebut dengan derived class atau subclass, atau child class. Dengan
inheritance, kita dapat men daur ulang program kita atau bahkan men daur ulang
program orang lain agar sesuai dengan kebutuhan kita.
Tanpa inheritance, kelas merupakan sebuah unit yang berdiri sendiri.
Inheritance akan membentuk suatu konsep dimana jika konsep yang diatas berubah
maka perubahan akan juga berlaku pada yang ada dibawahnya. Inherate sangat mirip
dengan hubungan orang tua dengan anak. Manakala suatu kelas menerima warisan,
semua anggota data dan fungsi juga akan menerima warisan, walalupun tidak
semuanya akan dapat di akses oleh anggota fungsi dari kelas.
Di dalam C++ penentuan akses pada inheritance ada tiga macam, yaitu :

1. Public
Penentuan akses berbasis public menyebabkan anggota dari public dari sebuah
kelas utama akan menjadi anggota public kelas turunan dan menyebabkan juga
anggota protect kelas utama menjadi anggota protect kelas turunan, namun untuk
anggota kelas private tetap pada private kelas utama.
2. Private
Penentu akses berbasis private menyebabkan anggota dari anggota public dari
kelas utama akan menjadi anggota protect kelas turunan, dan menyebabkan
anggota dari kelas utama menjadi anggota protect kelas turunan, namun untuk
anggota kelas private tetap pada private kelas utama.
3. Protected
Penentu akses berbasis protect menyebabkan anggota dari anggota protect dan
public dari kelas utama akan menjadi anggota private dari kelas turunan.
Anggota private dari kelas utama selalu menjadi anggota private kelas utama.





A. Public pada kelas
Public (public) menyatakan bahwa deklarasi variabel atau item-item yang ada di
dalam kelas dapat diakses dari luar kelas.
Contoh-1 //Penggunaan public pada class
#include <iostream.h>
#include <conio.h>
garis()
{
cout<<"==============================\n";
}
class siswa
{
public :
char nis[9],nama[20];
float nilai;
};
main()
{
clrscr();
siswa sekolah;
garis();cout<<endl;
cout<<"\t Program Nilai Siswa"<<endl
<<"\t -------------------"<<endl;
cout<<" Input NIS = ";cin>>sekolah.nis;
cout<<" Input Nama Siswa = ";cin>>sekolah.nama;
cout<<" Input Nilai Akhir = ";cin>>sekolah.nilai;
clrscr();
garis();cout<<endl;
cout<<"\t Nilai Siswa"<<endl
<<"\t ------------"<<endl<<endl
<<" NIS = "<<sekolah.nis<<endl
<<" Nama Siswa = "<<sekolah.nama<<endl
<<" Nilai Akhir = "<<sekolah.nilai<<endl;
garis();
getch();