Enkapsulasi dan Abstraksi

Enkapsulasi dan abstraksi adalah prinsip dasar Pemrograman Berorientasi Objek (OOP) yang membantu mengelola kompleksitas dan meningkatkan pengaturan kode.

Enkapsulasi membatasi akses langsung ke data suatu objek, sedangkan abstraksi menyembunyikan detail implementasi dan hanya menampilkan fitur-fitur penting.

Enkapsulasi berarti menggabungkan data (atribut) dan metode dalam satu class serta membatasi akses langsung ke keduanya.

# Example of encapsulation
class Person:
    # Private attribute (indicated by double underscores)
    def __init__(self, name):
        self.__name = name

    # Public method to access the private attribute
    def get_name(self):
        return self.__name

person = Person("Alice")
# Accessing private data via a public method
print(person.get_name())

Dalam Python, atribut privat ditandai dengan dua garis bawah __. Atribut tersebut tidak dapat diakses secara langsung dari luar class.

# Private attributes
class Car:
    def __init__(self, brand):
        self.__brand = brand  # Private attribute

    def get_brand(self):
        # Public method to access the private attribute
        return self.__brand

car = Car("Toyota")
print(car.get_brand())  # Outputs: Toyota

Abstraksi menyembunyikan detail implementasi internal suatu class dan hanya menampilkan fungsionalitas yang diperlukan oleh pengguna.

# Example of abstraction
from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Subclass implementing the abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

circle = Circle(5)
print(circle.area())  # Outputs: 78.5

Class abstrak adalah class yang tidak dapat dibuat instansnya secara langsung. Class ini digunakan untuk menentukan interface umum bagi subclass-nya.

# Abstract Base Class with multiple subclasses
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
cat = Cat()
dog.speak()  # Outputs: Dog barks
cat.speak()  # Outputs: Cat meows

Enkapsulasi dan abstraksi saling berkaitan erat, tetapi merupakan konsep yang berbeda:

• Enkapsulasi: Membatasi akses ke data di dalam suatu class.
• Abstraksi: Menyembunyikan detail implementasi dan menyediakan interface yang jelas.

Berikut beberapa keuntungan utamanya:

• Meningkatkan keamanan dan kemudahan pemeliharaan kode.
• Mendorong pembuatan kode yang modular dan dapat digunakan kembali.
• Membuat kode lebih mudah dibaca dan dipahami.

Berikut beberapa kesalahan yang harus dihindari:

• Mengakses atribut privat secara langsung, bukan menggunakan metode pengambil dan metode pengubah.
• Membuat instans class abstrak secara langsung.
• Tidak mengimplementasikan semua metode abstrak dalam subclass.

Dalam pelajaran ini, Anda telah mempelajari:

• Pengertian enkapsulasi dan cara membatasi akses ke data menggunakan atribut privat.
• Pengertian abstraksi dan cara menggunakan class abstrak untuk menentukan interface umum.
• Perbedaan dan manfaat enkapsulasi serta abstraksi.

Kerja bagus! Mari lanjut ke topik berikutnya.