ಪೈಥಾನ್ OOP: ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಮತ್ತು ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್
1. ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ (Encapsulation) ಎಂದರೇನು?
ಉತ್ತರ: ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಎನ್ನುವುದು ಡೇಟಾ (ಅಟ್ರಿಬ್ಯೂಟ್ಸ್) ಮತ್ತು ಆ ಡೇಟಾದ ಮೇಲೆ ಕೆಲಸ ಮಾಡುವ ಮೆಥಡ್ಗಳನ್ನು ಒಂದೇ ಯೂನಿಟ್ (ಕ್ಲಾಸ್) ಆಗಿ ಕಟ್ಟುವುದು. ಇದು ಡೇಟಾವನ್ನು ಹೊರಗಿನ ಪ್ರಪಂಚದಿಂದ ಮರೆಮಾಚಲು (data hiding) ಮತ್ತು ನೇರ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಡೇಟಾವನ್ನು ಪಬ್ಲಿಕ್ ಮೆಥಡ್ಗಳ (ಗೆಟರ್ಸ್ ಮತ್ತು ಸೆಟರ್ಸ್) ಮೂಲಕ ಮಾತ್ರ ಆಕ್ಸೆಸ್ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಉಪಯೋಗ:
- ಡೇಟಾದ ಸುರಕ್ಷತೆ ಮತ್ತು ಸಮಗ್ರತೆಯನ್ನು ಕಾಪಾಡುತ್ತದೆ.
- ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಘಟಿತವಾಗಿ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
2. ಪೈಥಾನ್ನಲ್ಲಿ ಪ್ರೈವೇಟ್ (Private) ಅಟ್ರಿಬ್ಯೂಟ್ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು?
ಉತ್ತರ:
ಪೈಥಾನ್ನಲ್ಲಿ "ನಿಜವಾದ" ಪ್ರೈವೇಟ್ ಅಟ್ರಿಬ್ಯೂಟ್ಗಳಿಲ್ಲ (C++ ಅಥವಾ Java ದಂತೆ). ಆದರೆ, ಒಂದು ಅಟ್ರಿಬ್ಯೂಟ್ನ ಹೆಸರಿನ ಮುಂದೆ ಎರಡು
ಅಂಡರ್ಸ್ಕೋರ್ (__) ಬಳಸುವ ಮೂಲಕ ಅದನ್ನು ಪ್ರೈವೇಟ್ ಎಂದು ಸೂಚಿಸಬಹುದು. ಇದನ್ನು "ನೇಮ್ ಮ್ಯಾಂಗ್ಲಿಂಗ್" (name mangling) ಎನ್ನುತ್ತಾರೆ.
ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಈ ಹೆಸರನ್ನು _ClassName__attributeName ಎಂದು ಬದಲಾಯಿಸುತ್ತದೆ, ಇದರಿಂದ ನೇರವಾಗಿ ಆಕ್ಸೆಸ್ ಮಾಡುವುದು
ಕಷ್ಟವಾಗುತ್ತದೆ.
ಉದಾಹರಣೆ:
class BankAccount:
def __init__(self, balance):
self.__balance = balance # ಪ್ರೈವೇಟ್ ಅಟ್ರಿಬ್ಯೂಟ್
def get_balance(self):
return self.__balance
acc = BankAccount(1000)
# print(acc.__balance) # AttributeError ನೀಡುತ್ತದೆ
print(acc.get_balance()) # 1000
print(acc._BankAccount__balance) # ಹೀಗೆ ಆಕ್ಸೆಸ್ ಮಾಡಬಹುದು, ಆದರೆ ಇದು ಉತ್ತಮ ಅಭ್ಯಾಸವಲ್ಲ
3. ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ (Abstraction) ಎಂದರೇನು?
ಉತ್ತರ: ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಎನ್ನುವುದು ಕಾಂಪ್ಲೆಕ್ಸ್ ಸಿಸ್ಟಮ್ನ ಅನಗತ್ಯ ವಿವರಗಳನ್ನು ಮರೆಮಾಚಿ, ಕೇವಲ ಅಗತ್ಯವಿರುವ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಮಾತ್ರ ಬಳಕೆದಾರರಿಗೆ ತೋರಿಸುವುದು. ಇದು "ಏನು ಮಾಡುತ್ತದೆ" ಎಂಬುದರ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತದೆ, "ಹೇಗೆ ಮಾಡುತ್ತದೆ" ಎಂಬುದರ ಮೇಲಲ್ಲ.
ಉದಾಹರಣೆ: ನಾವು ಕಾರು ಚಲಾಯಿಸುವಾಗ, ನಮಗೆ ಸ್ಟೀರಿಂಗ್, ಗೇರ್, ಮತ್ತು ಬ್ರೇಕ್ಗಳ ಬಗ್ಗೆ ಮಾತ್ರ ತಿಳಿದಿದ್ದರೆ ಸಾಕು. ಇಂಜಿನ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬ ಆಂತರಿಕ ವಿವರಗಳು ನಮಗೆ ಅಗತ್ಯವಿಲ್ಲ. ಇಲ್ಲಿ, ಕಾರು ಒಂದು ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್.
ಪೈಥಾನ್ನಲ್ಲಿ, ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಅನ್ನು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್ಗಳು (Abstract Classes) ಮತ್ತು ಮೆಥಡ್ಗಳ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ.
4. ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್ (Abstract Class) ಮತ್ತು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ (Abstract Method) ಎಂದರೇನು?
ಉತ್ತರ:
-
ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್:
- ಇದು ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ಗಳನ್ನು ಹೊಂದಿರುವ ಕ್ಲಾಸ್.
- ಇದರ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ನೇರವಾಗಿ ರಚಿಸಲಾಗುವುದಿಲ್ಲ.
- ಇದನ್ನು ಬೇರೆ ಕ್ಲಾಸ್ಗಳಿಗೆ ಒಂದು ಬ್ಲೂಪ್ರಿಂಟ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ.
-
ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್:
- ಇದು ಡಿಕ್ಲೇರ್ ಆಗಿರುತ್ತದೆ ಆದರೆ ಯಾವುದೇ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ (ಕೋಡ್) ಹೊಂದಿರುವುದಿಲ್ಲ.
- ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡುವ ಯಾವುದೇ ಚೈಲ್ಡ್ ಕ್ಲಾಸ್, ಎಲ್ಲಾ ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ಗಳನ್ನು ಕಡ್ಡಾಯವಾಗಿ ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಬೇಕು.
ಪೈಥಾನ್ನಲ್ಲಿ, abc (Abstract Base Classes) ಮಾಡ್ಯೂಲ್ ಬಳಸಿ ಇದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ.
ಉದಾಹರಣೆ:
from abc import ABC, abstractmethod
class Shape(ABC): # ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್
@abstractmethod
def area(self): # ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್
pass
class Square(Shape):
def __init__(self, side):
self.side = side
def area(self): # ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮೆಥಡ್ ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಲಾಗಿದೆ
return self.side * self.side
# s = Shape() # TypeError: Can't instantiate abstract class
sq = Square(5)
print(sq.area()) # 25
5. ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಮತ್ತು ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?
ಉತ್ತರ:
| ಲಕ್ಷಣ | ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ | ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ |
|---|---|---|
| ಉದ್ದೇಶ | ಡೇಟಾ ಮತ್ತು ಮೆಥಡ್ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಕಟ್ಟುವುದು (Data Hiding). | ಅನಗತ್ಯ ವಿವರಗಳನ್ನು ಮರೆಮಾಚುವುದು (Implementation |
| Hiding). | ||
| ಗಮನ | "ಹೇಗೆ" ಎಂಬುದರ ಮೇಲೆ (ಆಂತರಿಕ ರಚನೆ). | "ಏನು" ಎಂಬುದರ ಮೇಲೆ (ಬಾಹ್ಯ ಇಂಟರ್ಫೇಸ್). |
| ಸಾಧನೆ | ಪ್ರೈವೇಟ್ ಮೆಂಬರ್ಗಳು ಮತ್ತು ಪಬ್ಲಿಕ್ ಮೆಥಡ್ಗಳ ಮೂಲಕ. | ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಕ್ಲಾಸ್ಗಳು ಮತ್ತು ಇಂಟರ್ಫೇಸ್ಗಳ ಮೂಲಕ. |
| ಸಂಬಂಧ | ಇದು ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಅನ್ನು ಸಾಧಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. | ಇದು ವಿನ್ಯಾಸದ ಮೇಲೆ ಹೆಚ್ಚು ಗಮನಹರಿಸುತ್ತದೆ. |