Modu Loop

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 berori-

entasi 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

sistem (sistem perangkat lunak, sistem informasi atau sistem yang lain).

Pendekatan berorientasi obyek akan memandang sistem yang akan dikembangkan

sebagai suatu kumpulan obyek yang berkorespondensi dengan obyek-obyek dunia nyata.

Ada banyak cara untuk mengabstraksikan dan memodelkan obyek-obyek tersebut,

mulai dari abstraksi obyek, kelas, hubungan antar kelas sampai abstraksi sistem.

Saat mengabstraksikan dan memodelkan obyek ini, data dan proses-proses yang

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

Adalah abstraksi dari sesuatu yang mewakili dunia nyata seperti : benda, manusia,

satuan organisasi, tempat, kejadian, struktur, status atau hal-hal yang bersifat abstrak.

Suatu entitas yang mampu menyimpan informasi (status) dan mempunyai operasi

(kelakuan) yang dapat diterapkan atau dapat berpengaruh pada status obyek.

Dalam konteks Oop, obyek adalah instansiasi (yang dibentuk secara seketika)

dari kelas pada saat eksekusi.

Obyek mempunyai siklus hidup : diciptakan, dimanipulasi, dan dihancurkan.

Kelas

Adalah kumpulan dari obyek-obyek dengan karakteristik yang sama.

Adalah definis statik dari himpunan obyek yang sama yang mungkin lahir

atau diciptakan dari kelas tersebut.

Sebuah kelas akan mempunyai sifat (atribut) , kelakuan (operasi), hubungan

(relationsip) dan arti.

Suatu kelas dapat diturunkan dari kelas yang lain, dimana atribut dari kelas

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

oleh obyek.

Dapat berasal dari : model obyek, event, aktifitas atau aksi keadaan, fungsi,

kelakuan dunia nyata.

Klasifikasi Obyek

Menurut [BOO95] obyek dapat dibedakan menjadi :

ADT (abstract data type) definisi dari kelas dimana komponen type menjadi

atribut dan fungsi primitif menjadi operasi/metode/layanan.

Mesin, obyek pasif yang punya status yang akan diaktifkan oleh obyek lain,

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

L 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,

lingkaran dan bangun yang diarsir)

Menentukan atribut dari setiap obyek ( segiempat [panjang, lebar], lingkaran [

phi, jari], bangun yang diarsir [panjang, lebar, phi, jari])

Menentukan layanan untuk obyek ( segi empat [luas,keliling], lingkaran [luas,

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

Menentukan struktur dan hirarki obyek

Menginteraksikan obyek sedemikian sehingga solusi permasalahan bisa

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 :


//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

pengelolaan kompleksitas

Metode berorientasi obyek meliputi rangkaian aktifitas analisis berorientasi

obyek, perancangan berorientasi obyek, pemrograman berorientasi obyek, dan

pengujian berorientasi obyek.

Teknik yang digunakan, produk yang dihasilkan, prosedur verifikasi dan

criteria untuk setiap aktifitas yang dikerjakan

Alat Bantu untuk memodelkan (mendokumentasikan) hasil dari setiap

aktifitas.

Metode pengembangan perangkat lunak berorientasi obyek yang sudah dikenal

diantaranya adalah :

Object oriented analisis (OOA) dan object oriented design (OOD) dari Peter

Coad dan Edward Yourdon [1990]

Object Modeling Teknik (OMT) dari James Rumbaugh, Michael Braha,

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

menggunakan

Pulse Counter

No_Id

Zone_Bicara

Juml_Pulsa()

Clock

Hour

Minute

Second

Reset_ClockConvert_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 obyek-

obyek 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 <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;

public :

void isicargo(int u);

int banyakcargo(void);

void cetak(void);

};

void kendaraan :: isiroda(int b)

{

roda = b;

}

int kendaraan :: banyakroda(void)

{

return roda;

}

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 <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 :


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); // Get the values

total = GetTotal(noOfChecks, theChecks); // Add them up

cout.precision(2);

cout.setf(ios::showpoint);

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 :


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 <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; // Only in Car not Vehicle

};

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; // Only in Truck

};

// Global function

void GetRentalDate(char * date)

{

cout << "When are you returning the 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 : " << model << endl;

cout << "Mileage: " << 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

Modu Loop

Documents

Transcript of Modu Loop