Core Object-Oriented Programming (OOP) dalam Python

Core Object-Oriented Programming (OOP) in Python

 1. Inheritance

Konsep Inheritance:

Inheritance adalah  konsep OOP fundamental yang memungkinkan kelas derivatif (class child) untuk mewarisi sifat dan metode dari kelas dasar. (parent class). Ini mempromosikan penggunaan ulang kode dan menetapkan hierarki alami antara kelas.

Types of Inheritance:

1. Single Inheritance:Kelas derivatif mewarisi dari satu kelas dasar.

   ```python

class BaseClass:

    def base_method(self):

        print("Base method")

class DerivedClass(BaseClass):

    def derived_method(self):

        print("Derived method")

obj = DerivedClass()

obj.base_method()  # Output: Base method

obj.derived_method()  # Output: Derived method

   ```

2. Multiple Inheritance: Kelas derivatif mewarisi dari beberapa kelas dasar.

   ```python

class ClassB:

    def method_b(self):

        print("Method B")

class ClassC(ClassA, ClassB):

    pass

obj = ClassC()

obj.method_a()  # Output: Method A

obj.method_b()  # Output: Method B

   ```

3. Multilevel Inheritance:Kelas derivatif mewarisi dari kelas derivatif lainnya.

   ```python

class IntermediateClass(BaseClass):

    def intermediate_method(self):

        print("Intermediate method")

class DerivedClass(IntermediateClass):

    def derived_method(self):

        print("Derived method")

obj = DerivedClass()

obj.base_method()  # Output: Base method

obj.intermediate_method()  # Output: Intermediate method

obj.derived_method()  # Output: Derived method

   ```

4. Hierarchical Inheritance: Kelas-kelas yang diwariskan dari satu basis.

   ```python

class DerivedClass2(BaseClass):

    def derived2_method(self):

        print("Derived2 method")

obj1 = DerivedClass1()

obj1.base_method()  # Output: Base method

obj1.derived1_method()  # Output: Derived1 method

obj2 = DerivedClass2()

obj2.base_method()  # Output: Base method

obj2.derived2_method()  # Output: Derived2 method

   ```

Benefits of Inheritance:

- Code Reuse: Fungsi umum dapat didefinisikan dalam kelas dasar dan digunakan kembali dalam kelas derivatif.

- Hierarchical Organization: Kelas dapat diatur dalam hierarki, membuat kode lebih mudah dipahami dan dapat dikelola.

- Extensibility: Fungsionalitas baru dapat ditambahkan ke kelas yang ada tanpa mengubahnya secara langsung.

 2. Encapsulation

Principle of Encapsulation:

Encapsulation adalah praktik bundling data (attribut) dan metode yang beroperasi pada data menjadi satu unit, atau kelas. Prinsip ini membantu dalam melindungi keadaan internal sebuah objek dari modifikasi yang tidak disengaja dan menyediakan antarmuka terkontrol untuk mengakses dan memodifikasi data.

Encapsulation dalam Python:

- Public Members: dapat diakses dari mana saja.

- Protected Members: Diindikasikan oleh satu underscore (`_`). Dirancang untuk diakses hanya dalam kelas dan subkelasnya.

- Private Members: yang ditandai dengan double underscore (`__`) Hanya tersedia di dalam kelas.

Example:

```python

class DerivedClass1(BaseClass):

    def derived1_method(self):

        print("Derived1 method")

class MyClass:

    def __init__(self):

        self.public_attr = "I am public"

        self._protected_attr = "I am protected"

        self.__private_attr = "I am private"

   

    def get_private_attr(self):

        return self.__private_attr

   

    def set_private_attr(self, value):

        self.__private_attr = value

obj = MyClass()

print(obj.public_attr)  # Output: I am public

print(obj._protected_attr)  # Output: I am protected

print(obj.get_private_attr())  # Output: I am private

# Trying to access private attribute directly will raise an AttributeError

# print(obj.__private_attr)  # Raises AttributeError

```

 3. Abstraction

Konsep Abstraction:

Abstraction adalah konsep menyembunyikan detail implementasi yang kompleks dan menampilkan hanya fitur esensial dari suatu objek. Ini membantu mengurangi kompleksitas dan meningkatkan pembacaan kode.

Abstract Classes dan Methods dalam Python:

Abstract classes tidak dapat diinstansi dan dimaksudkan untuk diklasifikasikan. Mereka dapat berisi metode abstrak yang harus diimplementasikan oleh kelas derivatif.

Example:

```python

from abc import ABC, abstractmethod

class AbstractClass(ABC):

    @abstractmethod

    def abstract_method(self):

        pass

class ConcreteClass(AbstractClass):

    def abstract_method(self):

        print("Implementation of abstract method")

obj = ConcreteClass()

obj.abstract_method()  # Output: Implementation of abstract method

```

Role of Abstract Classes:

- Menentukan antarmuka umum untuk kelas derivatif.

- Menyediakan blueprint untuk kelas untuk diikuti, memastikan bahwa metode tertentu diterapkan.

 4. Polymorphism

Concept of Polymorphism:

Polymorphism memungkinkan objek dari kelas yang berbeda untuk diperlakukan sebagai objek dari superklase umum. Ini memungkinkan antarmuka yang sama untuk digunakan untuk bentuk dasar yang berbeda (data types).

Polymorphism lewat Method Overriding dan Overloading:

- Method Overriding: Kelas derivatif dapat memberikan implementasi spesifik dari metode yang sudah didefinisikan dalam kelas dasarnya.

- Method Overloading:Python tidak mendukung metode overloading secara natif, tetapi kita dapat mencapai perilaku serupa menggunakan argumen default atau argumen panjang variabel.

Example of Method Overriding:

```python

class BaseClass:

    def display(self):

        print("Base class display")

class DerivedClass(BaseClass):

    def display(self):

        print("Derived class display")

obj = DerivedClass()

obj.display()  # Output: Derived class display

```

Benefits of Polymorphism:

- Flexibility: Kelas yang berbeda dapat digunakan secara bergantian jika mereka berbagi antarmuka yang sama.

- Extensibility: Kelas baru dapat diperkenalkan dengan perubahan minimal ke basis kode yang ada.

 5. Classes, Constructors, and Methods

Defining Classes, Constructors, and Methods:

- Class: Blueprint untuk membuat objek.

- Constructor: Metode khusus (`__init__`) yang digunakan untuk memulakan atribut objek.

- Methods: Fungsi yang ditetapkan dalam suatu kelas.

Example:

```python

class MyClass:

    def __init__(self, value):

        self.value = value

   

    def display(self):

        print(f"Value: {self.value}")

   

    @staticmethod

    def static_method():

        print("This is a static method")

   

    @classmethod

    def class_method(cls):

        print("This is a class method")

obj = MyClass(10)

obj.display()  # Output: Value: 10

MyClass.static_method()  # Output: This is a static method

MyClass.class_method()  # Output: This is a class method

```

Purpose of Constructors:

- Mengidentifikasi atribut objek.

- Mengatur kondisi atau properti yang diperlukan untuk objek.

 6. Inheritance and Private/Public Properties

Inheritance and Accessibility of Class Members:

- Public Members: Inherited  dan dapat diakses oleh derivatif.

- Protected Members: Inherited dan dimaksudkan untuk diakses dalam kelas dan subkelasnya.

- Private Members: Tidak langsung inherited tetapi dapat diakses melalui nama mangling.

Example:

```python

class BaseClass:

    def __init__(self):

        self.public_attr = "Public"

        self._protected_attr = "Protected"

        self.__private_attr = "Private"

   

    def get_private_attr(self):

        return self.__private_attr

class DerivedClass(BaseClass):

    def display(self):

        print(self.public_attr)

        print(self._protected_attr)

        print(self.get_private_attr())

obj = DerivedClass()

obj.display()

```

 7. Private Attributes or Properties

Purpose and Benefits:

- Control Access: Melindungi data sensitif dari modifikasi yang tidak disengaja.

- Data Integrity: Pastikan data hanya dimodifikasi melalui metode terkontrol (getters and setters).

Defining and Accessing Private Attributes:

```python

class MyClass:

    def __init__(self, value):

        self.__private_attr = value

   

    def get_private_attr(self):

        return self.__private_attr

   

    def set_private_attr(self, value):

        self.__private_attr = value

obj = MyClass(10)

print(obj.get_private_attr())  # Output: 10

obj.set_private_attr(20)

print(obj.get_private_attr())  # Output: 20

```

 8. Challenge: Object-Oriented Programming

Problem Statement:

Rancang hierarki kelas untuk mewakili berbagai jenis kendaraan. Mengimplementasikan kelas ‘Vehicle’, ‘Car’ dan ‘Truck’ dengan persyaratan berikut:

- Gunakan  inheritance untuk berbagi atribut dan metode yang umum.

- Mengimplementasikan encapsulation untuk melindungi atribut pribadi.

- Menunjukkan polimorfisme dengan mendominasi metode dalam kelas derivatif.

Solution:

 9. Solution: Temperature Class

Class Design:

- gunakan encapsulation Melindungi atribut pribadi.

-Menyediakan metode getter dan setter untuk akses terkontrol.

- Menggunakan metode untuk mengkonversi antara Celsius dan Fahrenheit.

Example:

```python

class Temperature:

    def __init__(self, celsius=0):

        self.__celsius = celsius

   

    def get_celsius(self):

        return self.__celsius

   

    def set_celsius(self, value):

        self.__celsius = value

   

    def to_fahrenheit(self):

        return (self.__celsius * 9/5) + 32

   

    def from_fahrenheit(self, fahrenheit):

        self.__celsius = (fahrenheit - 32) * 5/9

temp = Temperature(25)

print(temp.get_celsius())  # Output: 25

print(temp.to_fahrenheit())  # Output: 77.0

temp.from_fahrenheit(77)

print(temp.get_celsius())  # Output: 25.0

```

 10. Solution: Circle Class

Class Design:

- Gunakan encapsulation untuk melindungi atribut pribadi.

- Mengimplementasikan metode untuk menghitung area dan lingkaran.

- Menggunakan metode statis untuk perhitungan yang tidak tergantung pada atribut instance.

Example:

```python

import math

class Circle:

    def __init__(self, radius):

        self.__radius = radius

   

    def get_radius(self):

        return self.__radius

   

    def set_radius(self, value):

        self.__radius = value

   

    def area(self):

        return math.pi * self.__radius ** 2

   

    def circumference(self):

        return 2 * math.pi * self.__radius

   

    @staticmethod

    def diameter(radius):

        return 2 * radius

circle = Circle(5)

print(circle.get_radius())  # Output: 5

print(circle.area())  # Output: 78.53981633974483

print(circle.circumference())  # Output: 31.41592653589793

print(Circle.diameter(5))  # Output: 10

```

Contoh-contoh ini mencakup konsep OOP inti, termasuk inheritance, encapsulation, abstraction, dan polymorphism, memberikan dasar yang kuat untuk memahami dan menerapkan OOP di Python.