Sabtu, 25 Mei 2019

Perbaikan Pemprograman Berbasis Objek


Perbaikan Pemprograman Berbasis Objek 

Nama : Abednego Wicaksono P

Kelas : RPL XI-2



OOP  (Object Oriented Programming)



   OOP atau bisa disebut juga Object Oriented Programming  adalah sebuah  pradigma pemprogramman dalam melakukan pemprogramman yang berorientasi kepada objek, fungsi data dan pengolahan data yang akan dibungkus dalam kelas-kelas dan objek-objek . Masing-masing dari objek dapat memiliki sifat dan tugasnya yang berbeda, dalam kasus ini objek dapat bekerja sendiri atau bekerja sama dengan kemungkinan saling ada hubungan seperti menerima data ,mengirim data dan memproses data.

   Contoh yang dapat kita ambil dari OOP dalam kehidupan nyata adalah , ada sebuah kendaraan memiliki banayk komponen seperti mesiin , aki , rem ,piston dan banyak lagi komponen-komponen tersebut memiliki fungsinya masing-masing layaknya objek yang memilikki fungsi , rem untuk mengerem motor , ban untuk melapisi roda agar roda bisa berputar dengan benar , mesin pun berguna untuk membuat motor bisa berjalan dengan bantuan dari komponen lainnya .

 Jenis-jenis OOP pada Bahasa Pemprograman

Dikarenakan banyak sekali kemudahan yang di berikan oleh OOP , banyak pula bhasa pemprogramman yang mendukung fitur OOP tersebut ada 3 jenis , yaitu :

- Bahasa OOP Murni adalah sebuah bahasa yang mengharuskan program ditulis hanya berupa            objek  saja . contoh -> smaltak , ruby , jade , dan lain-lain.

-Bahasa OOP Hybird adalah bahasa yag mengharuskan untuk pemprogramman objek dengan             beberapa elemen procedural.

-Bahasa OOP Hybird dalam Web sama dengan Bahasa OOP hybird ,namun yang membedakannya hanyalah konsep ini sering digunakan dalam pemprograman web.





Dalam OOP Ada beberapa konep diantaranya.

* Enkapsulasi (Encapsulation)

   Enkapsulasi merupakan metode untuk mengatur struktur class dengan cara menyembunyikan alur kerja dari class tersebut.

Struktur yang dimaksut adalah Propety dan method, dengan ini kita dapat membuat pembatas akses kepada properti dan mehod sehingga hanya beberapa property dan method saja yang dapat diakses, denagan enkapsulasi kita daapt menentukan properi dan method mana saja yang boleh diakses.



Pengertian Akses Protected

Jika sebuah property atau method dinyatakan sebagai protected, berarti propertiy atau methodtersebut tidak bisa diakses dari luar class, namun bisa diakses oleh class itu sendiri atau turunan class tersebut.
Apabila kita mencoba mengakses protected property atau protected method dari luar class, akan menghasilkan error, seperti contoh berikut ini:
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
<?php

// buat class laptop
class laptop {

   // buat protected property
   protected $pemilik;
  
  // buat protected method
   protected function hidupkan_laptop() {
      return "Hidupkan Laptop";
   }
}

// buat objek dari class laptop (instansiasi)
$laptop_anto = new laptop();
  
// set protected property akan menghasilkan error
$laptop_anto->pemilik="Anto";
// Fatal error: Cannot access protected property laptop::$pemilik
  
// tampilkan protected property akan menghasilkan error
echo $laptop_anto->pemilik;
// Fatal error: Cannot access protected property laptop::$pemilik
  
// jalankan protected method akan menghasilkan error
echo $laptop_anto->hidupkan_laptop();
// Fatal error: Call to protected method laptop::hidupkan_laptop()
// from context
?>
Dalam contoh di atas, pemanggilan property $pemilik dan method hidupkan_laptop() dari luar class akan menghasilkan error.
Walaupun akses level protected tidak bisa diakses dari luar class, namun bisa diakses dari dalam class itu sendiri, berikut adalah contohnya:
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
<?php

// buat class laptop
class laptop {

   // buat protected property
   protected $pemilik="Anto";

   public function akses_pemilik() {
      return $this->pemilik;
   }
   protected function hidupkan_laptop() {
      return "Hidupkan Laptop";
   }
   public function paksa_hidup() {
      return $this->hidupkan_laptop();
   }
}
  
// buat objek dari class laptop (instansiasi)
$laptop_anto = new laptop();
  
// jalankan method akses_pemilik()
echo $laptop_anto->akses_pemilik(); // "Anto"
  
// jalankan method paksa_hidup()
echo $laptop_anto->paksa_hidup(); // "Hidupkan Laptop"
?>

Hampir sama dengan contoh kita sebelumnya, property $pemilik di deklarasikan sebagai protected, sehingga pengaksesan dari luar class akan menghasilkan error. Oleh karena itu, saya membuat sebuah public method yang akan menampilkan hasil property $pemilik, yakni method akses_pemilik().

Begitu juga dengan method hidupkan_laptop() yang tidak bisa diakses secara langsung. Saya menambahkan method paksa_hidup() yang secara internal akan mengakses method hidupkan_laptop().


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

// buat class komputer
class komputer{

   // property dengan hak akses protected
   protected $jenis_processor = "Intel Core i7-4790 3.6Ghz";
}
  
// buat class laptop
class laptop extends komputer{
   public function tampilkan_processor() {
     return $this->jenis_processor;
   }
}
  
// buat objek dari class laptop (instansiasi)
$laptop_baru = new laptop();
  
// jalankan method
echo $laptop_baru->tampilkan_processor(); // "Intel Core i7-4790 3.6Ghz"
?>
Pada kode di atas, walaupun method $jenis_processor di set sebagai protected pada class komputer, tetapi masih bisa diakses dari class laptop yang merupakan turunan dari class komputer.
  
Pengertian Hak Akses: Private

 Hak akses terakhir dalam konsep enkapsulasi adalah private. Jika sebuah property atau method di-set sebagai private, maka satu-satunya yang bisa mengakses adalah class itu sendiri. Class lain tidak bisa mengaksesnya, termasuk class turunan.

Sebagai contoh, berikut adalah hasil yang di dapat jika kita mengakses property dan methoddengan level private:
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
<?php

// buat class komputer
class komputer {
   
   // property dengan hak akses protected
   private $jenis_processor = "Intel Core i7-4790 3.6Ghz";
   
   public function tampilkan_processor() {
     return $this->jenis_processor;
   }
}
  
// buat class laptop
class laptop extends komputer{
  
   public function tampilkan_processor() {
     return $this->jenis_processor;
   }
}
  
// buat objek dari class laptop (instansiasi)
$komputer_baru = new komputer();
$laptop_baru = new laptop();
  
// jalankan method dari class komputer
echo $komputer_baru->tampilkan_processor(); // "Intel Core i7-4790 3.6Ghz"
  
// jalankan method dari class laptop (error)
echo $laptop_baru->tampilkan_processor();
// Notice: Undefined property: laptop::$jenis_processor
?>
Dalam kode di atas, saya membuat 2 buah class, yakni class komputer, dan class laptop. Class laptop merupakan turunan dari class komputer. Di dalam class komputer terdapat property$jenis_processor dengan akses level private. Di dalam class komputer dan class laptop, saya membuat method tampilkan_processor() yang digunakan untuk mengakses property $jenis_processor.

Pengaksesan method tampilkan_processor() dari objek $komputer_baru sukse ditampilkan karena berada di dalam satu class dimana property $jenis_processor berada.

Akan tetapi, jika method tampilkan_processor() diakses dari objek $laptop_baru yang merupakan turunan dari class komputer, PHP akan mengeluarkan error karena property $jenis_processor tidak dikenal.

Akses level private sering digunakan untuk menyembunyikan property dan method agar tidak bisa diakses di luar class.

 * Inheritanse (Pewarisan)

    Inheritance atau Pewarisan/Penurunan adalah konsep pemrograman dimana sebuah class dapat ‘menurunkan’ property dan method yang dimilikinya kepada class lain. 


    Konsep inheritance digunakan untuk memanfaatkan fitur ‘code reuse’ untuk menghindari duplikasi kode program.
Cara Penggunaan Inheritance dalam PHP

    Di dalam PHP, inheritance / penurunan dari sebuah class kepada class lain menggunakan kata kunci: ‘extends’, dengan penulisan dasar sebagai berikut:

1
2
3
4
5
6
7
8
9
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 kedalam contoh program penggunaan inheritance/penurunan di dalam PHP:

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
<?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 diatas, saya membuat class komputer dengan beberapa property dan                  sebuah method. Property class komputer belum berisi nilai apa-apa.


    Dibawah class komputer, saya membuat class laptop extends class komputer. Disini                      saya menurunkan class komputer kedalam class laptop. Di dalam class laptop, kita bisa                        mengakses seluruh property dan method apapun dari 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 ‘menurunkan’:

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
<?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()
?>
     Dalam contoh diatas, saya membuat class komputer yang diturunkan kepada class laptop, dan        kemudian diturunkan lagi kepada class chromebook. Dari dalam class chromebook ini kemudian        saya memanggil method dari class diatasnya.

      Jika anda perhatikan, setiap method selain method beli_semua(), memiliki hak akses protected.     Hak akses protected ini ‘menghalangi’ kode program lain untuk mengaksesnya,                                   selain classturunan.

     Pada baris terakhir, saya menyisipkan kode program untuk mencoba mengakses method beli_komputer() . Kode ini sengaja saya beri tanda komentar. Jika anda menghapus tanda komentar, PHP akan mengeluarkan error yang menyatakan kita tidak bisa mengakses method dengan hak akses protected:
1
2
3
4
<?
$gadget_baru->beli_komputer();
// Fatal error: Call to protected method komputer::beli_komputer()
?>
    Inilah yang dimaksud dengan enkapsulasi dalam OOP. Membatasi method yang tidak boleh diakses akan membuat kode program menjadi lebih terstruktur.

   * Polimorfisme

      Di dalam pemrograman objek, polimorfisme adalah konsep dimana terdapat banyak class yang memiliki signature method yang sama. Implementasi dari method-method tersebut diserahkan kepada tiap class, akan tetapi cara pemanggilan method harus sama. Agar kita dapat ‘memaksakan’ signature method yang sama pada banyak class, class tersebut harus diturunkan dari sebuah abstract class atau object interface.

 Sebagai contoh, berikut adalah kode PHP yang mengimplementasikan konsep polimorfisme:
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
<?php
// buat abstract class
abstract class komputer{
   // buat abstract method
   abstract public function booting_os();
}
  
class laptop extends komputer{
   public function booting_os(){
     return "Proses Booting Sistem Operasi Laptop";
   }
}
  
class pc extends komputer{
   public function booting_os(){
     return "Proses Booting Sistem Operasi PC";
   }
}
  
class chromebook extends komputer{
public function booting_os(){
     return "Proses Booting Sistem Operasi Chromebook";
   }
}
  
  
// buat objek dari class diatas
$laptop_baru = new laptop();
$pc_baru = new pc();
$chromebook_baru = new chromebook();
  
// buat fungsi untuk memproses objek
function booting_os_komputer($objek_komputer){
   return $objek_komputer->booting_os();
}
  
// jalankan fungsi
echo booting_os_komputer($laptop_baru);
echo "<br />";
echo booting_os_komputer($pc_baru);
echo "<br />";
echo booting_os_komputer($chromebook_baru);
?>
    Contoh kode diatas cukup panjang, namun jika anda mengikuti tutorial OOP PHP sebelumnya (tentang abstract class), maka kode diatas akan bisa dipahami dengan baik.

      Pada awal program, saya membuat abstract class komputer yang kemudian diturunkan kedalam 3 class lain, yakni: class laptop, class pc dan class chromebook. Abstract class komputer memiliki abstract method booting_os(), yang harus diimplementasikan ulang pada tiap class yang diturunkan dari class komputer. Setelah pendefenisian class, saya membuat 3 objek dari masing-masing class.

       Perhatikan bahwa setelah pembuatan objek dari masing-masing class, saya membuat fungsi booting_os_komputer(). Fungsi ini berperan untuk memanggil method-method dari setiap class.

       Konsep polimorfisme dari contoh diatas adalah, fungsi booting_os_komputer() akan selalu berhasil dijalankan, selama argumen yang diberikan berasal dari class yang diturunkan dari class abstract komputer.


Peran Abstract Class dan Interface dalam Polimorfisme
     Baik abstract class maupun interface bisa digunakan untuk membuat banyak class dengan method yang sama. Bahkan keduanya sering digunakan secara bersama-sama.

      Berikut adalah revisi kode program kita sebelumnya dengan menggunakan abstract class dan interface:
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
<?php
// buat abstract class
abstract class komputer{
   // buat abstract method
   abstract public function booting_os();
}
  
interface mouse{
   public function double_klik();
}
  
class laptop extends komputer implements mouse{
   public function booting_os(){
     return "Proses Booting Sistem Operasi Laptop";
   }
   public function double_klik(){
     return "Double Klik Mouse Laptop";
   }
}
  
class pc extends komputer implements mouse{
   public function booting_os(){
     return "Proses Booting Sistem Operasi PC";
   }
   public function double_klik(){
     return "Double Klik Mouse PC";
   }
}
  
class chromebook extends komputer implements mouse{
   public function booting_os(){
     return "Proses Booting Sistem Operasi Chromebook";
   }
   public function double_klik(){
     return "Double Klik Mouse Chromebook";
   }
}
  
// buat objek dari class diatas
$laptop_baru = new laptop();
$pc_baru = new pc();
$chromebook_baru = new chromebook();
  
// buat fungsi untuk memproses objek
function booting_os_komputer($objek_komputer){
   return $objek_komputer->booting_os();
}
  
function double_klik_komputer($objek_komputer){
   return $objek_komputer->double_klik();
}
  
// jalankan fungsi
echo booting_os_komputer($laptop_baru);
echo "<br />";
echo double_klik_komputer($laptop_baru);
echo "<br />";
echo "<br />";
  
echo booting_os_komputer($pc_baru);
echo "<br />";
echo double_klik_komputer($pc_baru);
echo "<br />";
echo "<br />";
  
echo booting_os_komputer($chromebook_baru);
echo "<br />";
echo double_klik_komputer($chromebook_baru);
?>
     Pada kode program diatas, saya membuat 1 abstract class: komputer, dan 1 interface: mouse. Keduanya kemudian di turunkan kepada 3 class: class laptop, class pc, dan class chromebook.

    Selama sebuah class diturunkan dari abstract class komputer, dan menggunakan interface mouse, fungsi booting_os_komputer() dan fungsi double_klik_komputer() akan selalu berhasil di jalankan, terlepas dari apapun nama objek dan implementasi method yang digunakan.

      Konsep poliformisme yang kita bahas dalam tutorial ini bertujuan untuk membuat struktur pola dari class dan turunannya. Lebih jauh lagi, polimorfisme menekankan alur kode program yang terorganisir untuk mengurangi adanya perulangan kode program.

* Package 

     Package ini memiliki fungsi untuk mengelompokan dan mengorganisasian kelas-kelas dan interface yang sekelompok menjadi suatu unit tunggal dalam library Package juga mempengaruhi hak akses ke kelas-kelas di dalamnya.

 Membuat Java Package
Untuk menggunakan Java Package, cukup dengan mendeklarasikan kata kunci package yang diikuti nama paket. Seperti yang terlihat pada contoh berikut ini:
package kendaraan;
public class SepedaKumbang {
    int roda;
    int pedal;
    
    public void berjalan(){
        System.out.println("Berjalaan....");
    }
}
Maka akan terdapat direktori “kendaraan” pada direktory kerja yang biasa digunakan.

Memanggil Class pada Package
   Untuk memanggil class yang berbeda package maka terlebih dahulu dilakukan import terhadap package tersebut, seperti terlihat pada contoh berikut ini :

import kendaraan.*;
public class PanggilPackage {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SepedaKumbang sk = new SepedaKumbang();
        sk.berjalan();
    }
}
Namun bila berada pada satu package tidak perlu melakukan import, seperti pada contoh beriku ini:

package kendaraan;
 
public class PanggilKendaraan {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SepedaKumbang sk = new SepedaKumbang();
        sk.berjalan();
    }
}
Struktur file diatas terlihat pada bagan berikut ini :

PanggilPackage.java
|
|--kendaraan
   |--PanggilKendaraan.java
   |--Kendaraan.java
 

 Terlihat pada bagan class PanggilKendaraan dan Kendaraan terletak pada 1 direktori (baca:satu package) yaitu kendaraan, sedangkan class PanggilPackage terletak diluar package kendaraan sehingga mesti melakukan import package terlebih dahulu.

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