Anda di halaman 1dari 33

Pertemuan 1 Pengantar Pemrograman Berorientasi Obyek Pemrograman Berorientasi Obyek (PBO) Tujuan : a.

mempelajari konsep dasar dan teknik pembuatan program dengan pendekatan Obyek. b. mempelajari penulisan obyek dalam salah satu bahasa pemrograman berorientasi obyek (visual c++) Materi : 1. Konsep dasar pemrograman berorientasi obyek (obyek oriented programming) 2. Pengantar bahasa pemrograman visual c++ 3. Oop dengan enkapsulasi 4. Oop dengan hubungan antar obyek client suplier 5. Pewarisan (inheritance) 6. Polimorfisme dan Generalitas Konsep Dasar Pemrograman Berorientasi Obyek Adalah suatu teknik atau cara pendekatan baru dalam melihat permasalahan dari Pendekatan berorientasi obyek akan memandang sistem yang akan dikembangkan

sistem (sistem perangkat lunak, sistem informasi atau sistem yang lain). sebagai suatu kumpulan obyek yang berkorespondensi dengan obyek-obyek dunia nyata. Ada banyak cara untuk mengabstraksikan dan memodelkan obyek-obyek tersebut, Saat mengabstraksikan dan memodelkan obyek ini, data dan proses-proses yang

mulai dari abstraksi obyek, kelas, hubungan antar kelas sampai abstraksi sistem. dipunyai oleh obyek akan dienkapsulasi (dibungkus) menjadi satu kesatuan. Contoh : Tinjau aktifitas kuliah pada suatu sistem akademik. Dari aktifitas kuliah tersebut secara eksplisit ada 3 obyek yang langsung dapat dikenali yaitu : Dosen yang memberikan kuliah, Mahasiswa yang mengikuti kuliah, dan Materi kuliah yang disampaikan. Secara

implisit ada 2 obyek lain yang dapat dikenali yaitu : Jadwal kapan kuliah akan diadakan dan Nilai yang didapat mahasiswa dari mata kuliah yang sudah diikutinya. Abstraksi dan pemodelan untuk salah satu dari kelima obyek tersebut, misalnya untuk obyek Dosen adalah : diabstraksikan menjadi Kelas Dosen terdiri dari atribut : Kode Dosen, Nama Dosen dan Pendidikan, yang mempunyai operasi : rekam, update, retrieve dll. Dalam rekayasa perangkat lunak konsep pendekatan berorientasi obyek dapat

diterapkan pada tahap analisis, perancangan, pemrograman dan pengujian perangkat lunak. Ada berbagai teknik ynag dapat digunakan pada masing-masing tahap tersebut, dengan aturan dan alat bantu pemodelan tertentu. Obyek Kelas Adalah kumpulan dari obyek-obyek dengan karakteristik yang sama. Adalah definis statik dari himpunan obyek yang sama yang mungkin lahir Adalah abstraksi dari sesuatu yang mewakili dunia nyata seperti : benda, manusia, Suatu entitas yang mampu menyimpan informasi (status) dan mempunyai operasi

satuan organisasi, tempat, kejadian, struktur, status atau hal-hal yang bersifat abstrak. (kelakuan) yang dapat diterapkan atau dapat berpengaruh pada status obyek. Dalam konteks Oop, obyek adalah instansiasi (yang dibentuk secara seketika) Obyek mempunyai siklus hidup : diciptakan, dimanipulasi, dan dihancurkan.

dari kelas pada saat eksekusi.

atau diciptakan dari kelas tersebut. Sebuah kelas akan mempunyai sifat (atribut) , kelakuan (operasi), hubungan Suatu kelas dapat diturunkan dari kelas yang lain, dimana atribut dari kelas

(relationsip) dan arti. semula dapat diwariskan ke kelas yang baru.

Property Obyek Atribut Nilai atau elemen-elemen data yang dimiliki oleh obyek dalam kelas obyek. Merupakan ciri dari sebuah obyek. Dipunyai secara individual oleh sebuah obyek

Layanan (Service) Metode atau operasi yang berfungsi untuk memanipulasi obyek itu sendiri Fungsi atau transformasi yang dapat dilakukan terhadap obyek atau dilakukan Dapat berasal dari : model obyek, event, aktifitas atau aksi keadaan, fungsi,

oleh obyek. kelakuan dunia nyata. Klasifikasi Obyek Menurut [BOO95] obyek dapat dibedakan menjadi : ADT (abstract data type) definisi dari kelas dimana komponen type menjadi Mesin, obyek pasif yang punya status yang akan diaktifkan oleh obyek lain,

atribut dan fungsi primitif menjadi operasi/metode/layanan. fungsi primitigf pada mesin merupakan mekanisme transisi yang mengubah suatu status ke status lain. Proses, obyek aktif yang mempunyai urutan kendali (thread of control).

Pertemuan 2 Karakteristik Sistem Berorientasi Obyek Sistem Berorientasi Obyek Sebuah sistem yang dibangun dengan berdasarkan metode berorientasi obyek

adalah sebuah sistem yang komponennya dibungkus (dienkapsulasi) menjadi kelompok data dan fungsi. Setiap komponen dalam sistem tersebut dapat mewarisi atribut dan sifat dari komponen lainnya, dan dapat berinteraksi satu sama lainnya.

Karekteristik atau sifat-sifat yang dipunyai sebuah sistem berorientasi obyek adalah : Abstraksi,

prinsip untuk merepresentasikan dunia nyata yang komplek menjadi satu bentuk model yang sederhana dengan mengabaikan aspek-aspek lain yang tidak sesuai dengan permasalahan. Enkapsulasi,

pembungkusan atribut data dan layanan (operasi-operasi) yang dipunyai obyek, untuk menyembunyikan implementasi dari obyek sehingga obyek lain tidak mengetahui cara kerjanya. Pewarisan (inheritance),

mekanisme yang memungkinkan suatu obyek (kelas) mewarisi sebagian atau seluruh definisi dari obyek lain sebagai bagian dari dirinya. Reusability,

pemanfaatan kembali obyek yang sudah didefinisikan untuk suatu permasalahan pada permasalahan lainnya yang melibatkan obyek tersebut. Generalisasi dan spesialisasi,

menunjukan hubungan antara kelas dan obyek yang umum dengan kelas dan obyek yang khusus. Komunikasi antar obyek,

dapat dilakukan lewat pesan (message) yang dikirim dari satu obyek ke obyek lainnya. Polymorphism,

kemampuan suatu obyek untuk digunakan dibanyak tujuan yang berbeda dengan nama yang sama sehingga dapat menghemat pemakaian baris program.

Pertemuan 3 Pemrograman Prosedural dan Pemrograman Obyek Pemrograman prosedural terdiri dari : Bagian deklarasi data atau variabel agian deklarasi prosedur atau fungsi Bagian program utama

Tinjau masalah perhitungan luas bangun geometri Berikut jika panjang, lebar dan jari-jari diketahui.

P Penyelesaian dengan cara prosedural : 1. Hitung luas segi empat 2. Hitung luas lingkaran 3. Hitung selisih luas segi empat dengan luas lingkaran Program Visual C++ secara modular : #include <iostream.h> // deklarasi variabel publik float panjang, lebar, jari; // deklarasi prosedur / fungsi float luassegiempat() { return(panjang * lebar); } float luaslingkaran()

{ return(3.14 * jari * jari); } // program utama void main() { panjang=10; lebar = 6; jari = 2; cout << Luas Bangun = << luassegiempat() luaslingkaran(); return; } Pemrograman pendekatan obyek dengan abstraksi data type : pemrograman dengan satu atau beberapa obyek tetapi obyek tersebut tidak berinteraksi satu sama lain (berdiri sendiri). Penyelesaian pemrograman dengan pendekatan obyek adalah : Menentukan obyek yang ada pada lingkup permasalahan (segi empat, Menentukan atribut dari setiap obyek ( segiempat [panjang, lebar], lingkaran [

lingkaran dan bangun yang diarsir) phi, jari], bangun yang diarsir [panjang, lebar, phi, jari]) Menentukan layanan untuk obyek ( segi empat [luas,keliling], lingkaran [luas, Menentukan struktur dan hirarki obyek Menginteraksikan obyek sedemikian sehingga solusi permasalahan bisa

keliling, diameter], bangung yang diarsir[luas])

diselesaikan.

Pertemuan 4 Penerapan program Berorintasi Obyek Apabila kita lihat kembali permaslahan bangun pada pertemuan 3 diatas maka dapat kita implementasikan kedalam pemrograman berorintasi obyek sebagai berikut : #include <iostream.h> //deklarasi kelas class segiempat { public: // deklarasi atribut float panjang, lebar; // deklarasi layanan float luas() { return(panjang * lebar); } float keliling() { return(2 * (panjang + lebar); } } // program utama void main() { //ciptakan obyek segiempat s; //manipulasi obyek

cout << panjang : ; cin >> s.panjang; cout << lebar cin >> s.lebar; cout << Luas Bangun = << s.luas() <<endl; cout << Keliling Bangun = << s.keliling << endl; return; } : ;

Pertemuan 5 Metodologi Pemrograman Berorientasi Obyek Pengertian Metodologi Berorientasi Obyek Suatu strategi pembangunan perangkat lunak yang mengorganisasikan

perangkat lunak sebagai kumpulan obyek yang berisi data dan operasi yang diberlakukan terhadapnya. Suatu cara bagaimana system perangkat lunak dibangun melalui pendekatan obyek secara sistematis Metode berorientasi obyek didasarkan pada penerapan prinsip-prinsip Metode berorientasi obyek meliputi rangkaian aktifitas analisis berorientasi

pengelolaan kompleksitas obyek, perancangan berorientasi obyek, pemrograman berorientasi obyek, dan pengujian berorientasi obyek. aktifitas. Metode pengembangan perangkat lunak berorientasi obyek yang sudah dikenal diantaranya adalah : Object oriented analisis (OOA) dan object oriented design (OOD) dari Peter Object Modeling Teknik (OMT) dari James Rumbaugh, Michael Braha, Teknik yang digunakan, produk yang dihasilkan, prosedur verifikasi dan Alat Bantu untuk memodelkan (mendokumentasikan) hasil dari setiap

criteria untuk setiap aktifitas yang dikerjakan

Coad dan Edward Yourdon [1990] William premerlan, Frederick Eddy, dan William Lorensen [1991] Object Oriented Software Engineering (OOSE) dari Ivar Jacobson [1992] Booch Method dari Grady Booch [1994] Syntropy dari Steve Cook dan John Daniels [1994] UML (Unified Modeling Language) dari James Rumbaugh, Grady Booch dan

Ivar Jacobson [1997].

Pertemuan 6 OOP Dengan Hubungan Obyek Client Suplier Obyek oriented programming dimana ada satu obyek atau lebih yang menyediakan atribut dan layanan untuk digunakan oleh obyek yang lain. Hubungan obyek tersebut dapat diimplementasikan dengan : hubungan memakai, berisi, dijelaskan oleh, di Oleh (hubungan seperti pada ERD). Perhatkan gambar hubungan antar obyek dibawah ini antara Pulse Counter dan Clock yang mempunyai hubungan Pulse Counter menggunakan Clock

Pulse Counter

No_Id Zone_Bicara

Juml_Pulsa()

Clock Hour Minute Second menggunakan Reset_Clock Convert_2Second

Reset_Clock adalah prosedur untuk memberi nilai atribut dengan argumennya Convert_2Second adalah fungsi untuk merubah jam menjadi detik Juml_Pulsa adalah fungsi untuk menghitung pemakaian pulsa (lama bicara / satuan pulsa)

Pertemuan 7 Studi Kasus Amati obyek-obyek yang terdapat dalam suatu system penjualan tiket kereta api terdiri dari : Kereta api, Jadwal kereta api Loket Penumpang Pemesenan tiket Penjualan tiket

Dari obyek-obyek diatas gambarkan model hubungan obyek client supplier dari obyekobyek diatas. Saudara dapat mengamati system-sistem yang lain yang dapat saudara gunakan untuk menentukan model hubungan dari obyek yang ada. Sehingga pemahaman model hubungan obyek dapat lebih saudara pahami.

Pertemuan 8 Konstruktor dan Destruktor Konstruktor adalah sebuah fungsi yang merupakan anggota dari class dan namanya sama dengan nama class. Fungsi konstruktor dikerjakan pada saat program memasuki bagian deklarasi obyek. Destruktor adalah sebuah fungsi yang mempunyai nama yang sama dengan sebuah class tetapi didahului oleh tanda ~. Biasanya suatu obyek memerlukan suatu proses pada saat akan dibuang, proses-proses tersebut dapat dimasukan kedalam fungsi destruktor. Perhatikan contoh program obyek dibawah ini : # include <iostream.h> class antrian { int a[100]; int d,b; public : antrian(void); //construktor ~antrian(void); //destruktor void aisi(int I); int aambil(void); }; //fungsi untuk constructor antrian :: ~antrian(void) { cout << Membuang antrian \n; } void antrian :: aisi(int i) { if (d == 100) { cout << Antrian Penuh ;

return; } d++; a[d] = i; } int antrian :: aambil(void) { if (d == b) { cout << Antrian Habis; return; } b++; return a[b]; } main(void); { antrian ant1,ant2; ant1.aisi(10); ant2.aisi(15); ant1.aisi(25); ant2.aisi(5); cout << Isi antrian pertama : ; cout << ant1.aambil() << ; cout << ant1.aambil() << \n; cout << Isi antrian kedua : ; cout << ant2.aambil() << ; cout << ant2.aambil() << \n; return; } Pertemuan 9 Pewarisan (inheritance)

Pewarisan (inheritance) adalah mekanisme yang memungkinkan suatu obyek (kelas) mewarisi sebagian atau seluruh definisi dari obyek lain sebagai bagian dari dirinya. Dengan pewarisan kita dapat memasukan sebuah class kedalam class yang lainnya. Perhatikan contoh program pewarisan dibawah ini : #include <iostream.h> #include <conio.h> class kendaraan { int roda; int penumpang; public : void isiroda(int b); int banyakroda(void); void isipenumpang(int b); int banyakpenumpang(void); }; class truk : public kendaraan { int cargo; void isicargo(int u); int banyakcargo(void); void cetak(void); }; void kendaraan :: isiroda(int b) { roda = b; } int kendaraan :: banyakroda(void) { return roda; public :

} void kendaraan :: isipenumpang(int b) { penumpang = b; } int kendaraan :: banyakpenumpang(void) { return penumpang; } void truk :: isi_cargo(int b) { cargo = b; } int truk :: banyakcargo(void) { return cargo; } void truk :: cetak(void) { cout << \n Roda : << banyakroda() << \n; cout << Penumpang : << banyakpenumpang() << \n; cout << Kapasitas Cargo : << cargo << \n; } main(void) { truk t1,t2; t1.isiroda(18); t1.isipenumpang(2); t1.isicargo(3200); t2.isiroda(6); t2.isipenumpang(3);

t2.isicargo(1200); t1.cetak(); t2.cetak(); } Pada contoh diatas class kendaraan mendefinisikan semua jenis kendaraan. Class tersebut menyimpan banyaknya roda dan penumpang. Class truk adalah bagian dari class kendaraan.

Pertemuan 10 Function Overloading Function overloading adalah cara untuk mewujudkan polimorfisme. Di dalam Visual C+ + , beberapa fungsi dapat memakai nama yang sama asalkan deklarasi parameternya berbeda. Proses beberapa fungsi memakai nama yang sama dinamakan function overloading. Perhatikan contoh program dibawah ini : #include <iostream.h> #include <conio.h> int pangkat(int i); double pangkat(double d); long pangkat(long l); main() { cout << pangkat(25) << \ n ; cout << pangkat(26.0) << \ n ; cout << pangkat(5L) << \ n ; return; } int pangkat(int i) { cout << Didalam fungsi pangkat bilangan bulat \n; return i*i; } double pangkat(double d) { cout << Didalam fungsi pangkat bilangan double \n; return d*d;

} long pangkat(long l) { cout << Didalam fungsi pangkat bilangan long \n; return l*l; } Program diatas membuat tiga fungsi dengan nama pangkat. Kompiler bisa mengetahui harus memakai fungsi yang mana untuk setiap pemanggilan dengan melihat argumennya. Keuntungan functionoverload adalah untuk menangani kompleksitas program.

Pertemuan 11 Alokasi Memori Alokasi memori digunakan untuk meminta memori dari heap, yang akan digunakan oleh suatu proses program. Memori heap dapat dialokasikan dan didealokasikan apabila suatu proses program tidak lagi membutuhkan memori. Memori yang digunakan bisa berbentu memori dinamis yaitu: proses mengalokasikan dan mendealokasikan memori heap dari dalam program. Perhatikan contoh program untuk alokasi memori dibawah ini : #include <iostream.h> int HowMany(); void GetChecks(int noOfChecks, float * theChecks); float GetTotal(int noOfChecks, const float * theChecks); void main() { int noOfChecks; float total; float * theChecks; // Will point to allocated memory cout << "** Monthly Checkbook Program **" << endl << endl; noOfChecks = HowMany(); // Ask the user how many checks

// Allocate the memory, 1 float per check theChecks = new float [noOfChecks]; GetChecks(noOfChecks, theChecks); cout.precision(2); cout.setf(ios::showpoint); // Get the values total = GetTotal(noOfChecks, theChecks); // Add them up

cout.setf(ios::fixed); cout << endl << endl << "Your total was $" << total << " for the month." << endl; delete [] theChecks; return; } //*********************************************************** int HowMany() { int ans; // To hold the cin value cout << "How many checks did you write last month? "; cin >> ans; return (ans); } //*********************************************************** void GetChecks(int noOfChecks, float * theChecks) { int ctr; // No need or vehicle for passing allocated memory. The // memory does not go away between functions or blocks. cout << endl << "You now must enter the checks, one at a time." << endl << endl; for (ctr=0; ctr< noOfChecks; ctr++) { cout << "How much was check " << (ctr+1) << " for? "; cin >> theChecks[ctr]; // Store value on the heap } return; } //*********************************************************** float GetTotal(int noOfChecks, const float * theChecks)

{ // Add up the check totals int ctr; float total = 0.0; for (ctr=0; ctr<noOfChecks; ctr++) { total += theChecks[ctr]; } return total; }

Pertemuan 12 Fungsi Virtual Fungsi virtual digunakan untuk memanggil sebuah fungsi yang tergantung oleh tipe obyek kelas. Untuk menggunakan fungsi virtual digunakan mekanisme khusus dengan memakai kata kunci virtual di depan pengenal fungsi. Perhatikan contoh penulisan dibawah ini : class A { public : virtual void print() { cout << Ada printed << endl; } }; A a; a.print(); Contoh program pemakaian fungsi virtual : #include <iostream.h> class BaseClass { public: void Plain() { cout << "BaseClass::Plain()" << endl; } virtual void Virtual() { cout << "BaseClass::Virtual()" << endl; }

void CallVirtual() { Virtual(); } }; class DerivedClass : public BaseClass { public: void Plain() { cout << "DerivedClass::Plain()" << endl; } virtual void Virtual() { cout << "DerivedClass::Virtual()" << endl; } }; void main() { BaseClass baseClass; DerivedClass derivedClass; baseClass.Plain(); baseClass.Virtual(); baseClass.CallVirtual(); cout << endl; derivedClass.Plain(); derivedClass.Virtual();

derivedClass.CallVirtual(); cout << endl;

BaseClass * basePointer = &baseClass; BaseClass * derivedPointer = &derivedClass; // NB type of pointer is base class basePointer->Plain(); basePointer->Virtual(); basePointer->CallVirtual(); cout << endl; derivedPointer->Plain(); derivedPointer->Virtual(); derivedPointer->CallVirtual(); cout << endl; }

Pertemuan 13 Polimorfisme Polymorphism adalah kemampuan suatu obyek untuk digunakan dibanyak tujuan yang berbeda dengan nama yang sama sehingga dapat menghemat pemakaian baris program. Perhatikan contoh program obyek dengan menggunakan polymorphisme. #include <iostream.h> #include <string.h>

// Base class class Vehicle { public: virtual ~Vehicle() {} // Virtual destructor // does nothing but safe

void Print() const; // Never overridden virtual void Rent(const char * ReturnDate); // Could be protected: Vehicle(long Mileage, const char * Model); // Not needed public virtual const char * GetRentalType() const = 0; virtual void PrintAdditionalDetails() const = 0; private: long mileage; char model[21]; char returnDate[9]; }; class Car : public Vehicle { // Car is derived from Vehicle

public: Car(long Mileage, const char * Model,char Category); protected: const char * GetRentalType() const // Still virtual { return "Car"; } void PrintAdditionalDetails() const; // still virtual private: char category; }; class Truck: public Vehicle // Truck is derived from Vehicle { public: Truck(long Mileage, const char * Model,float MaxLoad); protected: virtual const char * GetRentalType() const { return "Truck"; } virtual void PrintAdditionalDetails() const; private: float maxLoad; }; // Global function void GetRentalDate(char * date) { cout << "When are you returning the vehicle?"; // Only in Truck // Only in Car not Vehicle

cin.getline(date,9); } //-----------------------------------------------------------// Main is here! //-----------------------------------------------------------void main() { char type; char rentalDate[9]; Vehicle * vehicle; // Ask what type of rental cout << "Rent car (c) or truck (t)? "; cin >> type; cin.ignore(80,'\n'); if (type == 't' || type == 'T') // truck rental vehicle = new Truck(4000,"Dodge",3.5F); else // Car rental vehicle = new Car(2500,"Buick",'B'); // Normal function GetRentalDate(rentalDate); vehicle->Rent(rentalDate); // Not overridden vehicle->Print(); delete vehicle; } //-----------------------------------------------------------// Vehicle class functions // Vehicle::Vehicle(long Mileage, const char * Model)

{ mileage = Mileage; // could have used intialization list strcpy(model,Model); returnDate[0] = '\0'; // zero length string } void Vehicle::Print() const { cout << GetRentalType() << " Rental" << endl; cout << "Model : cout << "Mileage: " << model << endl; " << mileage << endl;

cout << "Rented till: " ; if (returnDate[0]) // a test to see if first char is // a terminator cout << returnDate; else cout << "Not rented"; cout << endl; PrintAdditionalDetails(); } void Vehicle::Rent(const char * RentalDate) { strcpy(returnDate,RentalDate); } //-----------------------------------------------------------// Car class functions // Car::Car(long Mileage, const char * Model, char Category) : Vehicle(Mileage,Model) // calls base constructor

{ category = Category; } void Car::PrintAdditionalDetails() const { cout << "Category : " << category << endl; } //-----------------------------------------------------------// Turck class functions // Truck::Truck(long Mileage, const char * Model, float MaxLoad) : Vehicle(Mileage,Model) { maxLoad = MaxLoad; } void Truck::PrintAdditionalDetails() const { cout << "Max load : " << maxLoad << endl; }

Pertemuan 14 Studi Kasus Sebuah sistem penjualan obat pada sebuah apotek, memberikan pelayanan penjualan obat kepada pelanggannya dengan menyediakan obat-obatan yang dibutuhkan oleh pelanggannya. Apotek menyimpan data suplier dan obat-obatnya untuk melakukan pemesanan obat yang dibutuhkan pelanggannya. Apotek membuat daftar pesanan obat kepada suplier berdasarkan stok obat dan permintaan obat dari pelanggan. Apotek mencatat data obat yang telah diterima dari suplier dan daftar harga obat yang akan dipasarkan kepada konsumen. Apotek mencatat transaksi penjualan obat kepada konsumen dengan mencatat daftar obat yang dijual, serta dokter yang membuat resep obat apabila obat diterima dari dokter. Apotek membuat datar penjualan obat, daftar stok obat dan daftar penerimaan obat. Dari kasus tersebut diatas tentukan Class dan obyek-obyeknya. Model hubungan antar obyek Diaagram Implementasi program berorientasi obyek