𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻 𝗶𝗻 𝗢𝗢𝗣: 𝗛𝗶𝗱𝗶𝗻𝗴 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆
ನೀವು ಪೆಡಲ್ ಒತ್ತುವ ಮೂಲಕ ಮತ್ತು ಸ್ಟೀರಿಂಗ್ ಚಕ್ರವನ್ನು ತಿರುಗಿಸುವ ಮೂಲಕ ಕಾರನ್ನು ಚಲಾಯಿಸುತ್ತೀರಿ. ನಿಮಗೆ ಇಂಧನದ ಇಂಜೆಕ್ಷನ್ (fuel injection) ಅಥವಾ ಪಿಸ್ಟನ್ ಚಲನೆಯ ಬಗ್ಗೆ ತಿಳಿಯುವ ಅಗತ್ಯವಿಲ್ಲ. ಕಾರು ಈ ವಿವರಗಳನ್ನು ನಿಮ್ಮಿಂದ ಮರೆಮಾಚುತ್ತದೆ. ನೀವು ಕೇವಲ ಒಂದು ಸರಳವಾದ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸುತ್ತೀರಿ.
ಸಾಫ್ಟ್ವೇರ್ ಕೂಡ ಇದೇ ರೀತಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ.
ಇಮೇಲ್ ಕಳುಹಿಸುವುದನ್ನು ಯೋಚಿಸಿ. ನಿಮ್ಮ ಕೋಡ್ ಬಹುಶಃ ಹೀಗೆ ಇರುತ್ತದೆ:
emailService.send(email);
ಇದು ಸರಳವಾಗಿ ಕಾಣುತ್ತದೆ. ಆದರೆ ತೆರೆಯ ಮರೆಯಲ್ಲಿ, ಸಿಸ್ಟಮ್ ಅನೇಕ ಕಾರ್ಯಗಳನ್ನು ಮಾಡುತ್ತದೆ:
- ವಿಳಾಸವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ (Validates the address).
- SMTP ಸರ್ವರ್ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ.
- ಬಳಕೆದಾರರನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ (Authenticates the user).
- ಸಂದೇಶವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ.
- ಮರುಪ್ರಯತ್ನಗಳನ್ನು (retries) ನಿರ್ವಹಿಸುತ್ತದೆ.
- ದೋಷಗಳನ್ನು (errors) ಲಾಗ್ ಮಾಡುತ್ತದೆ.
ನೀವು ಈ ಹಂತಗಳನ್ನು ನೋಡುವ ಅಗತ್ಯವಿಲ್ಲ. ಇಮೇಲ್ ಕಳುಹಿಸಲ್ಪಟ್ಟಿತು ಎಂಬುದು ಮಾತ್ರ ನಿಮಗೆ ಮುಖ್ಯ.
ನೀವು ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನೂ ಬಹಿರಂಗಪಡಿಸಿದರೆ, ಸಮಸ್ಯೆಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತೀರಿ. ಪ್ರತಿಯೊಬ್ಬ ಡೆವಲಪರ್ ಕೂಡ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮ್ಯಾನುಯಲ್ ಆಗಿ ಕರೆಯಬೇಕಾದ ಪರಿಸ್ಥಿತಿಯನ್ನು ಊಹಿಸಿ:
connect()authenticate()buildMessage()sendMessage()disconnect()
ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ದುರ್ಬಲಗೊಳಿಸುತ್ತದೆ (fragile). ನೀವು ನಿಮ್ಮ ಇಮೇಲ್ ಪ್ರೊವೈಡರ್ ಅನ್ನು ಬದಲಾಯಿಸಿದರೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ನ ಪ್ರತಿಯೊಂದು ಕಡೆಯಲ್ಲೂ ಅದನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ನೊಂದಿಗೆ (implementation) ಅತಿಯಾಗಿ ಬೆಸೆದುಕೊಂಡಿರುತ್ತದೆ (tightly coupled).
Abstraction ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.
Abstraction ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಅದು ಅದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಮರೆಮಾಚುತ್ತದೆ. ಬಳಕೆದಾರರಿಗೆ ಅಗತ್ಯವಿರುವಿದ್ದನ್ನು ಮಾತ್ರ ನೀವು ತೋರಿಸುತ್ತೀರಿ.
ಬಳಕೆದಾರರು ಒಂದು ಸ್ಥಿರವಾದ ಇಂಟರ್ಫೇಸ್ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಾರೆ. ನಿಮ್ಮ ಅಥೆಂಟಿಕೇಶನ್ ಲಾಜಿಕ್ ಅಥವಾ ನಿಮ್ಮ ರಿಟ್ರೈ ಸ್ಟ್ರಾಟಜಿಯ ಬಗ್ಗೆ ಅವರಿಗೆ ಕಾಳಜಿ ಇರುವುದಿಲ್ಲ. ಆ ವಿವರಗಳು ಮರೆಮಾಚಲ್ಪಟ್ಟಿರುತ್ತವೆ.
ಅನೇಕ ಜನರು Abstraction ಮತ್ತು Encapsulation ನಡುವೆ ಗೊಂದಲಕ್ಕೊಳಗಾಗುತ್ತಾರೆ. ಅವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ಇಲ್ಲಿದೆ:
Encapsulation ಕೇಳುತ್ತದೆ: ಈ ಆಬ್ಜೆಕ್ಟ್ನ ಸ್ಥಿತಿಯನ್ನು (state) ಯಾರು ಬದಲಾಯಿಸಬಹುದು? ಇದು ಡೇಟಾವನ್ನು ರಕ್ಷಿಸುತ್ತದೆ.
Abstraction ಕೇಳುತ್ತದೆ: ಬಳಕೆದಾರರು ಯಾವ ವಿವರಗಳನ್ನು ನೋಡಬೇಕು? ಇದು ಸಂಕೀರ್ಣತೆಯನ್ನು ಮರೆಮಾಚುತ್ತದೆ.
ಉತ್ತಮ ಸಿಸ್ಟಮ್ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇವೆರಡೂ ಒಟ್ಟಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ.
ಮುಂದೆ, ನಾವು Inheritance ಬಗ್ಗೆ ಚರ್ಚಿಸೋಣ. ಒಂದೇ ಕೋಡ್ ಅನ್ನು ಎರಡು ಬಾರಿ ಬರೆಯದೆಯೇ ಹಂಚಿಕೆಯ ನಡವಳಿಕೆಯನ್ನು (shared behavior) ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ನೋಡೋಣ.