ಆಗಾಗ್ಗೆ ನಾನು SOLID ತತ್ವಗಳ ಬಗ್ಗೆ ಕೇಳದ ಡೆವಲಪರ್‌ಗಳನ್ನು ಭೇಟಿಯಾಗುತ್ತೇನೆ (ನಾವು . — ಟ್ರಾನ್ಸ್. ಡೆವಲಪರ್ ತನ್ನ ದೈನಂದಿನ ಕೆಲಸದಲ್ಲಿ ಸಹಾಯ ಮಾಡುವ OOP ತತ್ವಗಳ ಪ್ರಯೋಜನಗಳನ್ನು ಈ ಲೇಖನವು ವಿವರಿಸುತ್ತದೆ. ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಚೆನ್ನಾಗಿ ತಿಳಿದಿವೆ, ಇತರರು ತುಂಬಾ ಅಲ್ಲ, ಆದ್ದರಿಂದ ಲೇಖನವು ಆರಂಭಿಕರಿಗಾಗಿ ಮತ್ತು ಅನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.
ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರಚಾರದ ಕೋಡ್ ಬಳಸಿ ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ನೋಂದಾಯಿಸುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.
ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಶೈಕ್ಷಣಿಕ ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ .
ಶುಷ್ಕ (ನಿಮ್ಮನ್ನು ಪುನರಾವರ್ತಿಸಬೇಡಿ)
ಸಾಕಷ್ಟು ಸರಳವಾದ ತತ್ವ, ಅದರ ಸಾರವು ಹೆಸರಿನಿಂದ ಸ್ಪಷ್ಟವಾಗಿದೆ: "ನೀವೇ ಪುನರಾವರ್ತಿಸಬೇಡಿ." ಪ್ರೋಗ್ರಾಮರ್ಗಾಗಿ, ಇದರರ್ಥ ನಕಲಿ ಕೋಡ್ ಅನ್ನು ತಪ್ಪಿಸುವ ಅಗತ್ಯತೆ, ಹಾಗೆಯೇ ಅವರ ಕೆಲಸದಲ್ಲಿ ಅಮೂರ್ತತೆಯನ್ನು ಬಳಸುವ ಅವಕಾಶ.
ಕೋಡ್‌ನಲ್ಲಿ ಎರಡು ಪುನರಾವರ್ತಿತ ವಿಭಾಗಗಳಿದ್ದರೆ, ಅವುಗಳನ್ನು ಒಂದು ವಿಧಾನದಲ್ಲಿ ಸಂಯೋಜಿಸಬೇಕು. ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಲಾದ ಮೌಲ್ಯವನ್ನು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಬಳಸಿದರೆ, ಅದನ್ನು ಸಾರ್ವಜನಿಕ ಸ್ಥಿರಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ.
ಕೋಡ್ ಅನ್ನು ಸರಳೀಕರಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗುವಂತೆ ಮಾಡಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ, ಇದು OOP ಯ ಮುಖ್ಯ ಗುರಿಯಾಗಿದೆ. ನೀವು ಯೂನಿಯನ್ ಅನ್ನು ಅತಿಯಾಗಿ ಬಳಸಬಾರದು, ಏಕೆಂದರೆ ಒಂದೇ ಕೋಡ್ ಆರ್ಡರ್ಐಡಿ ಮತ್ತು ಎಸ್ಎಸ್ಎನ್ ಎರಡರಲ್ಲೂ ಪರಿಶೀಲನೆಯನ್ನು ರವಾನಿಸುವುದಿಲ್ಲ.
ಎನ್ಕ್ಯಾಪ್ಸುಲೇಟಿಂಗ್ ಬದಲಾವಣೆಗಳು
ಹೆಚ್ಚಿನ ಕಂಪನಿಗಳ ಸಾಫ್ಟ್‌ವೇರ್ ಉತ್ಪನ್ನಗಳು ನಿರಂತರವಾಗಿ ವಿಕಸನಗೊಳ್ಳುತ್ತಿವೆ. ಇದರರ್ಥ ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ, ಅದನ್ನು ಬೆಂಬಲಿಸುವ ಅಗತ್ಯವಿದೆ. ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಜೀವನವನ್ನು ನೀವು ಸುಲಭಗೊಳಿಸಬಹುದು. ನಿಮ್ಮ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಬೇಸ್ ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. .
ನೀವು ಜಾವಾದಲ್ಲಿ ಬರೆದರೆ, ನಂತರ .
ತೆರೆದ/ಮುಚ್ಚಿದ ತತ್ವ
ಕೆಳಗಿನ ಹೇಳಿಕೆಯನ್ನು ಓದುವ ಮೂಲಕ ಈ ತತ್ವವನ್ನು ಸುಲಭವಾಗಿ ನೆನಪಿಸಿಕೊಳ್ಳಬಹುದು: "ಸಾಫ್ಟ್‌ವೇರ್ ಘಟಕಗಳು (ವರ್ಗಗಳು, ಮಾಡ್ಯೂಲ್‌ಗಳು, ಕಾರ್ಯಗಳು, ಇತ್ಯಾದಿ) ವಿಸ್ತರಣೆಗಾಗಿ ತೆರೆದಿರಬೇಕು, ಆದರೆ ಮಾರ್ಪಾಡುಗಾಗಿ ಮುಚ್ಚಿರಬೇಕು." ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಮೂಲ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸದೆಯೇ ಅವರು ತಮ್ಮ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಲು ಅನುಮತಿಸಬಹುದು ಎಂದರ್ಥ.
ಮೂಲ ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳು ಕೋಡ್ ಪರಿಷ್ಕರಣೆ, ಘಟಕ ಪರೀಕ್ಷೆ ಮತ್ತು ಇತರ ಕಾರ್ಯವಿಧಾನಗಳ ಅಗತ್ಯವಿರುವಾಗ ತತ್ವವು ಮುಖ್ಯವಾಗಿದೆ. ತೆರೆದ/ಮುಚ್ಚಿದ ತತ್ವವನ್ನು ಅನುಸರಿಸುವ ಕೋಡ್ ವಿಸ್ತರಿಸಿದಾಗ ಬದಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದರೊಂದಿಗೆ ಕಡಿಮೆ ಸಮಸ್ಯೆಗಳಿವೆ.
ಈ ತತ್ವವನ್ನು ಉಲ್ಲಂಘಿಸುವ ಕೋಡ್ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ.
ನೀವು ಅದರಲ್ಲಿ ಏನನ್ನಾದರೂ ಬದಲಾಯಿಸಬೇಕಾದರೆ, ಇದು ಸಾಕಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಏಕೆಂದರೆ ಬಯಸಿದ ತುಣುಕಿನೊಂದಿಗೆ ಸಂಪರ್ಕವನ್ನು ಹೊಂದಿರುವ ಕೋಡ್ನ ಎಲ್ಲಾ ವಿಭಾಗಗಳನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ.
ಮೂಲಕ, ಮುಕ್ತತೆ-ಮುಚ್ಚುವಿಕೆ SOLID ನ ತತ್ವಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.
ಏಕ ಹೊಣೆಗಾರಿಕೆ ತತ್ವ (SRP)
SOLID ಸೆಟ್‌ನಿಂದ ಮತ್ತೊಂದು ತತ್ವ. "ವರ್ಗದಲ್ಲಿ ಬದಲಾವಣೆಯನ್ನು ಉಂಟುಮಾಡುವ ಒಂದು ಕಾರಣವಿದೆ" ಎಂದು ಅದು ಹೇಳುತ್ತದೆ. ವರ್ಗವು ಕೇವಲ ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಇದು ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಆದರೆ ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ. ಎಲ್ಲಾ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳು ಇದನ್ನು ಮಾತ್ರ ಪೂರೈಸಬೇಕು.
ಈ ತತ್ವದ ಮೌಲ್ಯವೆಂದರೆ ಅದು ಪ್ರತ್ಯೇಕ ಸಾಫ್ಟ್‌ವೇರ್ ಘಟಕ ಮತ್ತು ಕೋಡ್ ನಡುವಿನ ಜೋಡಣೆಯನ್ನು ಸಡಿಲಗೊಳಿಸುತ್ತದೆ. ನೀವು ವರ್ಗಕ್ಕೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಕಾರ್ಯಗಳನ್ನು ಸೇರಿಸಿದರೆ, ಅದು ಎರಡು ಕಾರ್ಯಗಳ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ನೀವು ಅವುಗಳಲ್ಲಿ ಒಂದನ್ನು ಬದಲಾಯಿಸಿದರೆ, ಎರಡನೆಯದನ್ನು ಹಾಳುಮಾಡುವ ಹೆಚ್ಚಿನ ಅವಕಾಶವಿದೆ, ಅದು ಮೊದಲನೆಯದಕ್ಕೆ ಸಂಪರ್ಕ ಹೊಂದಿದೆ. ಮತ್ತು ಇದರರ್ಥ ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳನ್ನು ಮುಂಚಿತವಾಗಿ ಗುರುತಿಸಲು ಪರೀಕ್ಷಾ ಚಕ್ರಗಳನ್ನು ಹೆಚ್ಚಿಸುವುದು.
ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವ (ಡಿಐಪಿ)
ಆಪ್‌ಮ್ಯಾನೇಜರ್ EventLogWriter ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ಮೇಲೆ ನೀಡಲಾಗಿದೆ, ಇದು ಆಪ್‌ಮ್ಯಾನೇಜರ್‌ನೊಂದಿಗೆ ನಿಕಟವಾಗಿ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಿದೆ. ಅಧಿಸೂಚನೆಯನ್ನು ತೋರಿಸಲು ನಿಮಗೆ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಅಗತ್ಯವಿದ್ದರೆ, ಅದು ಪುಶ್, SMS ಅಥವಾ ಇಮೇಲ್ ಆಗಿರಬಹುದು, ನೀವು AppManager ವರ್ಗವನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ.
ಡಿಐಪಿ ಬಳಸಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬಹುದು. ಆದ್ದರಿಂದ, AppManager ಬದಲಿಗೆ, ನಾವು EventLogWriter ಅನ್ನು ವಿನಂತಿಸುತ್ತೇವೆ, ಅದನ್ನು ಫ್ರೇಮ್‌ವರ್ಕ್ ಬಳಸಿ ನಮೂದಿಸಲಾಗುತ್ತದೆ.
ಅವಲಂಬನೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಪ್ರತ್ಯೇಕ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಇತರರೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಬದಲಾಯಿಸಲು DIP ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಇದು ಒಂದು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇತರರ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದಂತೆ ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.
ಆನುವಂಶಿಕತೆಯ ಬದಲಿಗೆ ಸಂಯೋಜನೆ
ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ಎರಡು ಮುಖ್ಯ ಮಾರ್ಗಗಳಿವೆ: ಆನುವಂಶಿಕತೆ ಮತ್ತು ಸಂಯೋಜನೆ, ಇವೆರಡೂ ತಮ್ಮದೇ ಆದ ಅನುಕೂಲಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳನ್ನು ಹೊಂದಿವೆ. ಸಾಮಾನ್ಯವಾಗಿ ಎರಡನೆಯದನ್ನು ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.
ಸಂಯೋಜನೆಯು ಅದರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ರನ್ಟೈಮ್ನಲ್ಲಿ ವರ್ಗದ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ. ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ಪಾಲಿಮಾರ್ಫಿಸಮ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಅನುಷ್ಠಾನವನ್ನು ನೀಡುತ್ತದೆ.
ಜೋಶುವಾ ಬ್ಲೋಚ್ ಅವರ ಪರಿಣಾಮಕಾರಿ ಜಾವಾ ಸಹ ಪರಂಪರೆಯ ಮೇಲೆ ಸಂಯೋಜನೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಲಹೆ ನೀಡುತ್ತದೆ.
ಬಾರ್ಬರಾ ಲಿಸ್ಕೋವ್ ಪರ್ಯಾಯ ತತ್ವ (LSP)
SOLID ಟೂಲ್‌ಕಿಟ್‌ನಿಂದ ಮತ್ತೊಂದು ತತ್ವ. ಸೂಪರ್ಟೈಪ್ಗೆ ಉಪವಿಧಗಳು ಪರ್ಯಾಯವಾಗಿರಬೇಕು ಎಂದು ಅದು ಹೇಳುತ್ತದೆ. ಅಂದರೆ, ಸೂಪರ್ಕ್ಲಾಸ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ವಿಧಾನಗಳು ಮತ್ತು ಕಾರ್ಯಗಳು ಅದರ ಉಪವರ್ಗಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
LSP ಏಕ ಜವಾಬ್ದಾರಿ ತತ್ವ ಮತ್ತು ಹಂಚಿಕೆಯ ಜವಾಬ್ದಾರಿ ತತ್ವ ಎರಡಕ್ಕೂ ಸಂಬಂಧಿಸಿದೆ. ಒಂದು ವರ್ಗವು ಉಪವರ್ಗಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಕಾರ್ಯವನ್ನು ಒದಗಿಸಿದರೆ, ಎರಡನೆಯದು ಈ ತತ್ವವನ್ನು ಉಲ್ಲಂಘಿಸುವ ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.
LSP ಯನ್ನು ವಿರೋಧಿಸುವ ಕೋಡ್ನ ತುಣುಕು ಇಲ್ಲಿದೆ.
ಪ್ರದೇಶ (ಆಯತ r) ವಿಧಾನವು ಆಯತದ ಪ್ರದೇಶವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಸ್ಕ್ವೇರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ ಏಕೆಂದರೆ ಸ್ಕ್ವೇರ್ ಇಲ್ಲಿ ಆಯತವಾಗಿಲ್ಲ. LSP ತತ್ವದ ಪ್ರಕಾರ, ಮೂಲ ವರ್ಗಗಳಿಗೆ ಉಲ್ಲೇಖಗಳನ್ನು ಬಳಸುವ ಕಾರ್ಯಗಳು ಹೆಚ್ಚುವರಿ ಸೂಚನೆಗಳಿಲ್ಲದೆ ಪಡೆದ ವರ್ಗಗಳ ವಸ್ತುಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ಉಪಪ್ರಕಾರದ ನಿರ್ದಿಷ್ಟ ವ್ಯಾಖ್ಯಾನವಾಗಿರುವ ಈ ತತ್ವವನ್ನು ಬಾರ್ಬರಾ ಲಿಸ್ಕೋವ್ ಅವರು 1987 ರ ಸಮ್ಮೇಳನದ ಮುಖ್ಯ ಭಾಷಣದಲ್ಲಿ "ಡೇಟಾ ಅಮೂರ್ತತೆ ಮತ್ತು ಶ್ರೇಣಿ ವ್ಯವಸ್ಥೆ" ಎಂಬ ಶೀರ್ಷಿಕೆಯಲ್ಲಿ ಪ್ರಸ್ತಾಪಿಸಿದರು.
ಇಂಟರ್ಫೇಸ್ ಸ್ಪ್ಲಿಟ್ ಪ್ರಿನ್ಸಿಪಲ್ (ISP)
ಮತ್ತೊಂದು ಘನ ತತ್ವ. ಅದರ ಪ್ರಕಾರ, ಬಳಸದ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಾರದು. ಈ ತತ್ವವನ್ನು ಅನುಸರಿಸುವುದರಿಂದ ಆಪರೇಟಿಂಗ್ ಲಾಜಿಕ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿದಾಗ ಸಿಸ್ಟಮ್ ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಸೂಕ್ತವಾಗಿದೆ.
ಹೆಚ್ಚಾಗಿ, ಇಂಟರ್ಫೇಸ್ ಹಲವಾರು ಕಾರ್ಯಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಒಳಗೊಂಡಿರುವಾಗ ಈ ಪರಿಸ್ಥಿತಿಯು ಸಂಭವಿಸುತ್ತದೆ ಮತ್ತು ಕ್ಲೈಂಟ್ಗೆ ಅವುಗಳಲ್ಲಿ ಒಂದನ್ನು ಮಾತ್ರ ಅಗತ್ಯವಿದೆ.
ಇಂಟರ್ಫೇಸ್ ಬರೆಯುವುದು ಕಷ್ಟದ ಕೆಲಸವಾಗಿರುವುದರಿಂದ, ಕೆಲಸ ಮುಗಿದ ನಂತರ ಯಾವುದನ್ನೂ ಮುರಿಯದೆ ಬದಲಾಯಿಸುವುದು ಒಂದು ಸವಾಲಾಗಿದೆ.
ಜಾವಾದಲ್ಲಿನ ISP ತತ್ವದ ಪ್ರಯೋಜನವೆಂದರೆ ಎಲ್ಲಾ ವಿಧಾನಗಳನ್ನು ಮೊದಲು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು, ಮತ್ತು ನಂತರ ಮಾತ್ರ ಅವುಗಳನ್ನು ವರ್ಗಗಳಿಂದ ಬಳಸಬಹುದು. ಆದ್ದರಿಂದ, ತತ್ವವು ವಿಧಾನಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.
ಇಂಟರ್ಫೇಸ್ಗಾಗಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್, ಅನುಷ್ಠಾನವಲ್ಲ
ಇಲ್ಲಿ ಎಲ್ಲವೂ ಶೀರ್ಷಿಕೆಯಿಂದ ಸ್ಪಷ್ಟವಾಗಿದೆ. ಈ ತತ್ವವನ್ನು ಅನ್ವಯಿಸುವುದರಿಂದ ಇಂಟರ್ಫೇಸ್ನ ಯಾವುದೇ ಹೊಸ ಅನುಷ್ಠಾನದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಹುದಾದ ಹೊಂದಿಕೊಳ್ಳುವ ಕೋಡ್ನ ರಚನೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ವೇರಿಯೇಬಲ್‌ಗಳು, ರಿಟರ್ನ್ ಪ್ರಕಾರಗಳು ಅಥವಾ ವಿಧಾನ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪ್ರಕಾರಕ್ಕಾಗಿ ನೀವು ಇಂಟರ್ಫೇಸ್ ಪ್ರಕಾರವನ್ನು ಬಳಸಬೇಕು. ಉಪವರ್ಗದ ಬದಲಿಗೆ ಸೂಪರ್‌ಕ್ಲಾಸ್ ಅನ್ನು ಬಳಸುವುದು ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
ಅದು:
ಪಟ್ಟಿ ಸಂಖ್ಯೆಗಳು= getNumbers();
ಆದರೆ ಅಲ್ಲ:
ಅರೇಲಿಸ್ಟ್ ಸಂಖ್ಯೆಗಳು = getNumbers();
ಮೇಲೆ ಚರ್ಚಿಸಿದ ಪ್ರಾಯೋಗಿಕ ಅನುಷ್ಠಾನ ಇಲ್ಲಿದೆ.
ನಿಯೋಗದ ತತ್ವ
ಒಂದು ಸಾಮಾನ್ಯ ಉದಾಹರಣೆಯೆಂದರೆ ಜಾವಾದಲ್ಲಿ ಸಮಾನ () ಮತ್ತು ಹ್ಯಾಶ್‌ಕೋಡ್ () ವಿಧಾನಗಳು. ಎರಡು ವಸ್ತುಗಳನ್ನು ಹೋಲಿಸಲು ಅಗತ್ಯವಾದಾಗ, ಈ ಕ್ರಿಯೆಯನ್ನು ಕ್ಲೈಂಟ್ ಒಂದಕ್ಕೆ ಬದಲಾಗಿ ಅನುಗುಣವಾದ ವರ್ಗಕ್ಕೆ ನಿಯೋಜಿಸಲಾಗುತ್ತದೆ.
ತತ್ವದ ಪ್ರಯೋಜನವೆಂದರೆ ಕೋಡ್ನ ಯಾವುದೇ ನಕಲು ಇಲ್ಲ ಮತ್ತು ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸುವುದು ತುಲನಾತ್ಮಕವಾಗಿ ಸರಳವಾಗಿದೆ. ಈವೆಂಟ್ ನಿಯೋಗಕ್ಕೂ ಇದು ಅನ್ವಯಿಸುತ್ತದೆ.
ಈ ಎಲ್ಲಾ ತತ್ವಗಳು ಹೆಚ್ಚಿನ ಒಗ್ಗಟ್ಟು ಮತ್ತು ಕಡಿಮೆ ಜೋಡಣೆಯೊಂದಿಗೆ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ, ಸುಂದರವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸಹಜವಾಗಿ, ಸಿದ್ಧಾಂತವು ಒಳ್ಳೆಯದು, ಆದರೆ ಡೆವಲಪರ್ ನಿಜವಾಗಿಯೂ ಸ್ವಾಧೀನಪಡಿಸಿಕೊಂಡ ಜ್ಞಾನವನ್ನು ಬಳಸಲು, ಅಭ್ಯಾಸದ ಅಗತ್ಯವಿದೆ. ನೀವು OOP ತತ್ವಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಂಡ ನಂತರ, ಸಾಮಾನ್ಯ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ವಿನ್ಯಾಸ ಮಾದರಿಗಳನ್ನು ಕಲಿಯುವುದು ನಿಮ್ಮ ಮುಂದಿನ ಹಂತವಾಗಿದೆ.
ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:
- ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ .
- ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ ಅನ್ನು ಅನ್ವಯಿಸಲಾಗಿದೆ .
- ಎರಡು ವರ್ಷಗಳ ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ .
ಮೂಲ: www.habr.com