Cara Memahami Penggunaan OOP (Object Oriented Programming) bagi Pemula
Tags: programming
Published: 2024-06-03 11:30:29


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lrgd9t8a4ybzrio7ywrd.png)

OOP atau Object-Oriented Programming tuh kayak gaya nge-coding yang ngefokusin pada objek. Jadi, bayangin aja kalau kita bikin program kayak bikin benda-benda nyata yang punya sifat (atribut) dan bisa ngelakuin sesuatu (metode). Nah, buat kalian yang baru banget kenal sama OOP, yuk kita bahas dengan gaya santai biar lebih paham!

### Apa Itu OOP?
OOP itu intinya adalah bikin kode yang pake "object". _Object_ tuh kayak benda nyata yang punya atribut (kayak sifat atau data) dan _method_ (kayak aksi atau fungsi). _Class_ itu kayak blueprint atau cetakan dari _object_. Misalnya, kelas "Mobil" bisa dipake buat bikin objek "Mobil Avanza", "Mobil Jazz", dll.

### Konsep Dasar OOP

**1. Kelas (Class)**
Class itu blueprint dari object. Kita bikin class buat nentuin atribut dan method yang akan dimiliki object.

```php
<?php

class Hewan {
    public $nama;
    public $jenis;

    function __construct($nama, $jenis) {
        $this->nama = $nama;
        $this->jenis = $jenis;
    }

    function bicara() {
        return "$this->nama sedang berbicara.";
    }
}

```

**2. Objek (Object)**
Objek itu instance dari kelas. Jadi kita bikin objek dari kelas yang udah kita buat.

```php
<?php

$kucing = new Hewan("Tom", "Kucing");
echo $kucing->bicara();  // Output: Tom sedang berbicara.

```

**3. Enkapsulasi (Encapsulation)**
Enkapsulasi itu buat nyembunyiin detail implementasi dari objek. Caranya dengan bikin atribut jadi private.

```php
<?php

class Hewan {
    private $nama;
    private $jenis;

    function __construct($nama, $jenis) {
        $this->nama = $nama;
        $this->jenis = $jenis;
    }

    public function getNama() {
        return $this->nama;
    }

    public function bicara() {
        return "$this->nama sedang berbicara.";
    }
}

```

**4. Pewarisan (Inheritance)**
Pewarisan itu memungkinkan class buat mewarisi atribut dan metode dari class lain. Ini ngebantu bikin kode yang bisa dipake ulang.
```php
<?php

class Hewan {
    public $nama;
    public $jenis;

    function __construct($nama, $jenis) {
        $this->nama = $nama;
        $this->jenis = $jenis;
    }

    function bicara() {
        return "$this->nama sedang berbicara.";
    }
}

class Anjing extends Hewan {
    public $suara;

    function __construct($nama, $jenis, $suara) {
        parent::__construct($nama, $jenis);
        $this->suara = $suara;
    }

    function bicara() {
        return "$this->nama berkata $this->suara";
    }
}

$anjing = new Anjing("Spike", "Anjing", "Guk guk");
echo $anjing->bicara();  // Output: Spike berkata Guk guk

```

**5. Polimorfisme (Polymorphism)**
Polimorfisme memungkinkan method buat berperilaku beda berdasarkan objek yang manggilnya.

```php
<?php

class Kucing extends Hewan {
    function bicara() {
        return "$this->nama berkata Meow";
    }
}

$hewan_list = [
    new Hewan("Hewan", "Umum"),
    new Anjing("Spike", "Anjing", "Guk guk"),
    new Kucing("Tom", "Kucing")
];

foreach ($hewan_list as $hewan) {
    echo $hewan->bicara() . "\n";
}
// Output:
// Hewan sedang berbicara.
// Spike berkata Guk guk
// Tom berkata Meow

```

**6. Abstraksi (Abstraction)**
Abstraksi adalah cara buat cuma nampilin detail penting dari objek, nyembunyiin detail yang gak relevan. Biasanya pake kelas abstrak.

```php
<?php

abstract class Hewan {
    abstract public function bicara();
}

class Anjing extends Hewan {
    public function bicara() {
        return "Guk guk";
    }
}

class Kucing extends Hewan {
    public function bicara() {
        return "Meow";
    }
}

$anjing = new Anjing();
$kucing = new Kucing();

echo $anjing->bicara();  // Output: Guk guk
echo $kucing->bicara();  // Output: Meow

```

### Keuntungan Menggunakan OOP

1. Modularitas: Kode lebih rapi dan gampang dimengerti karena dikelompokkan dalam class.
2. Pemeliharaan: Lebih gampang update atau maintenance kode.
3. Penggunaan Ulang Kode: Kode bisa dipake ulang lewat pewarisan.
4. Fleksibilitas: Polimorfisme bikin metode bisa berperilaku beda tergantung objek yang manggil.

### Penerapan OOP dalam Proyek Nyata
Kalau temen-temen masih bingung dengan contoh diatas, kita coba pakai studi kasus asli dengan proyek yang mungkin temen-temen sering temui.

Untuk mulai memahami dan mengimplementasikan OOP, penting untuk berlatih dengan proyek kecil yang memanfaatkan konsep-konsep dasar OOP. Misalnya, membuat program sederhana yang mengelola data mahasiswa dengan kelas `Mahasiswa`, `Dosen`, dan `MataKuliah`. Dengan memahami cara kerja class, object, pewarisan, polimorfisme, enkapsulasi, dan abstraksi melalui proyek-proyek kecil, nanti temen-temen juga bakal paham dengan sendirinya kok.

```php
<?php

class Mahasiswa {
    private $nama;
    private $nim;

    public function __construct($nama, $nim) {
        $this->nama = $nama;
        $this->nim = $nim;
    }

    public function getNama() {
        return $this->nama;
    }

    public function getNim() {
        return $this->nim;
    }

    public function tampilkanInfo() {
        return "Nama: " . $this->nama . ", NIM: " . $this->nim;
    }
}

class Dosen {
    private $nama;
    private $nidn;

    public function __construct($nama, $nidn) {
        $this->nama = $nama;
        $this->nidn = $nidn;
    }

    public function getNama() {
        return $this->nama;
    }

    public function getNidn() {
        return $this->nidn;
    }

    public function tampilkanInfo() {
        return "Nama: " . $this->nama . ", NIDN: " . $this->nidn;
    }
}

class MataKuliah {
    private $namaMatkul;
    private $kodeMatkul;

    public function __construct($namaMatkul, $kodeMatkul) {
        $this->namaMatkul = $namaMatkul;
        $this->kodeMatkul = $kodeMatkul;
    }

    public function getNamaMatkul() {
        return $this->namaMatkul;
    }

    public function getKodeMatkul() {
        return $this->kodeMatkul;
    }

    public function tampilkanInfo() {
        return "Mata Kuliah: " . $this->namaMatkul . ", Kode: " . $this->kodeMatkul;
    }
}

$mahasiswa = new Mahasiswa("Budi", "123456");
$dosen = new Dosen("Pak Ahmad", "98765");
$matkul = new MataKuliah("Pemrograman", "INF101");

echo $mahasiswa->tampilkanInfo();  // Output: Nama: Budi, NIM: 123456
echo $dosen->tampilkanInfo();      // Output: Nama: Pak Ahmad, NIDN: 98765
echo $matkul->tampilkanInfo();     // Output: Mata Kuliah: Pemrograman, Kode: INF101

```

Apakah sudah paham sampai sini? Dengan paham dan praktek konsep OOP, temen-temen bisa bikin kode yang lebih efisien, rapi, dan gampang dirawat.

Jadi, memahami dan menerapkan OOP bukan hanya soal menguasai konsep-konsep dasarnya, tetapi juga tentang bagaimana mengintegrasikan konsep tersebut ke dalam praktek pemrograman sehari-hari. Dengan pendekatan yang benar, OOP dapat membantu temen-temen menulis kode yang lebih baik, lebih mudah dikelola, dan lebih fleksibel untuk kebutuhan pengembangan di masa depan. Dan yang paling penting ngoding itu diketik jangan dipikir. Sampai bertemu di artikel yang lebih menarik lagi!!!