OOP ನಲ್ಲಿ ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ (Abstraction): ಸಂಕೀರ್ಣತೆಯನ್ನು ಮರೆಮಾಚುವುದು
ನೀವು ಕೆಲವು ಸರಳ ಕ್ರಮಗಳ ಮೂಲಕ ಕಾರನ್ನು ಚಲಾಯಿಸುತ್ತೀರಿ. ನೀವು ಗ್ಯಾಸ್ ಪೆಡಲ್ ಒತ್ತುತ್ತೀರಿ. ಸ್ಟೀರಿಂಗ್ ಅನ್ನು ತಿರುಗಿಸುತ್ತೀರಿ. ಬ್ರೇಕ್ ಒತ್ತುತ್ತೀರಿ.
ಇಂಜಿನ್ಗೆ ಇಂಧನ ಹೇಗೆ ಸೇರುತ್ತದೆ ಎಂಬುದು ನಿಮಗೆ ತಿಳಿಯಬೇಕಾಗಿಲ್ಲ. ಪಿಸ್ಟನ್ಗಳು ಹೇಗೆ ಚಲಿಸುತ್ತವೆ ಅಥವಾ ಗೇರ್ಗಳು ಹೇಗೆ ಬದಲಾಗುತ್ತವೆ ಎಂಬುದು ನಿಮಗೆ ಅರ್ಥವಾಗಬೇಕಾಗಿಲ್ಲ. ಕಾರು ಆ ವಿವರಗಳನ್ನು ನಿಮ್ಮಿಂದ ಮರೆಮಾಚುತ್ತದೆ. ನೀವು ಒಂದು ಸಂಕೀರ್ಣ ಯಂತ್ರವನ್ನು ನಿಯಂತ್ರಿಸಲು ಸರಳವಾದ ಇಂಟರ್ಫೇಸ್ (interface) ಅನ್ನು ಬಳಸುತ್ತೀರಿ.
ಸಾಫ್ಟ್ವೇರ್ ಕೂಡ ಇದೇ ರೀತಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ.
ಇಮೇಲ್ ಕಳುಹಿಸುವುದನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳಿ. ನೀವು ಕೇವಲ ಒಂದು ಕಮಾಂಡ್ ಅನ್ನು ಕರೆಯುತ್ತೀರಿ: emailService.send().
ಹಿನ್ನೆಲೆಯಲ್ಲಿ, ಅನೇಕ ವಿಷಯಗಳು ನಡೆಯುತ್ತವೆ:
- ಸಿಸ್ಟಮ್ ವಿಳಾಸವನ್ನು (address) ಪರಿಶೀಲಿಸುತ್ತದೆ.
- ಇದು SMTP ಸಂಪರ್ಕವನ್ನು (connection) ಸೃಷ್ಟಿಸುತ್ತದೆ.
- ಇದು ಪ್ರೊವೈಡರ್ನೊಂದಿಗೆ ದೃಢೀಕರಣವನ್ನು (authentication) ಮಾಡುತ್ತದೆ.
- ಇದು ಸಂದೇಶವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ.
- ಮೊದಲ ಪ್ರಯತ್ನ ವಿಫಲವಾದರೆ, ಇದು ಮರುಪ್ರಯತ್ನಗಳನ್ನು (retries) ನಿರ್ವಹಿಸುತ್ತದೆ.
ನೀವು ಈ ಹಂತಗಳನ್ನು ನೋಡಬೇಕಾಗಿಲ್ಲ. ಇಮೇಲ್ ಕಳುಹಿಸಲ್ಪಟ್ಟಿತು ಎಂಬುದು ಮಾತ್ರ ನಿಮಗೆ ಮುಖ್ಯ.
ನೀವು ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಬಳಸದಿದ್ದರೆ, ನಿಮ್ಮ ಕೋಡ್ ಹೀಗೆ ಕಾಣುತ್ತಿತ್ತು:
- connect()
- authenticate()
- buildMessage()
- sendMessage()
- disconnect()
ಪ್ರತಿ ಬಾರಿಯೂ ಹೀಗೆ ಮಾಡುವುದು ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ನ ಪ್ರತಿಯೊಂದು ಭಾಗವೂ ಅತಿಯಾದ ವಿವರಗಳನ್ನು ತಿಳಿದಿರುತ್ತದೆ. ನೀವು ನಿಮ್ಮ ಇಮೇಲ್ ಪ್ರೊವೈಡರ್ ಅನ್ನು ಬದಲಾಯಿಸಿದರೆ, ಇಮೇಲ್ ಕಳುಹಿಸುವ ಪ್ರತಿಯೊಂದು ಸಾಲಿನ ಕೋಡ್ ಅನ್ನು ನೀವು ಅಪ್ಡೇಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದರಿಂದ ನಿಮ್ಮ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು ಕಷ್ಟವಾಗುತ್ತದೆ.
ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಇದು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ (object) ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ ಆದರೆ ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಮರೆಮಾಚುತ್ತದೆ.
ನೀವು ಒಂದು ಸರಳ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತೀರಿ. ಕರೆಯುವವರು (caller) ಕೇವಲ ಕೆಲಸದ ಮೇಲೆ ಗಮನ ಹರಿಸುತ್ತಾರೆ. ಅದರ ಅನುಷ್ಠಾನ (implementation) ಮರೆಮಾಚಲ್ಪಟ್ಟಿರುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಡಿಕಪಲ್ಡ್ (decoupled) ಆಗಿ ಮತ್ತು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸುವಂತೆ (maintain) ಮಾಡುತ್ತದೆ.
ಜನರು ಹೆಚ್ಚಾಗಿ ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಮತ್ತು ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ (Encapsulation) ನಡುವೆ ಗೊಂದಲಕ್ಕೀಡಾಗುತ್ತಾರೆ.
ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಕೇಳುತ್ತದೆ: ಈ ಡೇಟಾವನ್ನು ಯಾರು ಬದಲಾಯಿಸಬಹುದು? ಇದು ಆಂತರಿಕ ಸ್ಥಿತಿಯನ್ನು (internal state) ರಕ್ಷಿಸುತ್ತದೆ. ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಕೇಳುತ್ತದೆ: ಬಳಕೆದಾರರು ಯಾವ ವಿವರಗಳನ್ನು ನೋಡಬೇಕಿದೆ? ಇದು ಸಂಕೀರ್ಣತೆಯನ್ನು ಮರೆಮಾಚುತ್ತದೆ.
ಉತ್ತಮ ಸಿಸ್ಟಮ್ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇವೆರಡೂ ಒಟ್ಟಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ.
ಮುಂದೆ, ನಾವು ಇನ್ಹೆರಿಟನ್ಸ್ (Inheritance) ಬಗ್ಗೆ ನೋಡೋಣ. ನಾವು ಒಂದು ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸುತ್ತೇವೆ: ಆಬ್ಜೆಕ್ಟ್ಗಳು ಒಂದೇ ರೀತಿಯ ವರ್ತನೆಯನ್ನು ಹಂಚಿಕೊಂಡರೆ, ನೀವು ಒಂದೇ ಕೋಡ್ ಅನ್ನು ಎರಡು ಬಾರಿ ಬರೆಯಬೇಕಾಗುತ್ತದೆಯೇ?