Penjelasan dan Macam-macam Tipe Relationship antar Object

Object Relationships

Sebelumnya telah di jelaskan mengenai Object relationship di bagian penjelasan dari pengertian Object Oriented Programing, yang menjelaskan tentang paradigm pemrograman yang beroriontasi kepada object, dan object sendiri sama seperti yang ada pada dunia nyata, bahwa object dapat saling berelasi dan kadang relasi tersebut membentuk pola untuk menciptakan object yang besar.

Dan di sini penulis tegaskan bahwa relasi antar object umumnya memliki 3 macam tipe, yaitu:

1. Compositon
2. Association
3. Aggregation

Penjelasan dari Macam-macam Tipe Object Relationships

Composition

Composition merupakan relasi dengan model “bagian dari”, masing-masing object akan saling bergantung, dan hubungan dari mereka akan menentukan jangka hidup masing-masing dari mereka.

Contoh: relasi badan manusia dengan jantung, jika salah satu mati maka yang lainnya tidak akan bisa bertahan.

Contoh Program:
jantung.h

#ifndef JANTUNG_H
#define JANTUNG_H

class jantung{
    public:
        jantung(){
            cout<<"jantung dihidupkan\n";
        }
        ~jantung(){
            cout<<"jantung dimatikan\n";
        }
};

#endif // JANTUNG_H

manusia.h

#ifndef MANUSIA_H
#define MANUSIA_H

class manusia{
public:
    std::string name;
    jantung varJantung;

    manusia(std::string pName)
    : name(pName){
        cout<<name<<" hidup\n";
    }
    ~manusia(){
        cout<<name<<" mati\n";
    }
};

#endif // JANTUNG_H

main.cpp

#include <iostream>
#include <string>
using namespace std;

#include "jantung.h"
#include "manusia.h"

int main(){
    manusia *varManusia = new manusia("budi");
    delete varManusia;
    return 0;
}

Pada contoh program di atas, dicontohkan bagaimana relasi antar object bekerja dengan tipe relasi composition.

Pada file main.cpp, dilakukan penghapusan memori terhadap object varManusia, dengan dilakukan hal tersebut maka otomatis akan menghapus object varJantung yang berada di dalam object varManusia.

Association

Association merupakan object yang independen tapi berelasi, masing-masing object memiliki jangka hidup mereka sendiri dan tidak ada yang namanya kepemilikan.

Contoh : hubungan antara dokter dan pasien, yang masing-masin memiliki jangka hidupnya sendiri, dan mereka dapat memutuskan atau mengganti hubungan kapan saja.

Contoh Program:

#include <iostream>
#include <vector>
using namespace std;

class dokter;
class pasien{
public:
    string nama;
    vector<dokter *> daftar_dokter;
    pasien(string pNama):nama(pNama){
		cout<<"Pasien \""<<nama<<"\" ada\n";
    }
	~pasien(){
		cout<<"Pasien \""<<nama<<"\" tidak ada\n";
    }
    void tambahDokter(dokter*);
	void cetakDokter();
};

class dokter{
public:
    string nama;
	vector<pasien *> daftar_pasien;

    dokter(string pNama):nama(pNama){
		cout<<"Dokter \""<<nama<<"\" ada\n";
    }
	~dokter(){
		cout<<"Dokter \""<<nama<<"\" tidak ada\n";
    }
	void tambahPasien(pasien*);
	void cetakPasien();
};

void pasien::tambahDokter(dokter *pDokter){
	daftar_dokter.push_back(pDokter);
}
void pasien::cetakDokter(){
    cout<<"Daftar Dokter dari pasien \""<<this->nama<<"\":\n";
    for (auto &a : daftar_dokter){
        cout<<a->nama<<"\n";
    }
    cout<<endl;
}
void dokter::tambahPasien(pasien *pPasien){
	daftar_pasien.push_back(pPasien);
	pPasien->tambahDokter(this);
}
void dokter::cetakPasien(){
    cout<<"Daftar Pasien dari dokter \""<<this->nama<<"\":\n";
    for (auto &a : daftar_pasien){
        cout<<a->nama<<"\n";
    }
    cout<<endl;
}

int main(){
	dokter *varDokter = new dokter("budi");
	dokter *varDokter2 = new dokter("tono");
	pasien *varPasien = new pasien("andi");
	pasien *varPasien2 = new pasien("doni");

	varDokter->tambahPasien(varPasien);
	varDokter->tambahPasien(varPasien2);
	varDokter2->tambahPasien(varPasien);

   	 varDokter->cetakPasien();
	varDokter2->cetakPasien();
	varPasien->cetakDokter();
	varPasien2->cetakDokter();

	delete varPasien;
	delete varPasien2;
	delete varDokter;
	delete varDokter2;

	return 0;
}

Pada contoh di atas, dicontohkan bagaimana relasi object dengan tipe association bekerja.

Pada contoh program di atas, terdapat 2 macam object, yaitu; dokter dan pasien. Masing-masing object berdiri sendiri, dan dapat berelasi dengan banyak object lainnya, seperti 1 dokter dapat berelasi dengan 2 pasien, dan pasien juga bisa memiliki relasi dengan dokter lebih dari satu.

Keberadaan atau jangka hidup dari masing-masing object tidak mempengaruhi kehidupan object lainnya.

Aggregation

Aggregation merupakan relasi dengan model “memiliki”, dimana semua object memiliki jangka kehidupanya masing-masing dan adanya sebuah relasi kepemilikan lebih dari satu.

Contoh: hubungan antara anak dan orang tua, dimana masing-masing memiliki jangka kehidupan masing-masing, dan orang tua memiliki (banyak) anak.
Contoh Program:
anak.h

#ifndef ANAK_H
#define ANAK_H

class anak{
public:
    string nama;
    anak(string pNama):nama(pNama){
		cout<<"Anak \""<<nama<<"\" ada\n";
    }
	~anak(){
		cout<<"Anak \""<<nama<<"\" tidak ada\n";
    }
};
#endif

ibu.h

#ifndef IBU_H
#define IBU_H

class ibu{
public:
    string nama;
	vector<anak *> daftar_anak;

    ibu(string pNama):nama(pNama){
		cout<<"Ibu \""<<nama<<"\" ada\n";
    }
	~ibu(){
		cout<<"Ibu \""<<nama<<"\" tidak ada\n";
    }
	void tambahAnak(anak*);
	void cetakAnak();
};
void ibu::tambahAnak(anak *pAnak){
	daftar_anak.push_back(pAnak);
}
void ibu::cetakAnak(){
    cout<<"Daftar Anak dari Ibu \""<<this->nama<<"\":\n";
    for (auto &a : daftar_anak){
        cout<<a->nama<<"\n";
    }
    cout<<endl;
}
#endif

main.cpp

#include <iostream>
#include <vector>
using namespace std;

#include "anak.h"
#include "ibu.h"

int main(){
	ibu *varIbu = new ibu("dini");
	anak *varAnak = new anak("tono");
	anak *varAnak2 = new anak("rini");

	varIbu->tambahAnak(varAnak);
	varIbu->tambahAnak(varAnak2);

    varIbu->cetakAnak();

	delete varIbu;
	delete varAnak;
	delete varAnak2;

	return 0;
}

Pada contoh program di atas, dicontohkan bagaimana relasi object tipe aggregation bekerja. Dimana terdapat 2 object yang berdiri sendiri, yaitu; ibu dan anak.

Hampir mirip seperti association, tapi berbedaanya adalah, bahwa tidak semua object pada relasi tipe aggregation dapat memiliki banyak relasi ke object lainya, di atas dicontohkan bahwa hanya object ibu saja yang dapat memiliki banyak relasi ke object anak, tapi anak tidak bisa memiliki banyak relasi ke banyak object ibu.

Jangka kehidupan masing-masing object di atas memiliki sifat independen, kematian atau penghapusan salah satu dari object tidak akan mempengaruhi object lainya pada relasi tersebut.