Rabu, 11 Juli 2012

Sesi XIIII

Sessi 14 OOP Pada PHP

Diposkan oleh Mario Tawa Rabu, 11 Juli 2012

Object Oriented Programming (OOP) atau Pemrogrman Berbasis Objek adalah paradigma pemrograman yang memodelkan masalah dengan pendekatan objek. Konsep dari OOP sendiri adalah semua pemecahan masalah dibagi ke dalam objek seperti inheritance atau pewarisan, encapsulation atau pembungkusan, dan polymorphism atau kebanyakrupaan.

Perbedaan OOP dengan pemrograman prosedural

Menurut Bjarne Stroustrup dalam sebuah papernya yang berjudul “what is object oriented programming ?” paradigma dalam OOP adalah tentukan kelas yang kita inginkan, lengkapi sederetan operasi untuk kelas, tentukan struktur secara eksplisit dengan pewarisan. Sedangkan pemrograman prosedural berparadigma tentukan prosedur yang kita inginkan, gunakan algoritma terbaik yang bisa ditentukan. Dapat disimpulkan pemrograman prosedural berorientasi pada aksi, sedangkan OOP berorientasi pada objek.

Kelas dan Objek

Kelas adalah kumpulan objek-objek yang memiliki kemiripan perilaku (method) atu ciri atau karakterisitik
1
2
3
4
5
6
7
8
9
class myClass
{
public function doThat()
{
}
}
?>
Objek merupakan kesatuan entitas (benda) baik yang berwujudnyata atupun hanya suatu sistem atau konsep yang memilikisifat karakteristik dan fungsi. Objek juga merupakan instasiasi (instance) atau turunan langsung dari kelas

Inheritance

Fungsi utama pewarisan dalah menciptakan kelas baru dari kelas yang sudah ada. Dalam konsep ini kelas anak (child) mewarisi semua variabel dan method dari kelas asal(parent), namun masih dapat menambah variabel atau method baru jika memang diperlukan. Ada beberapa macam Inheritance atau pewarisan yang ada di dalam OOP yakni Single Inheritance dan Multple Inheritance
Single Inheritance

Multple Inheritance

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class KelasInduk
{
function fungsiInduk()
{
echo "Panggil fungsi Induk";
}
}
class KelasAnak extends KelasInduk
{
function fungsiAnak()
{
echo "Panggil fungsi Anak";
}
}
$child = new KelasAnak();
$child->fungsiInduk(); // output Panggil fungsi Induk
$child->fungsiAnak();// output Panggil fungsi Anak
?>
PHP tidak mendukung multiple inheritance dan perubahan PHP versi 5 ditekankan pada OOP salah satunya adalah beberapa tambahan untuk kemampuan inheritance

Encapsulation

Aspek ini berguna untuk menyembunyikan kelas dari luar sehingga pengaksesan data member (atribut dan method) suatu kelas tidak dapat diubah secara langsung oleh kelas lain. Enkapsulasi sangat berhungungan erat dengan modifier, yaitu :
  • Private
Akses modifier private memberikan spesifikasi bahwa nilai variabel dan method kelas hanya dapat diakses oleh method dalam kelas dimana didefinisikannya.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Kelas
{
private $variabel = "Panggil variabel private fungsi Anak";
public function fungsiSatu()
{
echo $this->variabel;
}
}
$kelas = new Kelas();
$kelas->fungsiSatu(); // output Panggil variabel private fungsi Anak
$kelas->fungsiDua(); // private tidak dapat diakses
?>
  • Protected
Akses modifier private memberikan spesifikasi bahwa nilai variabel dan method hanya dapat diakses oleh kelas dan sub-kelas (child) dari kelas tersebut
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class KelasInduk
{
protected function fungsiInduk()
{
echo "Panggil fungsi Induk";
}
}
class KelasAnak extends KelasInduk
{
public function fungsiAnak()
{
echo $this->fungsiInduk();
}
}
$child = new KelasAnak();
$child->fungsiAnak();// output Panggil fungsi Induk
$child->fungsiInduk ();// protected tidak dapat diakses
?>
  • Public
Akses modifier private memberikan spesifikasi bahwa nilai variabel dan method dapat diakses dari dalam maupun luar kelas

Polymorphism

Kemampuan suatu objek untuk memiliki bentuk atau wujud yang berbeda melalui suatu cara yang sama. Polimorfisme mengijinkan suatu kelas induk untuk mendefinisikan suatu method general untuk semua kelas turunannya dan selanjutnya kelas-kelas turunan dapat memperbaharui implemnetasi dari method tersebut secara lebih spesifik sesuai dengan karakteristik masing-masing. Polimorfisme dapat bekerja dengan kelas yang berbeda tidak perlu tahu kelas mana yang menggunakannya, karena semua menggunakan cara yang sama.
Sebuah analogi untuk polimorfisme adalah tombol. Semua orang tahu bagaimana menggunakan tombol, yaitu anda hanya menekan tombol tersebut. Lalu apa yang tombol lakukan? tergantung pada apa yang terhubung dan di mana tombol itu digunakan, tetapi tidak mempengaruhi bagaimana tombol digunakan.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class KelasInduk
{
public function ambil()
{
return __CLASS__;
}
}
class KelasAnak extends KelasInduk
{
public function ambil() // Override
{
return __CLASS__;
}
}
function ambilInduk(KelasInduk $p)
{
print $p->ambil() . '
';
}
$p = new KelasInduk();
$c = new KelasAnak();
ambilInduk($p);
ambilInduk($c);
?>
Hasil
KelasInduk
KelasAnak

Interface

PHP hanya mendukung single inherintace saja, artinya hanya kelas anak hanya mewarisi satu dari kelas induk. Namun kita bisa menggunakan interface sbagai alternatifnya. Interface hampir sama dengan kelas, tetapi hanya memiliki konstanta dan kumpulan method yang hanya memuat dekalarsi dan struktur method, tanpa detail implementasinya.
Sebuah analogi untuk interface adalah sepeda. Sepeda merupakan kendaraan, namun sepeda juga bisa dikategorikan sebagai alat olah raga. Apakah bisa katakan bahwa sepeda merupakan turunan dari kendaraan dan alat olah raga ? Tidak mungkin, karena dalam PHP tidak mendukung multiple inherintace. Hal yang mungkin adalah sepeda merupakan turunan dari kendaraan, yang juga memiliki sifat seperti alat olah raga. Inilah yang disebut interface, “memiliki sifat seperti…”, namun bukan turunannya.
1
2
3
4
5
interface MyInterface {
public function doThis();
public function doThat();
public function setName($name);
}
Untuk kelas yang mengimplementasi interface harus memiliki semua methiod yang ada dalam interface. Sebagai contoh berikut (lihat perbedaan pada komentar)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// VALID
class MyClass implements MyInterface
{
protected $name;
public function doThis() {
// kode doThis
}
public function doThat() {
// kode doThat
}
public function setName($name) {
$this->name = $name;
}
}
// INVALID
class MyClass implements MyInterface
{
// tidak ada method doThis
private function doThat() {
// harus public!
}
public function setName() {
// tidak ada argument name!
}
}

Kelas Abstrak

Kelas abstrak didesain untuk bertindak sebagai kelas dasar yang nantinya diperluas oleh kelas-kelas turunannya dan kelas abstrak tidak dapat dinstanisasikan secara langsung menjadi objek. Kelas yang diwarisi kelas abstrak harus mengimplementasikan semua metode abstrak didefinisikan dalam kelas abstrak. Beberapa aturan dalam pendefinisian kelas abstrak
  • Kelas yang berisi sedikitnya sebuah method abstrak harus didefinisikan sebagai abstrak
  • Method abstrak tidak boleh mendefinisikan implemntasi hanya signature
  • Kelas (non-abstrak) yang merupakan turunan kelas abstrak harus mendefiniskan semua method abstrak dan visibilitas minimal sama atau lebih luas.
1
2
3
4
5
6
7
8
9
abstract class MyAbstract
{
public $name;
public function doThis() {
// kode doThis
}
abstract public function doThat();
abstract public function setName($name);
}
Pewarisannya
1
2
3
4
5
6
7
8
9
10
11
class MyClass extends MyAbstract
{
public function doThat() {
// kode doThat
}
public function setName($name) {
// kode setName
}
}

Contoh Polymorphism, kelas abstrak dan interface

Kita ingin membuat rumus bangunan menghitung luas dan keliling, untuk persegi, persegi panjang dan segitiga. Dari ketiga bangunan tersebut memiliki sifat yang sama yaitu menghitung luas dan keliling. Beberapa memiliki bentuk hampir sama yang bisa dijadikan bentukan. Jadi kita membuat sebuah interface bangunan dan kelas abstrak untuk pewarisan bangunan persegi.
Persegi Panjang
luas persegi panjang
keliling persegi panjang
Persegi
luas persegi
keliling persegi
Segitiga
luas segitiga
keliling segitiga
gunakan fungsi PHP sqrt untuk hitung akar kuadrat
implementasi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
interface Bangunan
{
public function cariLuas();
public function cariKeliling();
}
class PersegiPanjang implements Bangunan
{
private $_sisi1;
private $_sisi2;
public function __construct($sisi1, $sisi2)
{
$this->_sisi1 = $sisi1;
$this->_sisi2 = $sisi2;
}
public function cariLuas()
{
return $this->_sisi1 * $this->_sisi2;
}
public function cariKeliling()
{
return 2 * ($this->_sisi1 + $this->_sisi2);
}
}
class Persegi extends PersegiPanjang
{
public function __construct($sisi)
{
parent::__construct($sisi, $sisi);
}
}
class Segitiga implements Bangunan
{
private $_sisi1;
private $_sisi2;
private $_sisi3;
public function __construct($sisi1, $sisi2, $sisi3)
{
$this->_sisi1 = $sisi1;
$this->_sisi2 = $sisi2;
$this->_sisi3 = $sisi3;
}
public function cariLuas()
{
$sp = $this->cariKeliling() / 2;
return sqrt($sp * ($sp - $this->_sisi1) * ($sp - $this->_sisi2) * ($sp - $this->_sisi3));
}
public function cariKeliling()
{
return $this->_sisi1 + $this->_sisi2 + $this->_sisi3;
}
}
function hitungKeliling(Bangunan $b)
{
printf('Keliling %s : %s
', get_class($b), $b->cariKeliling());
}
function hitungLuas(Bangunan $b)
{
printf('Luas %s : %s
', get_class($b), $b->cariLuas());
}
$bangunan = array(
new Segitiga(5, 6, 7),
new Persegi(4),
new PersegiPanjang(4,8)
);
array_walk($bangunan, 'hitungKeliling');
array_walk($bangunan, 'hitungLuas');
?>
Hasil
Keliling Segitiga : 15
Keliling Persegi : 16
Keliling PersegiPanjang : 24
Luas Segitiga : 9.9215674164922
Luas Persegi : 16
Luas PersegiPanjang : 32
Diposting oleh di Tidak ada komentar:

Sesi XIII










Diposting oleh di Tidak ada komentar:
Langganan: Postingan (Atom)