KELAS DAN OBJEK.

KELAS DAN OBJEK
KELAS
Adalah bentuk penyederhanaan dari suatu permasalahan yang berkaitan dengan objek yang
digunakan untuk merepresentasikan sebuah objek tertentu sehingga akan membantu dalam proses
penyelesaian masalah kompleks.
BU kelas :
Class nama kelas{
Acces specifier1;
Data member;
Member function;
......
Acces specifier2;
Data member;
Member function;
........
}
BU dari pendefinisian fungsi tersebut
Tipedata nama_kelas::nama_fungsi(daftar parameter) {
Statement yang akan dilakukan;
}
BU dari proses pengaksesan data atau fungsi dari sebuah kelas
Nama_instance.data
Atau
Nama_instance.nama_fungsi(daftar parameter)
Kode program 11-1
#include <iostream>
using namespace std;
class CONTOH {
int X;
public:
void set_X(int XX);
int get_X();
// Mendeklarasikan fungsi set_X
// Mendeklarasikan fungsi get_X
}
// Bagian implementasi dari fungsi set_X
void CONTOH::set_X(int XX) {
X = XX;
}
// Bagian implementasi dari fungsi get_X
int CONTOH::get_X() {
return X;
}
// Fungsi utama
int main() {
// Membuat instance dari kelas CONTOH dengan nama ob
CONTOH ob;
// Mengakses fungsi set_X yang terdapat pada kelas CONTOH
ob.set_X(100);
// Mengakses fungsi get_X yang terdapat pada kelas CONTOH
cout<<ob.get_X();
return 0;
}
100
CONSTRUCTOR DAN DESTRUKTOR
Construktor adalah sebuah fungsi khusus yang otomatis akan dipanggil setiap kali melakukan
instansiasi terhadap suatu kelas.
Ciri
1. Namanya sama dengan nama kelas
2. Selalu menjadi pemberian nilai awal
3. Secara otomatis terpanggil pada saat suatu kelas didefinisikan
Kode Program 11-2
#include <iostream>
using namespace std;
// Membuat kelas dengan nama CONTOH
class CONTOH {
int X;
public:
// Membuat constructor
CONTOH() {
X = 10; // Melakukan inisialisasi nilai X dengan nilai 10
}
// Membuat member function
void ShowX() {
cout<<"Nilai X : "<<X<<endl;
}
//...
};
int main() {
// Melakukan instansiasi terhadap kelas CONTOH
// dengan nama instance O
CONTOH O;
// Memanggil fungsi ShowX
O.ShowX();
return 0;
}
Nilai X= 10
Kode Program 11-3
#include <iostream>
using namespace std;
// Membuat kelas dengan nama CONTOH
class CONTOH {
int X;
public:
// Membuat constructor tanpa parameter
CONTOH() {
X = 10; // Melakukan inisialisasi nilai X dengan nilai 10
}
// Membuat constructor dengan menggunakan satu parameter
CONTOH(int XX) {
X = XX;
}
// Membuat member function
void ShowX() {
cout<<"Nilai X : "<<X<<endl;
}
//...
};
int main() {
// Melakukan instansiasi terhadap kelas CONTOH
// dengan nama instance O
CONTOH O;
// Melakukan instansiasi terhadap kelas CONTOH
// dengan nama instance P
CONTOH P(200);
// Memanggil fungsi ShowX
O.ShowX();
P.ShowX();
return 0;
}
Nilai X=10
Nilai X=200
Kode Program 11-4
#include <iostream>
using namespace std;
// Membuat kelas dengan nama CONTOH
class CONTOH {
int X;
public:
// Membuat constructor tanpa parameter
CONTOH() : X(10) {
}
// Membuat constructor dengan menggunakan satu parameter
CONTOH(int XX) : X(XX) {
}
// Membuat member function
void ShowX() {
cout<<"Nilai X : "<<X<<endl;
}
//...
};
int main() {
// Melakukan instansiasi terhadap kelas CONTOH
// dengan nama instance O
CONTOH O;
// Melakukan instansiasi terhadap kelas CONTOH
// dengan nama instance P
CONTOH P(200);
// Memanggil fungsi ShowX
O.ShowX();
P.ShowX();
return 0;
}
Destruktor (~).
1. namanya sama dengan construktor karena harus berpasangan
2. menggunakan tanda (~)
3. prosesnya berlawanan dengan konstruktor dan dilaksanakan di akhir proses program
Kode Program 11-5
#include <iostream>
using namespace std;
// Membuat kelas dengan nama CONTOH
class CONTOH {
int *X;
public:
// Membuat constructor
CONTOH(int XX) {
X = new int;
// Memesan ruang memori
*X = XX;
}
// Membuat destructor
~CONTOH() {
delete X;
// Menghapus pointer X;
}
void ShowX() {
cout<<"Nilai X : "<<*X<<endl;
}
// ...
};
// Fungsi utama
int main() {
CONTOH O(10);
O.ShowX();
return 0;
}
Nilai X=10
TINGKAT AKSES
1.Private
Berguna untuk memberikan hak akses data hanya sebagai kepada kelas yang bersangkutan saja
Kode Program 11-6
#include <iostream>
using namespace std;
class CONTOH {
int X;
// X bersifat private
public:
void SetX(int XX) {
X = XX;
}
void ShowX() {
cout<<"Nilai X : "<<X<<endl;
}
};
// Fungsi utama
int main() {
CONTOH O;
O.SetX(100);
O.ShowX()
return 0;
}
Hasil : 100
2. Public
Berfungsi untuk memberikan hak akses secara umum (public) kepada kelas kelas turunannya
maupun terhadap lingkungan luar di dalam program.
Kode Program 11-7
#include <iostream>
using namespace std;
class CONTOH {
int X;
public:
void SetX(int XX) {
X = XX;
}
int KuadratX() {
return X * X;
}
// …
};
// Fungsi utama
int main() {
CONTOH O;
int hasil;
// Melakukan pemanggilan terhadap fungsi-fungsi di dalam
// kelas CONTOH
O.SetX(10);
hasil = O.KuadratX();
cout<<"Hasil : "<<hasil;
return 0;
}
Hasil : 100
3.Protected
Digunakan untuk memberikan hak akses terhadap data dalam suatu kelas sehingga data tersebut
dapat diakses oleh kelas keturunannya, namun lingkungan luar di dalam program masih tetap tidak
diberi hak untuk mengaksesnya.
Kode Program 11-8
#include <iostream>
using namespace std;
// Membuat kelas DASAR yang didalamnya terdapat data
// dalam bagian protected
class DASAR {
protected:
int X;
public:
DASAR() { X = 10; } // Inisialisasi nilai X dengan nilai 10
//...
};
// Membuat kelas TURUNAN sebagai hasil turunan dari kelas DASAR
class TURUNAN: public DASAR {
int Y, hasil;
public:
void SetY(int YY) {
Y = YY;
}
void KaliXY() {
hasil = X * Y; // Menggunakan nilai X dari kelas DASAR
}
int GetHasil() {
return hasil;
}
};
// Fungsi utama
int main() {
DASAR A;
TURUNAN B;
B.SetY(5);
B.KaliXY();
cout<<"\nHasil X kali Y : "<<B.GetHasil();
return 0;
}
Hasil X kali Y : 50
HUBUNGAN ANTARA STRUKTUR DAN KELAS
1. Membuat Kelas dengan Menggunakan Kata Kunci struct
#include <iostream>
using namespace std;
// Membuat kelas MOTOR
struct MOTOR {
char* merk;
long tahun;
char* nopolisi;
char* warna;
public:
void SetMotor() {
merk = "Honda GL Pro";
tahun = 1997;
nopolisi = "G 5879 BF";
warna = "Hitam";
}
void ShowInfoMotor() {
cout<<"Merk
: "<<merk<<endl;
cout<<"Tahun : "<<tahun<<endl;
cout<<"No Polisi : "<<nopolisi<<endl;
cout<<"Warna : "<<warna<<endl;
}
};
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas MOTOR
MOTOR M;
M.SetMotor();
M.ShowInfoMotor();
return 0;
}
2. Membuat Kelas dengan Menggunakan Kata Kunci class
#include <iostream>
using namespace std;
// Membuat kelas MOTOR
class MOTOR {
char* merk;
long tahun;
char* nopolisi;
char* warna;
public:
void SetMotor() {
merk = "Honda GL Pro";
tahun = 1997;
nopolisi = "G 5879 BF";
warna = "Hitam";
}
void ShowInfoMotor() {
cout<<"Merk
: "<<merk<<endl;
cout<<"Tahun
: "<<tahun<<endl;
cout<<"No Polisi
: "<<nopolisi<<endl;
cout<<"Warna
: "<<warna<<endl;
}
};
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas MOTOR
MOTOR M;
M.SetMotor();
M.ShowInfoMotor();
return 0;
}
Merk
Tahun
No. Polisi
Warna
: Honda GL Pro
: 2007
: G 5879 BF
: Hitam
ANGGOTA KELAS YANG BERSIFAT STATIS
Data Statis
Kode Program 11-11
#include <iostream>
using namespace std;
class CONTOH {
static int X;
// variabel statik
int Y;
// variabel non-statik
public:
// Constructor kelas CONTOH
CONTOH(int XX, int YY) {
X = XX;
Y = YY;
}
// Fungsi untuk menampilkan nilai X dan Y
void ShowXY() {
cout<<"Nilai X : "<<X<<endl;
cout<<"Nilai Y : "<<Y<<endl;
cout<<endl;
}
};
// Mendefinisikan X
int CONTOH::X;
// Fungsi utama
int main() {
// Membuat instance A dengan X=10 dan Y=10
CONTOH A(10, 10);
// Menampilkan nilai X dan Y dari instance A
cout<<"Di dalam objek A"<<endl;
A.ShowXY();
// Membuat instance B dengan X=50 dan Y=50
CONTOH B(50, 50);
// Menampilkan nilai X dan Y dari instance B
cout<<"Di dalam objek B"<<endl;
B.ShowXY();
// Menampilkan kembali nilai X dan Y dari instance A
cout<<"Di dalam objek A"<<endl;
A.ShowXY();
return 0;
}
Di dalam objek A
Nilai X : 10
Nilai Y : 10
Di dalam objek B
Nilai X : 50
Nilai Y : 50
Di dalam objek A
Nilai X : 50
Nilai Y : 10
Fungsi Statis
Kode Program 11-12
#include <iostream>
using namespace std;
class CONTOH {
static int X;
public:
static void Inisialisasi(int XX) {
X = XX;
}
void ShowX() {
cout<<"Nilai X : "<<X<<endl;
}
};
// Mendefinisikan X
int CONTOH::X;
// Fungsi utama
int main() {
// Memanggil fungsi Inisialisasi sebelum
// sebuah objek/instance dibuat
CONTOH::Inisialisasi(25);
// Melakukan instansiasi terhadap kelas CONTOH
// dengan nama instance A
CONTOH A;
// Memanggil fungsi ShowX kepunyaan kelas CONTOH
A.ShowX();
return 0;
}
Nilai X : 25
POINTER KE OBJEK
#include <iostream>
using namespace std;
// Membuat kelas
class CONTOH {
int X;
public:
void SetX(int XX) {
X = XX;
}
void ShowX() {
cout<<"Nilai X : "<<X<<endl;
}
};
// Fungsi utama
int main() {
// Mendeklarasikan pointer yang menunjuk ke kelas CONTOH
CONTOH *P;
// Mengalokasikan memori untuk kelas CONTOH
P = new CONTOH;
// P menunjuk ke alamat
// yang baru dialokasikan
// Memanggil fungsi-fungsi milik kelas CONTOH,
// yaitu dengan operator ->
P->SetX(100); // Ingat, bukan menggunakan titik,
// karena P adalah pointer
P->ShowX();
return 0;
}
Nilai X : 100
POINTER this
Adalah pointer otomatis yng dilewatkan setiap kali objek dibuat di dalam memori dan akan mewakili
nama kelas yang bersangkutan.
Kode Program 11-14
#include <iostream>
using namespace std;
class KUBUS {
int S;
public:
void SetS(int SS);
int GetVolume();
void ShowVolume();
};
void KUBUS::SetS(int SS) {
this->S = SS;
}
int KUBUS::GetVolume() {
return (this->S * this->S * this->S);
}
void KUBUS::ShowVolume() {
cout<<"Volume Kubus : "<<this->GetVolume()<<endl;
}
// Fungsi utama
int main() {
KUBUS K;
K.SetS(5);
K.ShowVolume();
return 0;
}
Volume Kubus : 125
OBJEK SEBAGAI PARAMETER DALAM SEBUAH FUNGSI
#include <iostream>
using namespace std;
class CONTOH {
int X;
public:
void SetX(int XX) {
X = XX;
}
int GetX() {
return X;
}
};
int Kuadrat(CONTOH A, int N) {
A.SetX(N);
return (A.GetX() * A.GetX());
}
int main() {
CONTOH O;
// Memanggil fungsi Kuadrat
cout<<"Kuadrat dari 10 adalah : "<<Kuadrat(O,10);
return 0;
}
Kuadrat dari 10 adalah : 100
OBJEK SEBAGAI NILAI KEMBALIAN DALAM SEBUAH FUNGSI
Kode Program 11-16
#include <iostream>
using namespace std;
class CONTOH {
int X;
public:
void SetX(int XX) {
X = XX;
}
int GetX() {
return X;
}
};
CONTOH MyFunc() {
CONTOH A;
A.SetX(30);
return A;
// Mengembalikan nilai yag berupa objek
}
int main() {
CONTOH O;
// Memanggil fungsi Kali2 dan nilainya dimasukkan
// ke dalam objek O
O = MyFunc();
cout<<"Nilai X di dalam O adalah : "<<O.GetX();
return 0;
}
Nilai X di dalam O adalah : 30
FRIEND FUNCTION
Kita diizinkan membuat fungsi luar yang dapat mengakses bagian private suatu kelas
Kode Program 11-17
#include <iostream>
using namespace std;
class CONTOH{
int X, Y;
public:
void SetXY(int XX, int YY) {
X = XX;
Y = YY;
}
friend int KALI(CONTOH A);
};
// Mendefinisikan fungsi KALI yang bukan termasuk member function
// dari kelas CONTOH
int KALI(CONTOH A) {
// Mengakses bagian private secara langsung dari kelas CONTOH
return (A.X * A.Y);
}
// Fungsi utama
int main() {
// Melakukan instansiasi kelas CONTOH
CONTOH O;
O.SetXY(20, 3);// Mengeset nilai X=20 dan Y=3
cout<<"Hasil kali : "<<KALI(O);
return 0;
}
Hasil kali : 60
FRIEND CLASS
Kelas yang dapat mengakses semua data ( termasuk bagian private) dari kelas lain
Kode Program 11-18
#include <iostream>
using namespace std;
class KESATU {
int X, Y;
public:
KESATU(int XX, int YY) {
X = XX;
Y = YY;
}
friend class KEDUA; // Mendeklarasikan sebuah friend class
};
// Definisi dari kelas KEDUA
class KEDUA {
// …
public:
int Kali(KESATU A);
// …
};
int KEDUA::Kali(KESATU A) {
return (A.X * A.Y);
};
int main() {
// Melakukan instansiasi dari kelas KESATU
KESATU O(40, 3);
// Melakukan instansiasi dari kelas KEDUA
KEDUA P;
// Memanggil fungsi Kali yang terdapat pada kelas KEDUA
cout<<"Hasil kali : "<<P.Kali(O);
return 0;
}
Hasil Kali : 120
Oooo 00000 oooo