---
# System prepended metadata

title: PBO dengan Python - Polymorphism

---


# Modul Praktikum: Pemrograman Berorientasi Objek dengan Python
## Topik: Polymorphism

### 1. Pendahuluan
Pemrograman berorientasi objek (OOP) merupakan paradigma yang memodelkan program dalam bentuk objek-objek. Salah satu konsep penting dalam OOP adalah *polymorphism*. Polymorphism memungkinkan objek untuk diolah melalui antarmuka umum, bahkan ketika mereka berasal dari kelas yang berbeda. Dalam Python, polymorphism diterapkan dalam bentuk *method overriding* dan *method overloading*.

### 2. Dasar Teori
Polymorphism memungkinkan penggunaan satu antarmuka untuk berbagai tipe data. Dengan kata lain, satu fungsi atau metode dapat bekerja pada berbagai kelas yang berbeda. Ada dua jenis polymorphism yang sering digunakan:
- **Polymorphism dengan pewarisan (inheritance)**: Ketika subclass menimpa atau mengganti metode dari superclass.
- **Polymorphism dengan interface yang sama**: Ketika berbagai objek yang tidak terkait secara langsung, namun memiliki metode atau fungsi yang sama, dapat dipanggil dengan cara yang sama.

### 3. Contoh Penggunaan Polymorphism

Berikut ini beberapa contoh program yang menggunakan konsep polymorphism di Python.

#### **Contoh 1: Polymorphism dengan Pewarisan**

```python
class Animal:
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Bark"

class Cat(Animal):
    def sound(self):
        return "Meow"

def make_sound(animal):
    print(animal.sound())

dog = Dog()
cat = Cat()

make_sound(dog)  # Output: Bark
make_sound(cat)  # Output: Meow
```

**Analisis:**
- Kelas `Animal` memiliki metode `sound` yang akan di-*override* oleh subclass `Dog` dan `Cat`.
- Fungsi `make_sound` dapat menerima objek apa pun yang merupakan turunan dari `Animal` dan memanggil metode `sound()` dari objek tersebut.
- Ini menunjukkan polymorphism, karena objek berbeda (`Dog` dan `Cat`) dapat diproses menggunakan antarmuka yang sama (`make_sound`).

#### **Contoh 2: Polymorphism Tanpa Pewarisan**

```python
class Car:
    def move(self):
        return "Car is moving"

class Airplane:
    def move(self):
        return "Airplane is flying"

def transport(vehicle):
    print(vehicle.move())

car = Car()
airplane = Airplane()

transport(car)       # Output: Car is moving
transport(airplane)  # Output: Airplane is flying
```

**Analisis:**
- Kelas `Car` dan `Airplane` tidak memiliki hubungan pewarisan, tetapi keduanya memiliki metode `move`.
- Fungsi `transport` dapat menerima objek dari kelas `Car` atau `Airplane`, dan memanggil metode `move()`.
- Meskipun `Car` dan `Airplane` tidak berbagi hierarki yang sama, polymorphism terjadi melalui kesamaan antarmuka.

#### **Contoh 3: Polymorphism dengan Metode Generik**

```python
class Rectangle:
    def area(self, width, height):
        return width * height

class Circle:
    def area(self, radius):
        return 3.14 * radius ** 2

def calculate_area(shape, *args):
    print("Area:", shape.area(*args))

rect = Rectangle()
circle = Circle()

calculate_area(rect, 5, 10)  # Output: Area: 50
calculate_area(circle, 7)    # Output: Area: 153.86
```

**Analisis:**
- Kelas `Rectangle` dan `Circle` memiliki metode `area`, meskipun parameter yang diperlukan berbeda.
- Fungsi `calculate_area` bekerja dengan kedua objek tersebut menggunakan konsep polymorphism dengan metode yang memiliki nama yang sama tetapi argumen berbeda.
- Meskipun kelas memiliki cara berbeda untuk menghitung area, interface umum digunakan.

#### **Contoh 4: Polymorphism dengan Objek Koleksi**

```python
class Bird:
    def fly(self):
        return "Bird is flying"

class Airplane:
    def fly(self):
        return "Airplane is flying"

objects = [Bird(), Airplane()]

for obj in objects:
    print(obj.fly())
```

**Analisis:**
- Objek dari kelas `Bird` dan `Airplane` disimpan dalam list `objects`.
- Saat dilakukan iterasi pada list, polymorphism memungkinkan kita memanggil metode `fly()` pada setiap objek, meskipun objek tersebut berasal dari kelas yang berbeda.

#### **Contoh 5: Polymorphism dengan Built-in Functions**

```python
print(len("Python"))   # Output: 6
print(len([1, 2, 3]))  # Output: 3
```

**Analisis:**
- Fungsi `len()` adalah contoh polymorphism di Python karena ia dapat digunakan dengan berbagai tipe objek seperti string, list, tuple, dan lain-lain.
- Polymorphism ini diimplementasikan di level built-in functions.

#### **Contoh 6: Polymorphism dengan Fungsi Kustom**

```python
class Shape:
    def draw(self):
        pass

class Square(Shape):
    def draw(self):
        return "Drawing a square"

class Triangle(Shape):
    def draw(self):
        return "Drawing a triangle"

def draw_shape(shape):
    print(shape.draw())

shapes = [Square(), Triangle()]

for shape in shapes:
    draw_shape(shape)
```

**Analisis:**
- Kelas `Shape` adalah superclass dengan metode `draw` yang di-*override* oleh subclass `Square` dan `Triangle`.
- Fungsi `draw_shape` memungkinkan kita memanggil metode `draw` pada objek apapun yang merupakan subclass dari `Shape`.
- Polymorphism di sini memungkinkan kita menggunakan satu fungsi (`draw_shape`) untuk menangani berbagai jenis bentuk (shape).

### 4. Kesimpulan
Polymorphism memungkinkan kode lebih fleksibel, mudah diubah, dan efisien, karena satu fungsi atau metode dapat digunakan untuk berbagai tipe objek. Ini sangat penting dalam pemrograman berorientasi objek, terutama ketika berurusan dengan kelas-kelas yang berbeda tetapi berbagi antarmuka atau fungsi yang sama.
