# PBO : Class dan Object

## 1. Pendahuluan

Pemrograman berorientasi objek (OOP) adalah paradigma pemrograman yang menggunakan objek dan kelas sebagai elemen dasar untuk menyusun program. Dalam OOP, objek adalah entitas yang memiliki atribut (data) dan metode (fungsi), sedangkan kelas adalah blueprint atau template yang mendefinisikan sifat-sifat objek tersebut.

Materi kali ini akan membahas dasar dari Class dan Object dalam pemrograman Python, yang merupakan salah satu bahasa yang mendukung paradigma OOP.

### Tujuan Praktikum
1. Memahami konsep dasar class dan object.
2. Menerapkan class dan object dalam pembuatan program Python.
3. Memahami perbedaan antara class sebagai template dan object sebagai instansiasi dari class.

## 2. Dasar Teori

### Kelas (Class)
Kelas adalah blueprint atau cetak biru dari objek. Kelas mendefinisikan atribut dan perilaku (metode) yang dimiliki oleh objek-objek dari kelas tersebut. Sebuah kelas dibuat dengan menggunakan kata kunci `class` di Python.

**Sintaks:**

class ClassName:
    # constructor
    def __init__(self):
        # atribut
        pass
    
    # metode
    def method_name(self):
        pass

### Objek (Object)
Objek adalah instansiasi dari sebuah kelas. Ketika sebuah objek dibuat dari sebuah kelas, maka objek tersebut akan memiliki semua atribut dan metode yang didefinisikan dalam kelas.

**Sintaks:**

# membuat objek dari kelas
object_name = ClassName()

## 3. Contoh Use Case dan Analisis

### Contoh 1: Membuat Kelas Sederhana

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def display_info(self):
        print(f"Car brand: {self.brand}, Model: {self.model}")

# Membuat objek dari kelas Car
car1 = Car("Toyota", "Camry")
car1.display_info()

**Analisis:**
- `Car`: Kelas yang memiliki atribut `brand` dan `model`.
- `__init__(self, brand, model)`: Konstruktor yang diinisialisasi saat objek dibuat.
- `car1 = Car("Toyota", "Camry")`: Membuat objek `car1` dengan properti `brand` dan `model`.
- `car1.display_info()`: Memanggil metode untuk menampilkan informasi mobil.

---

### Contoh 2: Menambahkan Atribut Dinamis

class Dog:
    def __init__(self, name):
        self.name = name
        self.age = 0  # Default age

    def set_age(self, age):
        self.age = age

    def bark(self):
        print(f"{self.name} is barking!")

# Membuat objek dari kelas Dog
dog1 = Dog("Buddy")
dog1.set_age(3)
dog1.bark()

**Analisis:**
- `Dog`: Kelas dengan atribut `name` dan `age`.
- `dog1 = Dog("Buddy")`: Objek `dog1` dibuat dengan nama "Buddy".
- `dog1.set_age(3)`: Menetapkan umur `dog1` menjadi 3.
- `dog1.bark()`: Menampilkan suara anjing "Buddy".

---

### Contoh 3: Menggunakan Metode dengan Parameter

class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

# Membuat objek
calc = Calculator()
result_add = calc.add(10, 5)
result_subtract = calc.subtract(10, 5)

print(f"Addition: {result_add}")
print(f"Subtraction: {result_subtract}")

**Analisis:**
- `Calculator`: Kelas yang berisi metode untuk penambahan dan pengurangan.
- `calc.add(10, 5)`: Menghitung penjumlahan 10 dan 5.
- `calc.subtract(10, 5)`: Menghitung pengurangan 10 dan 5.

---

### Contoh 4: Menggunakan Objek di dalam Objek

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

class Car:
    def __init__(self, brand, model, horsepower):
        self.brand = brand
        self.model = model
        self.engine = Engine(horsepower)

    def display_info(self):
        print(f"Car brand: {self.brand}, Model: {self.model}, Horsepower: {self.engine.horsepower}")

# Membuat objek Car dengan objek Engine di dalamnya
car2 = Car("Honda", "Accord", 200)
car2.display_info()

**Analisis:**
- `Engine`: Kelas yang mendeskripsikan mesin mobil dengan atribut `horsepower`.
- `Car`: Kelas mobil yang memiliki objek `Engine` sebagai atribut.
- `car2.display_info()`: Menampilkan informasi mobil termasuk daya mesin.

---

### Contoh 5: Menggunakan Inheritance (Pewarisan)

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} is making a sound!")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} says Meow!")

# Membuat objek Cat yang mewarisi sifat dari kelas Animal
cat1 = Cat("Whiskers")
cat1.speak()

**Analisis:**
- `Animal`: Kelas dasar dengan metode `speak`.
- `Cat`: Kelas turunan dari `Animal`, yang menimpa metode `speak`.
- `cat1 = Cat("Whiskers")`: Objek kucing `cat1` dibuat dan mewarisi atribut `name`.

---

### Contoh 6: Kelas dengan Metode Statis

class Math:
    @staticmethod
    def multiply(a, b):
        return a * b

# Memanggil metode statis tanpa membuat objek
result = Math.multiply(5, 6)
print(f"Multiplication: {result}")

**Analisis:**
- `Math`: Kelas dengan metode statis `multiply`.
- `@staticmethod`: Dekorator untuk mendefinisikan metode statis.
- `Math.multiply(5, 6)`: Memanggil metode tanpa membuat objek.

## 4. Kesimpulan

Dalam modul ini, kita telah mempelajari konsep dasar dari class dan object dalam Python. Kita juga telah menerapkan 6 contoh use case yang menunjukkan berbagai cara penggunaan class dan object, mulai dari pembuatan objek sederhana hingga penggunaan inheritance dan metode statis.