ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ (Abstraction)

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ (Abstraction) ಎನ್ನುವುದು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ (OOP) ಒಂದು ಪ್ರಮುಖ ತತ್ವ. ಇದರ ಮುಖ್ಯ ಉದ್ದೇಶವೆಂದರೆ, ಬಳಕೆದಾರರಿಗೆ ಕೇವಲ ಅಗತ್ಯವಿರುವ ಮಾಹಿತಿಯನ್ನು ಮಾತ್ರ ತೋರಿಸಿ, ಅನಗತ್ಯವಾದ ಸಂಕೀರ್ಣ ವಿವರಗಳನ್ನು ಮರೆಮಾಡುವುದು.

ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, "ಏನು ಮಾಡುತ್ತದೆ" (What it does) ಎಂಬುದನ್ನು ತೋರಿಸುವುದು, ಆದರೆ "ಹೇಗೆ ಮಾಡುತ್ತದೆ" (How it does) ಎಂಬುದನ್ನು ಮರೆಮಾಡುವುದು.

ನೈಜ ಪ್ರಪಂಚದ ಉದಾಹರಣೆ: ನೀವು ಕಾರು ಚಲಾಯಿಸುವಾಗ, ನೀವು ಸ್ಟೀರಿಂಗ್, ಗೇರ್, ಮತ್ತು ಪೆಡಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತೀರಿ. ಆದರೆ, ಇಂಜಿನ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಗೇರ್‌ಬಾಕ್ಸ್ ಹೇಗೆ ಬದಲಾಗುತ್ತದೆ ಎಂಬ ಆಂತರಿಕ ತಾಂತ್ರಿಕ ವಿವರಗಳು ನಿಮಗೆ ತಿಳಿಯಬೇಕಾಗಿಲ್ಲ. ಇಲ್ಲಿ, ಕಾರಿನ ಇಂಟರ್ಫೇಸ್ (ಸ್ಟೀರಿಂಗ್, ಪೆಡಲ್) ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಆಗಿದೆ.

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ಸರಳತೆ: ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಬಳಕೆದಾರರು ಕೇವಲ ಸಂಬಂಧಿತ ಭಾಗಗಳ ಮೇಲೆ ಗಮನ ಹರಿಸಬಹುದು.
ಕೋಡ್ ನಿರ್ವಹಣೆ: ಆಂತರಿಕ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬದಲಾಯಿಸಿದರೂ, ಹೊರಗಿನ ಕೋಡ್‌ಗೆ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಕಾರಿನ ಇಂಜಿನ್ ಅನ್ನು ಬದಲಾಯಿಸಿದರೂ, ನೀವು ಕಾರನ್ನು ಅದೇ ಸ್ಟೀರಿಂಗ್ ಬಳಸಿ ಚಲಾಯಿಸಬಹುದು.
ಭದ್ರತೆ: ಅನಗತ್ಯ ವಿವರಗಳನ್ನು ಮರೆಮಾಡುವುದರಿಂದ, ಡೇಟಾ ಮತ್ತು ಲಾಜಿಕ್ ಅನ್ನು ಅನಧಿಕೃತ ಪ್ರವೇಶದಿಂದ ರಕ್ಷಿಸಬಹುದು.

ಪೈಥಾನ್‌ನಲ್ಲಿ ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ ಅನ್ನು ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್‌ಗಳು (Abstract Classes) ಮತ್ತು ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್‌ಗಳು (Abstract Methods) ಬಳಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಇದನ್ನು ಮಾಡಲು, ಪೈಥಾನ್‌ನ abc (Abstract Base Classes) ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್: ಇದು ಒಂದು ಕ್ಲಾಸ್ ಆಗಿದ್ದು, ಇದರಲ್ಲಿ ಒಂದು ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್‌ಗಳು ಇರುತ್ತವೆ. ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್‌ನ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ನೇರವಾಗಿ ರಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್: ಇದು ಕೇವಲ ಡಿಕ್ಲೇರ್ (ಘೋಷಣೆ) ಮಾಡಲಾದ ಮೆಥಡ್ ಆಗಿರುತ್ತದೆ, ಆದರೆ ಅದಕ್ಕೆ ಯಾವುದೇ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ (implementation) ಇರುವುದಿಲ್ಲ. ಈ ಮೆಥಡ್ ಅನ್ನು ಸಬ್‌ಕ್ಲಾಸ್‌ಗಳು (ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳು) ಕಡ್ಡಾಯವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು.

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್ ಮತ್ತು ಮೆಥಡ್ ರಚಿಸುವುದು

abc ಮಾಡ್ಯೂಲ್‌ನಿಂದ ABC ಮತ್ತು abstractmethod ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿಕೊಳ್ಳಬೇಕು.

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್ ರಚಿಸಲು, ಆ ಕ್ಲಾಸ್ ABC ಯಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗಬೇಕು.
ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ ರಚಿಸಲು, ಆ ಮೆಥಡ್‌ನ ಮೇಲೆ @abstractmethod ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಬೇಕು.

ಉದಾಹರಣೆ:

from abc import ABC, abstractmethod

# ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್
class Vehicle(ABC):
    def __init__(self, brand):
        self.brand = brand
        print(f"{self.brand} ವಾಹನ ಸಿದ್ಧವಾಗಿದೆ.")

    # ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್
    @abstractmethod
    def start(self):
        pass  # ಯಾವುದೇ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ ಇಲ್ಲ

    # ಸಾಮಾನ್ಯ ಮೆಥಡ್
    def stop(self):
        print(f"{self.brand} ವಾಹನ ನಿಂತಿದೆ.")

# ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್‌ನ ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ದೋಷ ಬರುತ್ತದೆ
# try:
#     v = Vehicle("Generic")
# except TypeError as e:
#     print(f"ದೋಷ: {e}")

# ಚೈಲ್ಡ್ ಕ್ಲಾಸ್
class Car(Vehicle):
    # ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ ಅನ್ನು ಕಡ್ಡಾಯವಾಗಿ ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಬೇಕು
    def start(self):
        print(f"{self.brand} ಕಾರು ಕೀ ಬಳಸಿ ಚಾಲೂ ಆಯಿತು.")

# ಮತ್ತೊಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್
class Bike(Vehicle):
    # ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ ಅನ್ನು ಕಡ್ಡಾಯವಾಗಿ ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಬೇಕು
    def start(self):
        print(f"{self.brand} ಬೈಕ್ ಕಿಕ್ ಸ್ಟಾರ್ಟ್‌ನಿಂದ ಚಾಲೂ ಆಯಿತು.")

# ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು
my_car = Car("ಮಾರುತಿ")
my_bike = Bike("ಹೋಂಡಾ")

my_car.start()
my_car.stop()

print("-" * 20)

my_bike.start()
my_bike.stop()

ಔಟ್‌ಪುಟ್:

ಮಾರುತಿ ವಾಹನ ಸಿದ್ಧವಾಗಿದೆ.
ಹೋಂಡಾ ವಾಹನ ಸಿದ್ಧವಾಗಿದೆ.
ಮಾರುತಿ ಕಾರು ಕೀ ಬಳಸಿ ಚಾಲೂ ಆಯಿತು.
ಮಾರುತಿ ವಾಹನ ನಿಂತಿದೆ.
--------------------
ಹೋಂಡಾ ಬೈಕ್ ಕಿಕ್ ಸ್ಟಾರ್ಟ್‌ನಿಂದ ಚಾಲೂ ಆಯಿತು.
ಹೋಂಡಾ ವಾಹನ ನಿಂತಿದೆ.

ಪ್ರಮುಖ ಅಂಶಗಳು

ಕಡ್ಡಾಯ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್: Vehicle ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗುವ ಯಾವುದೇ ಕ್ಲಾಸ್ (ಉದಾ: Car, Bike) start() ಮೆಥಡ್ ಅನ್ನು ಕಡ್ಡಾಯವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಪೈಥಾನ್ TypeError ಅನ್ನು ನೀಡುತ್ತದೆ.

ಉದಾಹರಣೆ (ದೋಷ):
```
class Scooter(Vehicle):
    def ride(self):
        print("ಸ್ಕೂಟರ್ ಚಲಿಸುತ್ತಿದೆ.")

# try:
#     s = Scooter("TVS")
# except TypeError as e:
#     print(f"ದೋಷ: {e}")
```
ಔಟ್‌ಪುಟ್:
```
ದೋಷ: Can't instantiate abstract class Scooter with abstract method start
```
ಇದರರ್ಥ, Scooter ಕ್ಲಾಸ್ start ಎಂಬ ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದರ ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಇಂಟರ್ಫೇಸ್ ಆಗಿ ಬಳಕೆ: ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್‌ಗಳು ಒಂದು ರೀತಿಯ "ಒಪ್ಪಂದ" ಅಥವಾ "ಇಂಟರ್ಫೇಸ್" ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಅವು ಸಬ್‌ಕ್ಲಾಸ್‌ಗಳು ಯಾವ ಮೆಥಡ್‌ಗಳನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ.

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ ಮತ್ತು ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸ

ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ (Abstraction)	ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ (Encapsulation)
ಸಂಕೀರ್ಣತೆಯನ್ನು ಮರೆಮಾಡುವುದು ಇದರ ಮುಖ್ಯ ಉದ್ದೇಶ.	ಡೇಟಾವನ್ನು ಮರೆಮಾಡುವುದು (Data Hiding) ಇದರ ಮುಖ್ಯ ಉದ್ದೇಶ.
"ಏನು ಮಾಡುತ್ತದೆ" ಎಂಬುದರ ಮೇಲೆ ಗಮನ ಹರಿಸುತ್ತದೆ.	"ಹೇಗೆ ಮಾಡುತ್ತದೆ" ಎಂಬುದರ ವಿವರಗಳನ್ನು ಮರೆಮಾಡುತ್ತದೆ.
ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ.	ಪ್ರೈವೇಟ್ ಮತ್ತು ಪ್ರೊಟೆಕ್ಟೆಡ್ ಅಟ್ರಿಬ್ಯೂಟ್‌ಗಳ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ.
ವಿನ್ಯಾಸದ ಹಂತದಲ್ಲಿ (design level) ಇದನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ.	ಕಾರ್ಯಗತಗೊಳಿಸುವ ಹಂತದಲ್ಲಿ (implementation level) ಇದನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ.

ಸಾರಾಂಶದಲ್ಲಿ, ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ ನಮಗೆ ಒಂದು ಸ್ಪಷ್ಟವಾದ ಮತ್ತು ಸರಳವಾದ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಆದರೆ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಆ ಇಂಟರ್ಫೇಸ್‌ನ ಹಿಂದಿನ ಡೇಟಾ ಮತ್ತು ಲಾಜಿಕ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿರಿಸುತ್ತದೆ.