Setelah mempelajari Pengertian Constructor dan Destructor dalam OOP PHP, kali ini kita akan membahas Pengertian Inheritance atau Pewarisan dalam Pemrograman Objek, serta melihat contoh penggunaannya.
Pengertian Inheritance (Pewarisan) dalam OOP
Inheritance adalah konsep OOP dimana sebuah class dapat menurunkan property dan method yang dimilikinya kepada class lain. Konsep inheritance dipakai untuk memanfaatkan fitur code reuse, yakni menghindari terjadinya duplikasi kode program.
Dalam bahasa Indonesia, inheritance ini disebut juga sebagai pewarisan atau penurunan.
Konsep inheritance membuat sebuah struktur atau hierarchy class dalam kode program. Class yang akan diturunkan bisa disebut sebagai class induk (parent class), super class, atau base class.
Sedangkan class yang menerima penurunan bisa disebut sebagai class anak (child class), sub class, derived class atau heir class.
Tidak semua property dan method class induk akan diturunkan. Property dan method dengan hak akses private tidak akan diturunkan kepada class anak. Hanya property dan method dengan hak akses protected dan public saja yang bisa diakses dari class anak.
Cara Penggunaan Inheritance dalam PHP
Di dalam PHP, inheritance atau penurunan sebuah class kepada class lain menggunakan keyword extends, dengan penulisan dasar sebagai berikut:
class induk { //...isi class induk } class anak extends induk { //... class anak bisa mengakses //... property dan method class induk }Agar lebih mudah dipahami, kita akan langsung masuk ke dalam contoh program penggunaan inheritance PHP:
<?php // buat class induk: komputer class komputer { public $merk; public $processor; public $memory; public function beli_komputer() { return "Beli komputer baru"; } } // turunkan class komputer ke laptop class laptop extends komputer { public function lihat_spec() { return "merk: $this->merk, processor: $this->processor, memory: $this->memory"; } } // buat objek dari class laptop (instansiasi) $laptop_baru = new laptop(); // isi property objek $laptop_baru->merk = "acer"; $laptop_baru->processor ="intel core i5"; $laptop_baru->memory = "2 GB"; //panggil method objek echo $laptop_baru->beli_komputer(); echo "<br />"; echo $laptop_baru->lihat_spec(); ?>Dalam contoh kode ini terdapat class komputer dengan beberapa property dan sebuah method. Semua property milik class komputer masih belum berisi nilai apa-apa.
Di bawah class komputer, saya membuat class laptop extends class komputer. Disini terjadi penurunan class komputer kepada class laptop. Hasilnya, di dalam class laptop kita bisa mengakses seluruh property dan method apapun milik class komputer selama memiliki hak akses public atau protected.
Untuk membuktikan hal tersebut, saya membuat objek $laptop_baru dari class laptop. Perhatikan bahwa kita bisa mengakses property $merk, $processor, dan$memory yang semuanya adalah milik class komputer, bukan class laptop.
Method beli_komputer() juga sukses diakses dari objek $laptop baru. Inilah yang dimaksud dengan inheritance/penurunan class dalam OOP.
PHP tidak membatasi berapa banyak penurunan objek yang bisa dilakukan. Dalam contoh berikut saya membuat 3 buah class yang saling diturunkan:
<?php // buat class komputer class komputer { protected function beli_komputer() { return "Beli komputer baru"; } } // turunkan class komputer ke laptop class laptop extends komputer { protected function beli_laptop() { return "Beli laptop baru"; } } // turunkan class laptop ke chromebook class chromebook extends laptop { protected function beli_chromebook() { return "Beli chromebook baru"; } public function beli_semua(){ $a = $this->beli_komputer(); $b = $this->beli_laptop(); $c = $this->beli_chromebook(); return "$a <br /> $b <br /> $c"; } } // buat objek dari class laptop (instansiasi) $gadget_baru = new chromebook(); //panggil method objek echo $gadget_baru->beli_semua(); // $gadget_baru->beli_komputer(); // Fatal error: Call to protected method komputer::beli_komputer() ?>Di awal kode program saya membuat class komputer yang diturunkan kepada class laptop. Class laptop ini kemudian diturunkan lagi kepada class chromebook. Dari dalam class chromebook ini di panggil method-model milik class diatasnya.
Jika anda perhatikan, setiap method selain method beli_semua(), juga menggunakan hak akses protected. Hak akses protected ini menghalangi kode program lain untuk mengaksesnya, selain class turunan.
Pada baris terakhir saya menyisipkan kode program untuk mencoba mengakses method beli_komputer(). Kode ini sengaja diberi tanda komentar karena PHP akan mengeluarkan error karena kita tidak bisa mengakses method dengan hak akses protected:
<? $gadget_baru->beli_komputer(); // Fatal error: Call to protected method komputer::beli_komputer() ?>Inilah salah satu penerapan enkapsulasi dalam OOP PHP. Yakni membatasi method yang tidak boleh diakses akan membuat kode program menjadi lebih terstruktur.
Dalam tutorial belajar OOP PHP kali ini, kita telah pelajari konsep inheritance atau pewarisan dalam pemrograman objek.
Penurunan class memiliki permasalahan tersendiri ketika terdapat property atau method dengan nama yang sama di parent class dan child class. Mengenai hal ini akan kita bahas dalam tutorial belajar OOP PHP berikutnya: Cara Mengakses Property dan Method Parent Class.
Duniailkom telah menerbitkan buku yang secara detail membahas pemrograman object PHP. Mulai dari materi dasar OOP seperti class, object, property, hingga trait, namespace, autoloading dan exception. Di akhir buku juga terdapat studi kasus pembuatan library dan aplikasi CRUD. Penjelasan lebih lanjut bisa ke eBook OOP PHP Uncover Duniailkom.
Komposisi merupakan relasi antar kelas yang lebih ketat dibanding agregasi (lihat pos yang lalu), sedikit berbeda dibanding inheritance yang bersifat generalisasi/spesialisasi. Masih dengan kasus yang sama berikut ini.
Diagram kelas Unified Modeling Language (UML) di atas memperlihatkan relasi antara kelas Dosen dan Mahasiswa “Membimbing”. Teknik di atas sering muncul di buku karangan Alan Denis (System Analysis & Design – an OO Approach with UML).
Karakteristik agregasi antara dua kelas adalah independen. Jika dihapus satu objek yang berelasi, objek lain masih ada, sementara komposisi tidak. Ada istilah Wadah (Container) dan Isi (Contain). Jika wadah dihapus maka isi ikut terhapus juga. Misalnya komputer yang memiliki komponen prosesor, ram, mainboard, dan lain-lain dihapus, maka komponen otomatis ikut terhapus.
Secara kode mirip dengan agregasi, hanya saja isi, dalam hal ini isi, misalnya dosen pembimbing, dibangkitkan dalam objek yang berperan sebagai wadah, misal mahasiswa.
Pada agregasi, objek mahasiswa y (si Wahyu) memiliki dosen pembimbing x (Rahmadya). Jika objek y dihapus (ketik saja “del y” di colab) x masih ada. Nah, untuk komposisi dosen pembimbing y (Ujang) diletakan di dalam y sebagai wadah. Jika y dihapus/delete dosen pembimbing pun terhapus, berbeda dengan agregasi yang masih ada x tersisa. Berikut secara UML bagaimana notasi agregasi dan komposisi.
Namun dalam implementasinya antara agregasi dan komposisi hanya garis saja seperti dalam buku Alan Dennis et al, kecuali jika ingin merinci diagram kelasnya. Untuk inheritance harus dicantumkan dalam diagram simbolnya, karena atribut dan metode ada di kelas induk. Jika tidak diberi simbol panah khawatir pembaca akan bingung kemana atribut dan metode lainnya yang berada di kelas induk. Untuk lebih jelasnya silahkan lihat video Youtube berikut ini.
Relasi antar kelas pada Pemrograman Berorientasi Objek (PBO) dikenal dengan nama Asosiasi, yang terdiri dari agregasi dan komposisi, selain dari pewarisan/inheritance yang merupakan ciri khas PBO. Postingan kali ini akan membahas agregasi, merupakan relasi/asosiasi yang dikenal dengan istilah “Is – a”. Perhatikan diagram kelas berikut ini:
Di sini kita akan mengintegrasikan konsep pewarisan (kelas Unisma memiliki anak Dosen, Mahasiswa, dan Satpam) dan agregasi (mahasiswa memiliki dosen pembimbing dari kelas Dosen). Atribut mahasiswa di sini antara lain:
Atribut nama, status, dan jurusan berasal dari kelas induk (Unisma) sementara NPM dan Pembimbing dari kelas Mahasiswa (kelas anak). Agregasi digambarkan dengan garis, terkadang ada panah disertai penjelasan relasi tersebut, misalnya “membimbing”. Berikut kelas Unisma.
class Unisma(object):
def __init__(self,nama,status,jurusan):
self.nama=nama
self.status=status
self.jurusan=jurusan
def Salam(self):
print(‘Selamat Hari Raya Idul Fitri 1442H’)
def Info(self):
print(“INFO”)
print(“Nama : “ + self.nama)
print(“Jurusan : “ + self.jurusan)
Berikut ini kode kelas Dosen. Perhatikan kata kunci “super” yang berarti dosen merupakan pewarisan dari kelas Unisma. Jadi Dosen mewarisi atribut-atribut nama, status, dan jurusan, berikut juga metode/operasi Salam() dan Info().
class Dosen(Unisma):
def __init__(self,nama,status,jurusan,nip):
super().__init__(nama,status,jurusan)
self.nip=nip
def SalamDosen(self):
print(‘Kami {} {} mengucapkan’.format(
self.status,self.jurusan))
self.Salam()
Berikut ini kode kelas Mahasiswa dengan tambahan satu atribut “pembimbing” yang nantinya akan direlasikan dengan objek Dosen selaku pembimbing.
class Mahasiswa(Unisma):
def __init__(self,nama,status,jurusan,npm,pembimbing):
super().__init__(nama,status,jurusan)
self.npm=npm
self.pembimbing=pembimbing
def SalamSiswa(self):
print(‘Hai teman-teman, kami {} {} mengucapkan’.format(
self.status,self.jurusan))
self.Salam()
def GetInfo(self):
print(“Pembimbing : “ + self.pembimbing.nama)
Jalankan dengan kode-kode berikut untuk mengeceknya.
x=Dosen(“Rahmadya”,“Dosen”,“Teknik Komputer”,123)
y=Mahasiswa(“Wahyu”,“Mahasiswa”,“Teknik Mesin”,1111123
Untuk lebih jelasnya silahkan lihat video penjelasannya berikut ini. Sekian, semoga bermanfaat.
Public, Private, dan Protected dikenal dengan nama Visibility. Istilah ini telah lama dikenal oleh bahasa pemrograman C++ dan Java. Python, merupakan bahasa baru secara default mendefinisikan suatu atribut atau metode bersifat public. Diagram kelas UML mendefinisikan public dan private dalam bentuk simbol positif dan negatif.
Untuk membuat private dengan menggunakan simbol garis bawah dimana untuk protected satu garis bawah (“_”) dan untuk private dua garis bawah (“__”).
Berikut contoh kelas Unisma sebagai induk dan kelas Dosen dan Mahasiswa sebagai anak yang diambil dari materi sebelumnya tentang inheritance/pewarisan. Silahkan gunakan editor Python, misalnya Google Colab untuk menjalankan kode berikut.
class Unisma(object):
def __init__(self,nama,status,jurusan):
self.__nama=nama
self.__status=status
self.__jurusan=jurusan
def Salam(self):
print(‘Selamat Hari Raya Idul Fitri 1442H’)
def Info(self):
print(“INFO”)
print(“Nama : “ + self._Unisma__nama)
print(“Jurusan : “ + self._Unisma__jurusan)
Berikutnya untuk kelas Mahasiswa:
class Mahasiswa(Unisma):
def __init__(self,nama,status,jurusan,npm):
super().__init__(nama,status,jurusan)
self.__npm=npm
def SalamSiswa(self):
print(‘Hai teman-teman, kami {} {} mengucapkan’.format(
self._Unisma__status,self._Unisma__jurusan))
self.Salam()
Berikutnya coba jalankan dengan instruksi pengaksesan kelas-kelas di atas.
y=Mahasiswa(“Wahyu”,“Mahasiswa”,“Teknik Mesin”,123
Berikut video youtube untuk lebih jelasnya.
Salah satu konsep terkenal pada pemrograman berorientasi objek adalah inheritance/pewarisan. Istilah ini identik dengan generalisasi dan spesialisasi dimana seorang induk akan mewariskan sifat-sifat ke seorang anak yang general dan seorang anak memiliki sifat khusus yang spesifik. Gambar di bawah ini contoh diagram UML dalam menggambarkan relasi generalisasi yang menggambarkan konsep pewarisan.
Kotak menggambarkan kelas dengan tiga kompartemen/ruang yaitu nama, atribut dan metode/operasi. Kelas Unisma di atas merupakan kelas induk yang akan mewariskan tiga buah atribut (nama, status, dan jurusan) dan dua buah operasi/metode (salam dan Info). Di sini simbol minus berarti private (tidak bisa diakses dari luar kelas) dan plus berarti publik (bisa diakses di luar kelas). Silahkan lihat slide berikut.
Kelas Dosen dan Mahasiswa berturut-turut memiliki atribut unik NIP dan NPM, juga metode SalamDosen() dan SalamSiswa(). Perhatikan jangan lupa menulis “()” setelah nama metode/operasi, yang merupakan standar/konvensi internasional. Silahkan buat satu sel yang berisi kelas Unisma yang merupakan kelas Induk.
//colab.research.google.com/drive/1T19eiVktOrMQzXqZLD3jV4I0fbbQZ6oA?usp=sharing
Kode di atas juga mengilustrasikan pembuatan dua kelas anak yaitu kelas Dosen dan kelas Mahasiswa. Di sini kita menggunakan IDE Google Colab yang dapat diakses tanpa perlu instalasi karena hanya menggunakan browser dengan network ke internet.
Perlu diperhatikan bahwa pemrograman berorientasi objek memiliki konsep Konstruktor dalam tiap pembuatan kelas. Karena tiap kelas harus mampu menciptakan satu objek. Tanpa konstruktor maka kelas tersebut tidak bisa membentuk objek. Istilahnya adalah kelas abstrak, terkadang diperlukan juga kelas jenis ini pada penerapannya. Silahkan lihat video berikut, semoga bermanfaat.
Tiap kampus ternyata berbeda-beda awal perkuliahannya, termasuk kampus tempat saya mengajar yang baru mulai pertemuan pertama semester genap. COVID-19 memang membuat beberapa agenda perkuliahan berubah. Faktor perkuliahan online dan kesiapan kampuslah yang membuah pergeseran dan perubahan sistem, dari yang tatap muka menjadi online. Terutama kesiapan dalam menangani praktikum.
Untuk bidang komputer, khususnya materi pemrograman dapat dilakukan praktik secara online. Problem utama hanyalah di sisi mahasiswa yang terpaksa memindahkan komputer lab ke dalam laptop sendiri, sekaligus sarana network berupa pulsa/paket internet. Nah, untuk mahasiswa yang pas-pasan, tentu saja agak kesulitan ketika memiliki laptop dengan spesifikasi minim. Oleh karena itu perlu difikirkan bagaimana menyiapkan sarana yang murah-meriah.
Java
Java dan C++ sudah sejak lama menjadi sarana belajar pemrograman berorientasi objek. Silahkan lihat postingan saya tentang DB4O untuk basis data objek. Sebelumnya, bahasa ini menjadi andalah saya untuk praktik pemrograman berorientasi objek, tetap kondisi online sangat menyulitkan mahasiswa, sehingga perlu sarana murah-meriah lainnya.
Python
Bahasa yang paling banyak diminati saat ini adalah Python. Banyak paket yang tersedia dari Python berbasis konsol hingga paket Anaconda yang gratis diunduh. Hanya saja paket ini membutuhkan sumber daya yang besar untuk mengaktifkan fasilitas-fasilitas seperti Jupyter Notebook atau Spyder.
Untungnya Google menyediakan sarana programming hanya dengan browser dan mempersilahkan orang menggunakan servernya, termasuk Graphic Processing Unit (GPU) yang cukup ampuh dalam menangani Deep Learning. Bagaimana untuk pemrograman berorientasi objek?
Saat ini Python memiliki pesaing kuat, suatu bahasa pemrograman secepat C++, sedinamis Ruby, dan semudah Python, yaitu Julia. Namun bahasa ini tidak ditujukan untuk pemrograman berorientasi objek, berbede dengan Python yang dari awal memang untuk objek.
Mencoba Pemrograman Objek Sederhana
Baik untuk praktik awal, silahkan buka Google Colab Anda (lihat tata cara di post yang lalu). Copy paste saja kode berikut ini sebagai ilustrasi bagaimana sebuah kelas dengan method yang tersedia.
import math class Point: 'Represents a point in two-dimensional geometric coordinates' def __init__(self, x=0, y=0): '''Initialize the position of a new point. The x and y coordinates can be specified. If they are not, the point defaults to the origin.''' self.move(x, y) def move(self, x, y): "Move the point to a new location in two-dimensional space." self.x = x self.y = y def reset(self): 'Reset the point back to the geometric origin: 0, 0' self.move(0, 0) def calculate_distance(self, other_point): """Calculate the distance from this point to a second point passed as a parameter. This function uses the Pythagorean Theorem to calculate the distance between the two points. The distance is returned as a float.""" return math.sqrt((self.x - other_point.x)**2 + (self.y - other_point.y)**2)Kelas di atas tidak menghasilkan output karena belum dihidupkan objeknya. Berikut cara mencoba method yang direpresentasikan dalam keyword “def” di atas.
point=Point(3,5) print("point awal = ",point.x, point.y) point2=Point(5,5) jarak=point.calculate_distance(point2) print("jarak dari point awal =",jarak)Pastikan hasilnya tampak seperti di bawah ini, selamat mencoba.
Ketika tidak mengajar, hal paling mengasyikan bagi dosen adalah pelatihan, terutama dari program studi diploma dan vokasi. Program studi jenis ini mengharuskan dosen memiliki ketrampilan yang bisa dibagikan kepada mahasiswa walaupun tentu saja tidak mungkin seorang dosen menguasai seluruh bidang yang ada, salah satunya adalah pemrograman mobile berbasis Android.
Cara paling praktis adalah saling berbagi ilmu oleh dosen-dosen yang ada. Beberapa hari yang lalu diadakan pelatihan mobile programming dengan Android Studio. Bahasa yang digunakan adalah Java disertai dengan Web Service berbasis CodeIgniter. Web service ini berfungsi menghubungkan aplikasi Android dengan sistem basis data, misalnya MySQL.
Ternyata banyak elemen-elemen yang perlu dikuasai untuk membuat aplikasi untuk handphone itu. Dari pembuatan layout, Grader Script, hingga pembuatan menu-menu lanjut seperti masukan berupa tanggal, combo, hingga upload image ke server. Bahkan instalasi software Android Studio pun butuh waktu. Tips dan Trik banyak diberikan terutama untuk mempercepat proses pembuatan aplikasi, misalnya penggunaan Genymotion yang menggantikan emulator bawaan Android Studio yang berat.
Sangat perlu untuk mengetahui teknik-teknik pembuatan praktis dan bagaimana beberapa paket dimanfaatkan yang berhubungan dengan user interface dan koneksi ke DBMS, misalnya dengan library volley. Rencananya akan dilanjutkan dengan pelatihan-pelatihan sesuai dengan peminatan seperti android yang menggunakan artificial intelligence, networking, hingga sistem informasi management (SIM). Dari semua itu, yang terpenting adalah kebersamaan antar dosen terutama dalam mengikuti visi misi tujuan dan sasaran (VMTS) prodi teknik komputer yang fokus salah satunya ke pemrograman berbasis network dan artificial intelligence pada perangkat embedded, yang kali ini diwakili oleh aplikasi mobile/gadget.
Pemrograman berorientasi objek (PBO) saat ini lebih diminati dari pemrograman terstruktur. Hal ini karena PBO ternyata lebih terstruktur dengan pola yang terdiri dari atribut dan metode (operasi). Untuk penggunaan fungsi eksternal pada jenis pemrograman terstruktur sudah dibahas pada post terdahulu. Agar lebih jelas ada baiknya kita menggunakan contoh kasus yang sama, yaitu pembelian barang.
Membuat Kelas
Kelas dapat dibuat dalam satu file yang sama atau terpisah. Di sini kita coba menggunakan file terpisah, misalnya bernama “hitung.py”. File ini berisi tiga buah method dengan fungsi seperti kasus yang lalu: total, diskon dan bayar. Berikut kelas “struk” yang dibuat dengan kata kunci “class”. Perhatikan indent (menjorok) baik setelah “class” maupun “def”.
class struk: def total(harga,jumlah): """fungsi untuk menghitung Total bayar""" return harga*jumlah def diskon(harga): """ fungsi menghitung diskon """ if (harga >= 500000): potongan=harga*0.1 else: potongan=harga*0.05 return potongan def bayar(harga,potongan): """ fungsi menghitung total bayar """ return harga-potonganMemanggil Kelas
Kelas dipanggil dengan kata kunci “import”. Perhatikan pada listing di bawah cara memanggil fungsi/metode yang dimiliki oleh kelas, dalam hal ini kelas “struk”. Formatnya adalah <nama_kelas>.<nama_metode>. Di sini kita coba menggunakan Google Colab. Kita bisa juga menggunakan Jupyter Notebook atau versi terdahulu dengan IDLE.
from hitung import struk print(" ———Toko Amanah Jaya———") #input data harga= int(input("masukan harga barang: ")) jumlah= int(input("masukan jumlah baju yang dibeli: ")) Total=struk.total(harga,jumlah) potongan=struk.diskon(Total) tagihan=struk.bayar(Total,potongan) print("Total Harga = ", "Rp.",Total) print("Diskon", "Rp.", potongan) Bayar=int(input("Jumlah Nominal Uang =" )) Kembalian= (Bayar-tagihan) print("Uang Kembalian = ", "Rp.",Kembalian)Berikut hasil “running” ketika transaksi barang dengan harga Rp. 100.000,- sebanyak 4 buah. Karena di bawah Rp. 500.000,- maka diskonnya 5 %. Sekian semoga bermanfaat.
Particle Swarm Optimization (PSO) has been widely used for solving optimization problems. This method has many advantages, in particular for the computational complexity. PSO mimics the flock of bird or the school of fish when searching for foods. It faster than genetic algorithms (GAs), so become the first choice when optimizing the complex problems, such as multi-objective optimization, optimization with many constraints, etc. Following is the particle velocity calculation and its new location.
Many source codes can be found in the internet, for example this panda site. This beautiful code use object-oriented style with some classes. Some functions inside a class are easy to understand. This code can be copied and pasted in your jupyter notebook. As usual, use the Anaconda Navigator to choose the right environment. This code only uses a simple library: math, and matplotlib.
Choose your working directory to open the Jupyter Notebook by typing “juypyter notebook”. The Jupyter notebook then suddenly appear in your browser. Copy and paste the code to run the sample of PSO. This sample use two variables (X0 and X1). Use mm=-1 for minimizing problem and mm=1 for maximizing problem. A main class run two previous classes (Particle and PSO) to show the optimum result with a performance chart.
Here is the code:
import random import math import matplotlib.pyplot as plt #------------------------------------------------------------------------------ # TO CUSTOMIZE THIS PSO CODE TO SOLVE UNCONSTRAINED OPTIMIZATION PROBLEMS, CHANGE THE PARAMETERS IN THIS SECTION ONLY: # THE FOLLOWING PARAMETERS MUST BE CHANGED. def objective_function(x): y = 3*(1-x[0])**2*math.exp(-x[0]**2 - (x[1]+1)**2) - 10*(x[0]/5 - x[0]**3 - x[1]**5)*math.exp(-x[0]**2 - x[1]**2) -1/3*math.exp(-(x[0]+1)**2 - x[1]**2); return y bounds=[(-3,3),(-3,3)] # upper and lower bounds of variables nv = 2 # number of variables mm = -1 # if minimization problem, mm = -1; if maximization problem, mm = 1 # THE FOLLOWING PARAMETERS ARE OPTIMAL. particle_size=100 # number of particles iterations=200 # max number of iterations w=0.85 # inertia constant c1=1 # cognative constant c2=2 # social constant # END OF THE CUSTOMIZATION SECTION #------------------------------------------------------------------------------ class Particle: def __init__(self,bounds): self.particle_position=[] # particle position self.particle_velocity=[] # particle velocity self.local_best_particle_position=[] # best position of the particle self.fitness_local_best_particle_position= initial_fitness # initial objective function value of the best particle position self.fitness_particle_position=initial_fitness # objective function value of the particle position for i in range(nv): self.particle_position.append(random.uniform(bounds[i][0],bounds[i][1])) # generate random initial position self.particle_velocity.append(random.uniform(-1,1)) # generate random initial velocity def evaluate(self,objective_function): self.fitness_particle_position=objective_function(self.particle_position) if mm == -1: if self.fitness_particle_position < self.fitness_local_best_particle_position: self.local_best_particle_position=self.particle_position # update the local best self.fitness_local_best_particle_position=self.fitness_particle_position # update the fitness of the local best if mm == 1: if self.fitness_particle_position > self.fitness_local_best_particle_position: self.local_best_particle_position=self.particle_position # update the local best self.fitness_local_best_particle_position=self.fitness_particle_position # update the fitness of the local best def update_velocity(self,global_best_particle_position): for i in range(nv): r1=random.random() r2=random.random() cognitive_velocity = c1*r1*(self.local_best_particle_position[i] - self.particle_position[i]) social_velocity = c2*r2*(global_best_particle_position[i] - self.particle_position[i]) self.particle_velocity[i] = w*self.particle_velocity[i]+ cognitive_velocity + social_velocity def update_position(self,bounds): for i in range(nv): self.particle_position[i]=self.particle_position[i]+self.particle_velocity[i] # check and repair to satisfy the upper bounds if self.particle_position[i]>bounds[i][1]: self.particle_position[i]=bounds[i][1] # check and repair to satisfy the lower bounds if self.particle_position[i] < bounds[i][0]: self.particle_position[i]=bounds[i][0] class PSO(): def __init__(self,objective_function,bounds,particle_size,iterations): fitness_global_best_particle_position=initial_fitness global_best_particle_position=[] swarm_particle=[] for i in range(particle_size): swarm_particle.append(Particle(bounds)) A=[] for i in range(iterations): for j in range(particle_size): swarm_particle[j].evaluate(objective_function) if mm ==-1: if swarm_particle[j].fitness_particle_position < fitness_global_best_particle_position: global_best_particle_position = list(swarm_particle[j].particle_position) fitness_global_best_particle_position = float(swarm_particle[j].fitness_particle_position) if mm ==1: if swarm_particle[j].fitness_particle_position > fitness_global_best_particle_position: global_best_particle_position = list(swarm_particle[j].particle_position) fitness_global_best_particle_position = float(swarm_particle[j].fitness_particle_position) for j in range(particle_size): swarm_particle[j].update_velocity(global_best_particle_position) swarm_particle[j].update_position(bounds) A.append(fitness_global_best_particle_position) # record the best fitness print('Optimal solution:', global_best_particle_position) print('Objective function value:', fitness_global_best_particle_position) print('Evolutionary process of the objective function value:') plt.plot(A) #------------------------------------------------------------------------------ if mm == -1: initial_fitness = float("inf") # for minimization problem if mm == 1: initial_fitness = -float("inf") # for maximization problem #------------------------------------------------------------------------------ # Main PSO PSO(objective_function,bounds,particle_size,iterations)
Aktivity diagram merupakan salah satu diagram Unified Modeling Language (UML). Diagram ini menjelaskan lebih rinci diagram use-case dalam bentuk alur aktivitas. Selain itu, diagram ini menyediakan pula sebuah swimlane yaitu alur yang menggambarkan bagian/divisi yang bekerja. Di sini kita coba menggambar diagram activity dengan Microsoft Visio. Berbeda dengan Excel dan Access yang satu paket dengan microsoft office, microsoft visio berbeda paket dan harus membeli lisensi tambahan untuk aplikasi ini. Buka Visio dan kita buat diagram baru.
Pada bagian more shapes pilih software & database – Software – UML Activity. Tampak diagram-diagram yang digunakan oleh diagram activity muncul di bagian kiri visio. Klik, tahan dan pindahan diagram ke lembar kerja visio. Yang pertama-tama adalah Swimlane, yang berupa persegi panjang vertikal.
Untuk menambah aktor tekan dua kali di sisi kanan Swimlane untuk menambah. Di sini untuk aktivitas tertentu terkadang berisi divisi atau bagian dimana sebuah aktivitas berlangsung. Ganti nama Function menjadi nama yang sesuai.
Sedikit tip n trik, ketika membuat satu activity baru, lebih enak dengan copas dari yang ada agar ukurannya tidak perlu diseting lagi. Untuk penentuan posisi, ikut arah garis pemandu agar ketika membuat garis panah akar lurus tepat di “pin” pada activity. Berikutnya sediakan beberapa konektor berupa garis berarah panah.
Secara default, garis konektor tidak memiliki panah. Jadi kita harus menambahkan panah dengan cara mengklik kanan garis konektor dan klik format shape.
Sekarang konektor sudah memiliki panah/arah. Berikutnya tidak perlu melakukan langkah itu lagi karena kita tinggal meng-copy-paste saja konektor yang sudah memiliki panah. Berikutnya buat diagram activity Anda hingga selesai.
Pada diagram activity terdapat juga decision berupa belah ketupat. Di sini pertanyaan tidak berada di dalam belah ketupat, melainkan di luar. Ada baiknya juga tulisan di luar belah ketupat, bentuk belah ketupat jadi tidak terlalu besar. Jika masuk satu keluar dua, disebut decision, sebaliknya disebut merge. Cukup mudah bukan? Selamat mencoba.
Bahasa Java memiliki istilah-istilah rumit terutama ditujukan untuk pemrograman berorientasi objek. Konsep objek dengan prinsip enkapsulasi (information hiding) memerlukan perlakuan khusus dalam membuat programnya. Contoh-contoh kode yang beredar di internet, terutama yang menggunakan basis data relational terkadang tidak menerapkan prinsip enkapsulasi ini. Untuk mempraktekannya ada baiknya dimulai dari yang dasar dulu yaitu konstruktor.
Konstruktor
Sebuah kelas merupakan cetakan (template) suatu objek tertentu. Misal seorang siswa memiliki atribut tertentu seperti kode dan nama serta metode/operasi seperti membaca data, memasukan data siswa baru, menghapus data siswa, dan sejenisnya. Jika sebuah objek baru terbentuk maka data baru harus mengikuti pola kelas Siswa tersebut yang terdiri dari atribut dan metode/operasi.
Pada Netbeans, kelas Siswa dapat dilihat di jendela navigator. Tampak atribut di bawah dan lingkaran yang menyatakan metode. Belah ketupat menyatakan metode yang masuk kategori konstruktor, yang berfungsi membuat satu objek baru.
Konstruktor Siswa(String k, String n) berfungsi membuat satu objek dengan atribut k dan n yang kemudian dikonversi menjadi variabel lokal (this.kodesiswa dan this.nama).
-
public Siswa(String k, String n){
Ketika kelas lain meminta menjalankan satu metode/operasi maka diperlukan objek baru yang dibentuk dari konstruktor. Misalkan menggunakan kelas Main yang biasanya secara default muncul di tiap project.
Getter & Setter
Objek “mhs” baru dibentuk lewat konstruktor Siswa yang menangkap kode “009” dan nama”Dr. Rahmadya Trias H.”. Ditangkap lewat mekanisme setter & getter. Ketika diketik “mhs.” Pastikan muncul operasi-operasi yang tersedia, jika tidak maka konstruktor bermasalah. Misal kita pilih metode “greetings()” yang sebelumnya di kelas Siswa telah diisi, misalnya sbb:
-
System.out.println(“Hai, salam kenal, saya ” +this.nama);
Jika dijalankan akan menjalankan metode “greetings()” dengan parameter yang dikirim “009” dan “Dr. Rahmadya Trias H.” untuk digunakan mengoperasikan tulisan (di sini yang digunakan hanya this.nama saja).
CRUDE singkatan dari Create, Read, Update, dan Execute. CRUD tanpa E biasa digunakan oleh pemrograman terstruktur, sementara Execute ditambahkan untuk Objek oriented yang artinya proses selain CRUD, misalnya membuat tampilan tertentu, perhitungan-perhitungan, validasi, dan lain-lain. CRUDE matrix biasanya dibuat dari Use Case diagram di tahapan analisa.
Berikut ini contoh pembuatan CRUDE matrix. Perhatikan aktor yang terlibat bisa juga berupa kelas, biasanya diberi simbol <<class>>, kadang tidak muncul pada Use Case diagram.
Kandidat aktor: Doctor, Management, New Patient, Old Patient. Aktor “Patient” menwakili New dan Old Patient.
Kandidat kelas:
Baik management dan Doctor mengelola jadwal (Manage Schedule). Ada kelas Jadwal (Schedule). Kelas New Patient butuh kelas Patient. Baik kelas New dan Old Patient mengajukan jadwal (appointment). Kelas Doctor perlu dibuat untuk penjadwalan.
CRUDE Matrix
Berikut CRUD Matrix sementara yang bisa berubah pada fase/tahap berikutnya.
Kelas-kalas: Management, Doctor, Patient, Appointment, Schedule
|
Management |
Doctor |
Patient |
Appointment |
Schedule |
|
|
Management |
C,R,U,D |
C,R,U,D |
R,E |
C,R,U,D |
|
|
Doctor |
C,R,U,D |
||||
|
Patient |
C,U |
||||
|
Appointment |
|||||
|
Schedule |
Pemrograman Berorientasi Objek (PBO) dalam proses perancangan sistemnya tidak berbeda dengan pemrograman terstruktur dan dapat menggunakan metode yang sama. Hanya saja karena ciri khas PBO yang tidak membedakan proses dan data maka ada sedikit sudut pandang yang berbeda dalam perancangannya. Tiga tokoh penggagas Unified Modeling Language (UML) yaitu Grady Booch, Ivar Jacobson, dan James Rumbaugh sepakat dalam perancangan sistem modern harus berbasis: Use Case Driven, fokus ke arsitektur sistem (Architecture-centric), dan iteratif & inkremental.
Use Case Driven
Use Case Driven artinya adalah Use Case sebagai pemodelan utama dalam perancangan sistem. Model Use Case menggambarkan hubungan antara pengguna dengan sistem dalam melakukan aktifitas tertentu seperti pemesanan barang, penyewaan, mencari informasi tertentu, dan lain-lain. Use Case Driven berbeda dengan pemodelan tradisional maupun Rapid Application Development (RAD) yang kompleks. Kompleksitas metode tradisional tersebut karena harus melibatkan baik analis maupun pengguna dimana sistem dipecah menjadi subsistem hingga tidak bisa dipecah lagi dalam analisanya. Diagram menjadi rumit karena saling terkait antara satu diagram dengan diagram lainnya yang jumlahnya banyak. Sementara itu Use Case hanya berfokus pada satu proses bisnis dalam satu waktu dan membuat proses menjadi lebih sederhana.
Fokus ke Arsitektur Sistem
Arsitektur bisa bermacam-macam artinya, tergantung dari sudut pandang tertentu. Dari sudut pandang PBO dengan standar UML-nya arsitektur merupakan aspek keseluruhan dari organisasi sistem. Aspek tersebut melandasi komponen-komponen arsitektur sistem yang terdiri dari fungsionalitas, struktur, dan proses (function, static, & behaviiour). Selain itu arsitektur juga mengatasi permasalahan performa, skalabilitas, reuse, dan batasan-batasan ekonomi dan teknis.
Secara garis besar arsitektur dapat dilihat dari sisi eksternal (pengguna) yaitu berupa fungsi-fungsi. Selain itu dilihat juga dari sisi internal berupa atribut, metode, dan kelas-kelas . Arsitektur juga melibatkan relasi antar objek yang melibatkan pesan-pesan untuk menjalankan fungsi tertentu.
Iteratif dan Inkremental
PBO menerapkan metode pengembangan sistem berupa iterasi dan inkremental. Metode ini mengembangkan tiga sudut pandang arsitektur (fungsi, statis, dan proses) secara berulang. Setelah testing, perancang kembali lagi ke awal untuk penyempurnaan. Dalam merancang, perancang mengembangkan sedikit demi sedikit, dari sistem sederhana menuju sistem yang lebih besar dan kompleks. Tiap iterasi pengembang selalu berhubungan dengan pengguna dalam merancang fungsi-fungsi yang diperlukan. Jadi struktur dan fungsi harus dikuasai oleh pengembang agar diperoleh sistem yang baik. Pengembang juga dapat menambahkan kebutuhan-kebutuhan fungsi yang tidak disadari oleh pengguna.
Untuk mengimplementasikan relasi one-to-many pada pemrograman terstruktur dengan sistem basis data relasional diperlukan sebuah tabel detil karena dalam satu field tidak boleh berisi lebih dari satu item. Namun pada pemrograman berorientasi objek dapat dihandel oleh sebuah kelas dengan format atribut array. Misalnya kelas kursus yang berisi lebih dari satu peserta kursus berikut ini.
Salah satu atribut kursus adalah peserta yang merupakan sebuah objek dari kelas siswa. Simbol kurung “[]” menandakan bahwa kelas Kursus bisa memiliki lebih dari satu objek peserta kursus, yang dalam ERD sistem relasional dikenal dengan relasi one-to-many. Bagaimana dalam implementasinya di Netbeans?
Memakai Atribut dari Kelas Lain
Pada kelas kursus terdapat atribut “peserta” yang berasal dari kelas Siswa. Karena menggunakan atribut maka terdapat relasi memiliki dari kelas Kursus terhadap kelas Siswa, diistilahkan dengan relasi “has-a”. Bandingkan dengan relasi antara kelas Main dengan Kursus yang berupa penggunaan saja (mengatur/maintain kursus), diistilahkan dengan relasi “is-a”. Berikut potongan kode dalam bahasa Java untuk kelas yang menggunakan objek dari kelas Siswa (peserta).
public class Kelas {private String kode,jadwal; private Siswa[] peserta; private int i; //konstruktorpublic Kelas(){ this.peserta=new Siswa[5]; }public Kelas(String kode, String jadwal, Siswa[] peserta){ this.kode=kode; this.jadwal=jadwal; this.peserta=peserta; }
…
Perhatikan variabel peserta diambil dari kelas Siswa (private Siswa[] peserta). Selanjutnya ditambah dengan setter & getter serta operasi-operasi lainnya. Pada konstruktor kelas misalnya dibatasi lima peserta kurus saja (this.peserta=new Siswa[5];). Operasi penting untuk menangkap data objek Kelas adalah sebagai berikut.
public void add(Siswa s){ if(i<peserta.length){ peserta[i]=s; System.out.println(“Siswa add at index “+i); i++; } System.out.println(“Peserta: “+peserta); } public void add3(String jadwal){ this.jadwal=jadwal; } public void add2(String kode){ this.kode=kode;
Peserta kursus memanfaatkan variabel I untuk menambah beberapa kali (dalam hal ini max 5). Operasi lainnya juga disertakan untuk menambahkan kode kelas dan jadwalnya. Jika dilihat di navigation pada Netbeans tampak seperti berikut ini.
Dua operasi CRUD (insertData dan readData) misalnya dimasukan. Sebaiknya seluruh CRUD dimasukan juga (update dan delete). Variabel I: int digunakan untuk memasukan peserta kursus yang lebih dari satu.
Kelas Siswa seperti biasa dibuat dengan atribut dan operasi tertentu. Buat CRUD yang lengkap seperti contoh berikut. Untuk akses ke basis data objek dengan operasi CRUD silahkan lihat pos yang lalu.
Kelas ini hanya contoh interface untuk mendaftarkan kelas beserta pesertanya. Dalam implementasi biasanya menggunakan form/frame.
ObjectContainer db = Db4oEmbedded.openFile(“C:/Users/Herlawati/Documents/NetBeansProjects/com.kursus/kursus.yap”); Kelas kel = new Kelas(); //siswa pertama Siswa sis = new Siswa(); sis.setKodesiswa(“03”); ObjectSet<Object> result = db.queryByExample(sis); Siswa m1 = (Siswa) result.next(); System.out.println(“ketemu siswa nama: “+m1.getNama()+” kode “+m1.getKodesiswa()); System.out.println(m1); kel.add(m1); //siswa kedua Siswa sis2 = new Siswa(); sis2.setKodesiswa(“04”); ObjectSet<Object> result2 = db.queryByExample(sis2); Siswa m2 = (Siswa) result2.next(); System.out.println(“ketemu siswa nama: “+m2.getNama()+” kode “+m2.getKodesiswa()); System.out.println(m2); kel.add(m2); //input atribut Kelas kel.add3(“senin dan selasa”); kel.add2(“kode3”); db.close(); kel.insertData();
Ada satu Kelas dengan dua peserta ditambahkan dengan kode di atas, pastikan ketika dieksekusi akan menghasilkan jawaban yang mengindikasikan data tersimpan.
Siswa dengan kode 03 dan 04 dicari terlebih dahulu dari kelas Siswa. Tentu saja sudah dimasukan terlebih dahulu beberapa objek Siswa. Fungsi Add akan memasukan siswa secara multivalue ke objek Kelas. Setelah atribut kelas (jadwal dan kode kelas) ditambahkan (operasi add2 dan add3) maka operasi insertData akan memasukan objek Kelas yang baru saja didaftarkan secara permanen ke sistem basis data objek. Butuh penjelasan yang detil, tetapi secara garis besar langkah-langkah di atas bermaksud menjelaskan prinsip kerja objek, baik instan (temporer) maupun persistence (permanen). Semoga bermanfaat.
Mirip dengan tabel master dan tabel transaksi pada basis data relasional, pada pemrograman berorientasi objek membutuhkan juga tabel transaksi yang melibatkan lebih dari dua tabel. Sebagai contoh adalah mahasiswa yang mendaftarkan kelas yang diikutinya lewat kelas registrasi. Di sini kelas registrasi memerlukan kelas Mahasiswa dan kelas Kelas yang diikuti. Berikut kode untuk membuat kelas Kelas.
public class Kelas {String kodemk; String namamk; int sks; public Kelas(String kodemk, String namamk, int sks){ this.kodemk=kodemk; this.namamk=namamk; this.sks=sks; }public void display(){ System.out.println(“Kode MK: “+kodemk+”| Nama MK: “+namamk+” | Jlh SKS: “+sks+”SKS”);}
}
Seperti biasa tiap kelas memiliki nama, atribut dan operasi. Karena hanya sebagai latihan, pada kelas ini tidak dimasukan kelas untuk operasi create, read, update and delete (CRUD). Hanya operasi display yang disertakan untuk memunculkan atribut-atribut kelas Kelas antara lain: kodemk, namamk, dan sks yang berturut-turut bertipe string, string, dan integer.
Dengan cara yang sama kita bisa membuat kelas Mahasiswa dengan atribut: nama, usia, dan jurusan. Tentu saja hanya sekedar contoh, karena biasany membutuhkan juga nomor pokok mahasiswa (NPM), alamat, ipk, dan lain-lain. Lanjut saja ke bagian penting, yaitu kelas Registrasi yang berfungsi mengakomodir Mahasiswa yang medaftarkan kelas mata kuliah tertentu. Berikut kode pada kelas Registrasi yang dibuat cepat dengan IDE Netbeans 8.
public class Registrasi { private String noreg; Mahasiswa m; Kelas kls; public Registrasi(String noreg, Mahasiswa m, Kelas kls){ this.noreg=noreg; this.m=m; this.kls=kls; } public void display(){ System.out.println(“No Reg: “+noreg); kls.display(); m.display(); } public void insertData() { System.out.println(“* Insert data…”); ObjectContainer db; db = Db4oEmbedded.openFile(“<folder>/mahasiswadb.yap”); try { Registrasi reg = new Registrasi(noreg,m,kls); db.store(reg); System.out.println(“Stored “+reg); } finally { db.close(); } }
}
Kelas Registrasi ini memiliki atribut: noreg, m, dan kls yang merepresentasikan berturut-turut nomor registrasi, mahasiswa dan kelas. Ada operasi display() yang berisi display dari kelas yang terlibat (Mahasiswa dan Kelas). Satu kelas penting lainnya adalah insertData() yang menyimpan data objek registrasi ke basis data agar tersimpan secara permanen (persistence). Terakhir di kelas Main masukan kode contoh berikut.
public class Main { /** * @param args the command line arguments */ public static void main(String[] args) { Mahasiswa m = new Mahasiswa(“Rahmadya”,43,”Teknik Komputer”); Kelas kls = new Kelas(“FIS-1″,”Fisika”,3); Registrasi reg = new Registrasi(“01/mei/2019”,m,kls); reg.display(); reg.insertData(); }
}
Pertama-tama objek mahasiswa dibentuk dengan atributnya lengkap. Demikian pula objek Kelas yang berisi kode kelas, nama kelas dan jumlah SKS. Terakhir objek registrasi yang berisi nomor registrasi beserta objek yang terlibat (diberi nama variabel m dan kls) dibentuk. Objek registrasi selain ditampilkan lewat operasi display() juga disimpan ke basis data lewat operasi insertData(). Jika dijalankan dengan menekan tombol segitiga hijau akan menghasilkan output di bawah ini.
Coba buka file basis data objek “mahasiswadb.yap” dengan notepad dan pastikan terisi objek yang baru saja disimpan lewat instruksi db.store(reg) di atas.
Postingan ini menggunakan Netbeans dengan Object Database Management System (ODBMS) DB4O yang masih jarang digunakan. Biasanya pengembang menggunakan kelas dan objek yang disimpan dalam Relational Database Management System (RDBMS). Silahkan searching ebook tentang DB4O yang banyak beredar di internet. Untuk buku sejenis yang berbahasa Indonesia saya masih mencoba menulis, semoga segera selesai
Problem Create, Read, Update, dan Delete (CRUD) pada PBO dikenal dengan istilah impedance mismatch. Hal ini terjadi karena pemrograman terstruktur dengan karakternya yang menggunakan database relasional menggunakan prinsip pemisahan antara data dengan program. Sementara itu PBO dalam satu kelas memadukan data dan program. Dalam hal ini data berupa atribut, sementara programnya berupa method/operasi. Kontroversi kerap terjadi, biasanya untuk programmer-programmer yang biasanya menangani program-program nonobjek, yang menganjurkan CRUD terpisah dari kelas-nya (lihat di sini). Terutama yang sering menggunakan framework maupun bertipe service oriented architecture (SOA), cenderung memasukan CRUD ke layer service. Atau programmer yang menerapkan Object Relational Database Management System (ORDBMS).
Gambar berikut dikutip dari sumber materi PBO link ini. Tampak pada kelas Customer, kelas ini memiliki operasi bernama +add(name,phone) yang bertugas memasukan pelanggan baru. Operasi yang berada dalam sebuah kelas sebenarnya memperkuat konsep PBO yaitu encapsulation dimana kelas lain tidak bisa mengutak-atik kelas tertentu. Untuk menambah pelanggan, dalam kelas Customer harus lewat operasi +add pada kelas tersebut, tidak seperti database relasional yang menggunakan akses dari luar lewat injeksi SQL (insert into Customer).
Jadi sejatinya CRUD pada objek terletak di bagian operasi kelas yang bersangkutan, jika ingin prinsip encapsulation tetap dipegang. Hal ini bisa dijalankan untuk Object Database Management System (ODBMS) murni dengan basis data objek seperti DB4O (lihat pos yang lalu) atau tipe no-sql seperti MongoDB. Interface yang mengirimkan data yang harus diubah pada PBO hanya berupa pesan (message), misalnya pada diagram kelas di atas ingin menambah satu pelanggan baru maka interface yang biasanya form/frame memberikan pesan ke kelas Customer agar menjalankan operasi +add(name,phone) untuk menambah satu data pelanggan baru dengan name dan phone tertentu (dari isian form/frame). Mungkin pembaca tidak setuju, boleh saja, toh antara konsep PBO dengan terstruktur termasuk antara database relasional dan objek pun bisa dikombinasikan. Terkadang antara teori dengan aplikasi/penerapan perlu kompromi.