ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವವನ್ನು ಬಳಸಿಕೊಂಡು ಅಳವಡಿಸಲಾಗಿದೆ. ಅವಲಂಬನೆ ವಿಲೋಮ

ವಾಸ್ತವವಾಗಿ, ಎಲ್ಲಾ ತತ್ವಗಳು ಘನಬಲವಾಗಿ ಪರಸ್ಪರ ಸಂಪರ್ಕ ಹೊಂದಿದೆ ಮತ್ತು ಉತ್ತಮ ಗುಣಮಟ್ಟದ, ಸ್ಕೇಲೆಬಲ್ ಸಾಫ್ಟ್‌ವೇರ್ ರಚಿಸಲು ಸಹಾಯ ಮಾಡುವುದು ಅವರ ಮುಖ್ಯ ಗುರಿಯಾಗಿದೆ. ಆದರೆ ಕೊನೆಯ ತತ್ವ ಘನನಿಜವಾಗಿಯೂ ಅವರ ವಿರುದ್ಧ ನಿಂತಿದೆ. ಮೊದಲಿಗೆ, ಈ ತತ್ವದ ಸೂತ್ರೀಕರಣವನ್ನು ನೋಡೋಣ. ಆದ್ದರಿಂದ, ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವ (ಅವಲಂಬಿತ ವಿಲೋಮ ತತ್ವ - ಡಿಐಪಿ): "ಅಮೂರ್ತತೆಗಳ ಮೇಲೆ ಅವಲಂಬನೆ. ನಿರ್ದಿಷ್ಟವಾದ ಯಾವುದಕ್ಕೂ ಅವಲಂಬನೆ ಇಲ್ಲ.. ಕುಖ್ಯಾತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ತಜ್ಞ ರಾಬರ್ಟ್ ಮಾರ್ಟಿನ್ ಸಹ ತತ್ವವನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತಾರೆ ಡಿಐಪಿಮತ್ತು ಇತರ ತತ್ವಗಳನ್ನು ಅನುಸರಿಸುವ ಪರಿಣಾಮವಾಗಿ ಅದನ್ನು ಸರಳವಾಗಿ ಪ್ರಸ್ತುತಪಡಿಸುತ್ತದೆ ಘನ- ತೆರೆದ / ಮುಚ್ಚಿದ ತತ್ವ ಮತ್ತು ಲಿಸ್ಕೋವ್ ಪರ್ಯಾಯ ತತ್ವ. ಹೊಸ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ವರ್ಗವನ್ನು ಮಾರ್ಪಡಿಸಬಾರದು ಎಂದು ಮೊದಲನೆಯದು ಹೇಳುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳಿ, ಮತ್ತು ಎರಡನೆಯದು ಉತ್ತರಾಧಿಕಾರದೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂನ ಸರಿಯಾದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮುರಿಯದೆ ಕೆಲವು ಮೂಲ ಪ್ರಕಾರದ ಪಡೆದ ಪ್ರಕಾರಗಳ ಸುರಕ್ಷಿತ ಬಳಕೆಯನ್ನು ಊಹಿಸುತ್ತದೆ. ರಾಬರ್ಟ್ ಮಾರ್ಟಿನ್ ಮೂಲತಃ ಈ ತತ್ವವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ರೂಪಿಸಿದರು:

ಒಂದು). ಮೇಲ್ಮಟ್ಟದ ಮಾಡ್ಯೂಲ್‌ಗಳು ಕೆಳ ಹಂತದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರಬಾರದು. ಎರಡೂ ಹಂತಗಳಲ್ಲಿನ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅಮೂರ್ತತೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರಬೇಕು.

2) ಅಮೂರ್ತತೆಗಳು ವಿವರಗಳನ್ನು ಅವಲಂಬಿಸಿರಬಾರದು. ವಿವರಗಳು ಅಮೂರ್ತತೆಯನ್ನು ಅವಲಂಬಿಸಿರಬೇಕು.

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

ಸಾರ್ವಜನಿಕ ವರ್ಗದ ಬಾರ್ಡ್ (ಖಾಸಗಿ ಗಿಟಾರ್ ಗಿಟಾರ್; ಸಾರ್ವಜನಿಕ ಬಾರ್ಡ್ (ಗಿಟಾರ್ ಗಿಟಾರ್) (ಇದು.ಗಿಟಾರ್ = ಗಿಟಾರ್; ) ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಪ್ಲೇ() (ಗಿಟಾರ್.ಪ್ಲೇ(); ) )

ನಾವು ಈ ತರಗತಿಗೆ ಇತರ ಸಂಗೀತ ವಾದ್ಯಗಳಿಗೆ ಬೆಂಬಲವನ್ನು ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾವು ಹೇಗಾದರೂ ಈ ವರ್ಗವನ್ನು ಮಾರ್ಪಡಿಸಬೇಕಾಗುತ್ತದೆ. ಇದು ತತ್ವದ ಸ್ಪಷ್ಟ ಉಲ್ಲಂಘನೆಯಾಗಿದೆ OCP. ಮತ್ತು ಇವುಗಳು ಸಹ ತತ್ವದ ಉಲ್ಲಂಘನೆ ಎಂದು ನೀವು ಈಗಾಗಲೇ ಗಮನಿಸಿರಬಹುದು ಡಿಐಪಿ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ನಮ್ಮ ಅಮೂರ್ತತೆಯು ವಿವರಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ನಮ್ಮ ವರ್ಗದ ಮತ್ತಷ್ಟು ವಿಸ್ತರಣೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ, ಇದು ಒಳ್ಳೆಯದಲ್ಲ. ನಮ್ಮ ವರ್ಗವು ತತ್ವದ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಲು OCPನಾವು ವ್ಯವಸ್ಥೆಗೆ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಸೇರಿಸಿದ್ದೇವೆ ಉಪಕರಣ, ಇದು ಕೆಲವು ರೀತಿಯ ಸಂಗೀತ ವಾದ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ನಿರ್ದಿಷ್ಟ ತರಗತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸಿತು.

ಫೈಲ್ Instrument.java:

ಸಾರ್ವಜನಿಕ ಇಂಟರ್ಫೇಸ್ ಇನ್ಸ್ಟ್ರುಮೆಂಟ್ (ಶೂನ್ಯ ಪ್ಲೇ (); )

ಫೈಲ್ ಗಿಟಾರ್.ಜಾವಾ:

ಕ್ಲಾಸ್ ಗಿಟಾರ್ ಉಪಕರಣವನ್ನು ಅಳವಡಿಸುತ್ತದೆ( @ಓವರ್‌ರೈಡ್ ಪಬ್ಲಿಕ್ ನಿರರ್ಥಕ ಪ್ಲೇ() ( System.out.println("Play Guitar!"); )

ಫೈಲ್ ಲೂಟ್.ಜಾವಾ:

ಸಾರ್ವಜನಿಕ ವರ್ಗದ ಲೂಟ್ ಉಪಕರಣವನ್ನು ಅಳವಡಿಸುತ್ತದೆ( @Override public void play() ( System.out.println("Play Lute!"); )

ಅದರ ನಂತರ ನಾವು ತರಗತಿಯನ್ನು ಬದಲಾಯಿಸಿದ್ದೇವೆ ಬಾರ್ಡ್ಆದ್ದರಿಂದ, ಅಗತ್ಯವಿದ್ದಲ್ಲಿ, ನಮಗೆ ಅಗತ್ಯವಿರುವವುಗಳೊಂದಿಗೆ ನಾವು ಅನುಷ್ಠಾನಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಇದು ರಚಿಸಲಾದ ವ್ಯವಸ್ಥೆಗೆ ಹೆಚ್ಚುವರಿ ನಮ್ಯತೆಯನ್ನು ತರುತ್ತದೆ ಮತ್ತು ಅದರ ಒಗ್ಗಟ್ಟನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ (ಪರಸ್ಪರ ವರ್ಗದ ಅವಲಂಬನೆಗಳು).

ಸಾರ್ವಜನಿಕ ವರ್ಗ ಬಾರ್ಡ್ (ಖಾಸಗಿ ವಾದ್ಯ ಉಪಕರಣ; ಸಾರ್ವಜನಿಕ ಬಾರ್ಡ್() () ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಪ್ಲೇ () (ಇನ್ಸ್ಟ್ರುಮೆಂಟ್.ಪ್ಲೇ (); ) ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಸೆಟ್ ಇನ್ಸ್ಟ್ರುಮೆಂಟ್ (ಇನ್ಸ್ಟ್ರುಮೆಂಟ್ ಇನ್ಸ್ಟ್ರುಮೆಂಟ್) (ಇದು.ಇನ್ಸ್ಟ್ರುಮೆಂಟ್ = ಉಪಕರಣ; ) )

2 ಪ್ರತ್ಯುತ್ತರಗಳು

ಒಳ್ಳೆಯ ಅಂಶ - ವಿಲೋಮ ಪದವು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಆಶ್ಚರ್ಯಕರವಾಗಿದೆ (ಡಿಐಪಿ ಅನ್ವಯಿಸಿದ ನಂತರ , ಕೆಳ ಹಂತದ ಅವಲಂಬನೆ ಮಾಡ್ಯೂಲ್ ಮೇಲ್ನೋಟಕ್ಕೆ ಈಗ ಉನ್ನತ ಮಟ್ಟದ ಕಾಲರ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅವಲಂಬಿಸಿಲ್ಲ: ಕರೆ ಮಾಡುವವರು ಅಥವಾ ಅವಲಂಬಿತರು ಈಗ ಹೆಚ್ಚುವರಿ ಅಮೂರ್ತತೆಯ ಮೂಲಕ ಹೆಚ್ಚು ಸಡಿಲವಾಗಿ ಜೋಡಿಸಲ್ಪಟ್ಟಿದ್ದಾರೆ )

ನಾನು "ವಿಲೋಮ" ಪದವನ್ನು ಏಕೆ ಬಳಸುತ್ತಿದ್ದೇನೆ ಎಂದು ನೀವು ಕೇಳಬಹುದು. ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ರಚನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ವಿನ್ಯಾಸದಂತಹ ಹೆಚ್ಚು ಸಾಂಪ್ರದಾಯಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ವಿಧಾನಗಳು ಸಾಫ್ಟ್‌ವೇರ್ ರಚನೆಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಒಲವು ತೋರುತ್ತವೆ, ಇದರಲ್ಲಿ ಉನ್ನತ-ಮಟ್ಟದ ಮಾಡ್ಯೂಲ್‌ಗಳು ಕಡಿಮೆ-ಮಟ್ಟದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ ಮತ್ತು ಇದರಲ್ಲಿ ಅಮೂರ್ತತೆಗಳು ವಿವರಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ, ಈ ವಿಧಾನಗಳ ಒಂದು ಉದ್ದೇಶವೆಂದರೆ ಸಬ್‌ರುಟೀನ್‌ಗಳ ಕ್ರಮಾನುಗತವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು, ಅದು ಹೇಗೆ ಉನ್ನತ-ಮಟ್ಟದ ಮಾಡ್ಯೂಲ್‌ಗಳು ಕಡಿಮೆ-ಹಂತದ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಕರೆಗಳನ್ನು ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.... ಹೀಗಾಗಿ, ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಂನ ಅವಲಂಬನೆ ರಚನೆಯಾಗಿದೆ ಅವಲಂಬನೆ ರಚನೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ "ತಲೆಕೆಳಗಾದ", ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಂಪ್ರದಾಯಿಕ ಕಾರ್ಯವಿಧಾನದ ವಿಧಾನಗಳ ಫಲಿತಾಂಶವಾಗಿದೆ.

ಡಿಐಪಿಯಲ್ಲಿ ಅಂಕಲ್ ಬಾಬ್ ಅವರ ಕಾಗದವನ್ನು ಓದುವಾಗ ಗಮನಿಸಬೇಕಾದ ಒಂದು ಅಂಶವೆಂದರೆ C++ ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ಹೊಂದಿಲ್ಲ (ಮತ್ತು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, ಇಲ್ಲ) ಆದ್ದರಿಂದ C++ ನಲ್ಲಿ ಈ ಅಮೂರ್ತತೆಯನ್ನು ಸಾಧಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಅಮೂರ್ತ/ಶುದ್ಧ ವರ್ಚುವಲ್ ಬೇಸ್ ವರ್ಗದ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಜಾವಾದಲ್ಲಿ ಅಥವಾ C# ಸಂಯೋಜಕವನ್ನು ಸಡಿಲಗೊಳಿಸಲು ಅಮೂರ್ತತೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಅವಲಂಬನೆಯಿಂದ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಅಮೂರ್ತಗೊಳಿಸುವ ಮೂಲಕ ಮತ್ತು ಇಂಟರ್ಫೇಸ್ಗೆ ಉನ್ನತ ಮಟ್ಟದ ಮಾಡ್ಯೂಲ್(ಗಳನ್ನು) ಬಂಧಿಸುವ ಮೂಲಕ ಅನ್ಬೈಂಡ್ ಮಾಡುವುದು.

ತಿದ್ದುಕೇವಲ ಸ್ಪಷ್ಟಪಡಿಸಲು:

"ಕೆಲವು ಸ್ಥಳದಲ್ಲಿ ನಾನು ಇದನ್ನು ಅವಲಂಬನೆ ವಿಲೋಮ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ"

ವಿಲೋಮ:ಅವಲಂಬನೆ ನಿರ್ವಹಣೆಯನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ಕಂಟೇನರ್‌ಗೆ ತಿರುಗಿಸಿ (ಸ್ಪ್ರಿಂಗ್‌ನಂತೆ).

ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್:

ಕಾರ್ಖಾನೆಯ ಮಾದರಿಯನ್ನು ಬರೆಯುವ ಬದಲು, ವಸ್ತುವನ್ನು ನೇರವಾಗಿ ಕ್ಲೈಂಟ್ ವರ್ಗಕ್ಕೆ ಚುಚ್ಚುವುದು ಹೇಗೆ. ಆದ್ದರಿಂದ ಕ್ಲೈಂಟ್ ವರ್ಗವು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಡಿ ಮತ್ತು ನಾವು ಕ್ಲೈಂಟ್ ವರ್ಗಕ್ಕೆ ಕಾಂಕ್ರೀಟ್ ಪ್ರಕಾರವನ್ನು ಚುಚ್ಚಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಇದರೊಂದಿಗೆ, ಕ್ಲೈಂಟ್ ವರ್ಗವು ಹೊಸ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬೇಕಾಗಿಲ್ಲ ಮತ್ತು ಕಾಂಕ್ರೀಟ್ ವರ್ಗಗಳಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಟ್ಟಿದೆ.

ನಿಯಂತ್ರಣದ ವಿಲೋಮ (IoC) ಬಗ್ಗೆ ಏನು?

ಸಾಂಪ್ರದಾಯಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ, ವ್ಯವಹಾರ ತರ್ಕದ ಹರಿವನ್ನು ಪರಸ್ಪರ ಸ್ಥಿರವಾಗಿ ನಿಯೋಜಿಸಲಾದ ವಸ್ತುಗಳಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ನಿಯಂತ್ರಣದ ವಿಲೋಮದೊಂದಿಗೆ, ಹರಿವು ಆಬ್ಜೆಕ್ಟ್ ಗ್ರಾಫ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಅದು ಅಸೆಂಬ್ಲರ್‌ನಿಂದ ತ್ವರಿತಗೊಳಿಸಲ್ಪಟ್ಟಿದೆ ಮತ್ತು ಅಮೂರ್ತತೆಯ ಮೂಲಕ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವಸ್ತು ಸಂವಹನಗಳಿಂದ ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಬಂಡಲಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ, ಆದಾಗ್ಯೂ ಸೇವಾ ಲೊಕೇಟರ್ ಅನ್ನು ಬಳಸುವುದು ನಿಯಂತ್ರಣದ ವಿಲೋಮವನ್ನು ಒದಗಿಸುತ್ತದೆ ಎಂದು ಕೆಲವರು ವಾದಿಸುತ್ತಾರೆ.

ವಿನ್ಯಾಸ ಮಾರ್ಗದರ್ಶಿಯಾಗಿ ನಿಯಂತ್ರಣದ ವಿಲೋಮವು ಈ ಕೆಳಗಿನ ಉದ್ದೇಶಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ:

• ಅನುಷ್ಠಾನದಿಂದ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯದ ಮರಣದಂಡನೆಯ ಡಿಕೌಪ್ಲಿಂಗ್ ಇದೆ.
• ಪ್ರತಿಯೊಂದು ಮಾಡ್ಯೂಲ್ ಅದರ ಉದ್ದೇಶವನ್ನು ಕೇಂದ್ರೀಕರಿಸಬಹುದು.
• ಮಾಡ್ಯೂಲ್‌ಗಳು ಇತರ ವ್ಯವಸ್ಥೆಗಳು ಏನು ಮಾಡುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು ಯಾವುದೇ ಊಹೆಗಳನ್ನು ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ಅವುಗಳ ಒಪ್ಪಂದಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.
• ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸುವುದರಿಂದ ಇತರ ಮಾಡ್ಯೂಲ್‌ಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ನೋಡಿ.

ಕೊನೆಯ ನವೀಕರಣ: 03/11/2016

ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವ(ಡಿಪೆಂಡೆನ್ಸಿ ಇನ್ವರ್ಶನ್ ಪ್ರಿನ್ಸಿಪಲ್) ಅನ್ನು ಪರೀಕ್ಷಿಸಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ನವೀಕರಿಸಲು ಸುಲಭವಾದ ಸಡಿಲವಾಗಿ ಜೋಡಿಸಲಾದ ಘಟಕಗಳನ್ನು ರಚಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ತತ್ವವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ರೂಪಿಸಬಹುದು:

ಉನ್ನತ ಮಟ್ಟದ ಮಾಡ್ಯೂಲ್‌ಗಳು ಕೆಳ ಹಂತದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರಬಾರದು. ಎರಡೂ ಅಮೂರ್ತತೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರಬೇಕು.

ಅಮೂರ್ತತೆಗಳು ವಿವರಗಳನ್ನು ಅವಲಂಬಿಸಿರಬಾರದು. ವಿವರಗಳು ಅಮೂರ್ತತೆಯನ್ನು ಅವಲಂಬಿಸಿರಬೇಕು.

ತತ್ವವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

ತರಗತಿ ಪುಸ್ತಕ (ಸಾರ್ವಜನಿಕ ಸ್ಟ್ರಿಂಗ್ ಪಠ್ಯ (ಪಡೆಯಿರಿ; ಹೊಂದಿಸಿ;) ಸಾರ್ವಜನಿಕ ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್ ಪ್ರಿಂಟರ್ (ಪಡೆಯಿರಿ; ಹೊಂದಿಸಿ; ) ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಮುದ್ರಣ () ( ಪ್ರಿಂಟರ್.ಪ್ರಿಂಟ್ (ಪಠ್ಯ); ) ) ವರ್ಗ ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್ ( ಸಾರ್ವಜನಿಕ ಅನೂರ್ಜಿತ ಮುದ್ರಣ (ಸ್ಟ್ರಿಂಗ್ ಪಠ್ಯ) ( ಕನ್ಸೋಲ್. ರೈಟ್‌ಲೈನ್ (ಪಠ್ಯ);))

ಪುಸ್ತಕವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಪುಸ್ತಕ ವರ್ಗವು ಮುದ್ರಿಸಲು ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್ ವರ್ಗವನ್ನು ಬಳಸುತ್ತದೆ. ಈ ರೀತಿ ವ್ಯಾಖ್ಯಾನಿಸಿದಾಗ, ಪುಸ್ತಕದ ವರ್ಗವು ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್ ವರ್ಗವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಇದಲ್ಲದೆ, ConsolePrinter ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಮಾತ್ರ ಪುಸ್ತಕವನ್ನು ಮುದ್ರಿಸುವುದು ಸಾಧ್ಯ ಎಂದು ನಾವು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ. ಇತರ ಆಯ್ಕೆಗಳು, ಉದಾಹರಣೆಗೆ, ಪ್ರಿಂಟರ್‌ಗೆ ಔಟ್‌ಪುಟ್, ಫೈಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಅಥವಾ ಗ್ರಾಫಿಕಲ್ ಇಂಟರ್ಫೇಸ್‌ನ ಕೆಲವು ಅಂಶಗಳನ್ನು ಬಳಸುವುದು - ಈ ಸಂದರ್ಭದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಹೊರಗಿಡಲಾಗಿದೆ. ಪುಸ್ತಕ ಮುದ್ರಣದ ಅಮೂರ್ತತೆಯು ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್ ವರ್ಗದ ವಿವರಗಳಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿಲ್ಲ. ಇದೆಲ್ಲವೂ ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವದ ಉಲ್ಲಂಘನೆಯಾಗಿದೆ.

ಈಗ ನಾವು ಕಡಿಮೆ ಮಟ್ಟದ ಅನುಷ್ಠಾನದಿಂದ ಅಮೂರ್ತತೆಯನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಮೂಲಕ ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವಕ್ಕೆ ಅನುಗುಣವಾಗಿ ನಮ್ಮ ತರಗತಿಗಳನ್ನು ತರಲು ಪ್ರಯತ್ನಿಸೋಣ:

ಇಂಟರ್ಫೇಸ್ ಐಪ್ರಿಂಟರ್ (ಅನೂರ್ಜಿತ ಮುದ್ರಣ (ಸ್ಟ್ರಿಂಗ್ ಪಠ್ಯ); ) ವರ್ಗ ಪುಸ್ತಕ (ಸಾರ್ವಜನಿಕ ಸ್ಟ್ರಿಂಗ್ ಪಠ್ಯ (ಪಡೆಯಿರಿ; ಹೊಂದಿಸಿ; ) ಸಾರ್ವಜನಿಕ ಐಪ್ರಿಂಟರ್ ಪ್ರಿಂಟರ್ (ಪಡೆಯಿರಿ; ಹೊಂದಿಸಿ; ) ಸಾರ್ವಜನಿಕ ಪುಸ್ತಕ (ಐಪ್ರಿಂಟರ್ ಪ್ರಿಂಟರ್) (ಇದು. ಪ್ರಿಂಟರ್ = ಪ್ರಿಂಟರ್; ) ಸಾರ್ವಜನಿಕ ಅನೂರ್ಜಿತ ಮುದ್ರಣ( ) ( Printer.Print(Text); ) ವರ್ಗ ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್: IPrinter (ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಮುದ್ರಣ(ಸ್ಟ್ರಿಂಗ್ ಪಠ್ಯ) ( Console.WriteLine("Print to Console"); ) ) ವರ್ಗ HtmlPrinter: IPrinter (ಸಾರ್ವಜನಿಕ ಅನೂರ್ಜಿತ ಮುದ್ರಣ(ಸ್ಟ್ರಿಂಗ್ ಪಠ್ಯ) ( Console.WriteLine("html ಗೆ ಮುದ್ರಿಸು"); ) )

ಈಗ ಪುಸ್ತಕ ಮುದ್ರಣದ ಅಮೂರ್ತತೆಯನ್ನು ಕಾಂಕ್ರೀಟ್ ಅನುಷ್ಠಾನಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ. ಪರಿಣಾಮವಾಗಿ, ಪುಸ್ತಕ ವರ್ಗ ಮತ್ತು ಕನ್ಸೋಲ್‌ಪ್ರಿಂಟರ್ ವರ್ಗ ಎರಡೂ IPrinter ಅಮೂರ್ತತೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಈಗ ನಾವು ಐಪ್ರಿಂಟರ್ ಅಮೂರ್ತತೆಯ ಹೆಚ್ಚುವರಿ ಕಡಿಮೆ-ಮಟ್ಟದ ಅನುಷ್ಠಾನಗಳನ್ನು ಸಹ ರಚಿಸಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಅನ್ವಯಿಸಬಹುದು:

ಪುಸ್ತಕ ಪುಸ್ತಕ = ಹೊಸ ಪುಸ್ತಕ(ಹೊಸ ಕನ್ಸೋಲ್ ಪ್ರಿಂಟರ್()); ಪುಸ್ತಕ.ಮುದ್ರಣ(); book.Printer = ಹೊಸ HtmlPrinter(); ಪುಸ್ತಕ.ಮುದ್ರಣ();

ಅವಲಂಬನೆ ವಿಲೋಮವು ಅತ್ಯಂತ ಪ್ರಮುಖವಾದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷಾವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ರಷ್ಯಾದ ಭಾಷೆಯ ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ಈ ಭಾಷಾವೈಶಿಷ್ಟ್ಯದ (ತತ್ವ) ಆಶ್ಚರ್ಯಕರವಾಗಿ ಕೆಲವು ವಿವರಣೆಗಳಿವೆ. ಆದ್ದರಿಂದ ನಾನು ವಿವರಣೆಯನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಲು ನಿರ್ಧರಿಸಿದೆ. ನಾನು ಜಾವಾದಲ್ಲಿ ಉದಾಹರಣೆಗಳನ್ನು ಮಾಡುತ್ತೇನೆ, ಈ ಸಮಯದಲ್ಲಿ ಅದು ನನಗೆ ಸುಲಭವಾಗಿದೆ, ಆದಾಗ್ಯೂ ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವವು ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗೆ ಅನ್ವಯಿಸುತ್ತದೆ.

ಜಾವಾ ವಿದ್ಯಾರ್ಥಿಗಳೊಂದಿಗೆ ತರಗತಿಗಳ ತಯಾರಿಯಲ್ಲಿ ವ್ಲಾಡಿಮಿರ್ ಮ್ಯಾಟ್ವೀವ್ ಅವರೊಂದಿಗೆ ಜಂಟಿಯಾಗಿ ಈ ವಿವರಣೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ.

ಈ ಸರಣಿಯ ಇತರ ಲೇಖನಗಳು:

"ಅವಲಂಬನೆ" ಯ ವ್ಯಾಖ್ಯಾನದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಚಟ ಎಂದರೇನು? ನಿಮ್ಮ ಕೋಡ್ ಕೆಲವು ವರ್ಗವನ್ನು ಆಂತರಿಕವಾಗಿ ಬಳಸಿದರೆ ಅಥವಾ ಕೆಲವು ವರ್ಗ ಅಥವಾ ಕಾರ್ಯದ ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕರೆದರೆ, ಇದು ಅವಲಂಬನೆಯಾಗಿದೆ. ನಾನು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿವರಿಸುತ್ತೇನೆ:

ಕೆಲವು ವಿಧಾನ () ಎಂಬ ವಿಧಾನದ ಒಳಗೆ ವರ್ಗ A ಕೆಳಗೆ ವರ್ಗ B ಯ ವಸ್ತುವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ವಿಧಾನವನ್ನು ಕೆಲವು MethodOfB () ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ

ಸಾರ್ವಜನಿಕ ವರ್ಗ A (ಅನೂರ್ಜಿತ ಕೆಲವು ವಿಧಾನ() (B b = ಹೊಸ B(); b.someMethodOfB(); )

ಅಂತೆಯೇ, ಉದಾಹರಣೆಗೆ, ವರ್ಗ B ಎಂಬುದು ಸಿಸ್ಟಮ್ ವರ್ಗದ ಸ್ಥಿರ ಕ್ಷೇತ್ರಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಉಲ್ಲೇಖಿಸುತ್ತದೆ:

ಸಾರ್ವಜನಿಕ ವರ್ಗ B (ಅನೂರ್ಜಿತ ಕೆಲವುMethodOfB() ( System.out.println("ಹಲೋ ವರ್ಲ್ಡ್"); ) )

ಯಾವುದೇ ವರ್ಗ (ಟೈಪ್ ಎ) ಸ್ವತಃ ಯಾವುದೇ ವರ್ಗವನ್ನು (ಟೈಪ್ ಬಿ) ರಚಿಸಿದರೆ ಅಥವಾ ಸ್ಥಿರ ಕ್ಷೇತ್ರಗಳು ಅಥವಾ ವರ್ಗ ಸದಸ್ಯರನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರವೇಶಿಸುವ ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ನೇರಚಟ. ಆ. ಮುಖ್ಯ: ಒಂದು ವರ್ಗವು ತನ್ನೊಳಗೆ ಇನ್ನೊಂದು ವರ್ಗದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದರೆ, ಇದು ಅವಲಂಬನೆಯಾಗಿದೆ. ಅವನು ತನ್ನೊಳಗೆ ಈ ವರ್ಗವನ್ನು ಸೃಷ್ಟಿಸಿದರೆ, ಆಗ ಇದು ನೇರಚಟ.

ನೇರ ಅವಲಂಬನೆಗಳಲ್ಲಿ ಏನು ತಪ್ಪಾಗಿದೆ? ನೇರ ಅವಲಂಬನೆಗಳು ಕೆಟ್ಟದಾಗಿವೆ ಏಕೆಂದರೆ ಸ್ವತಂತ್ರವಾಗಿ ತನ್ನೊಳಗೆ ಮತ್ತೊಂದು ವರ್ಗವನ್ನು ರಚಿಸುವ ವರ್ಗವು ಈ ವರ್ಗದೊಂದಿಗೆ "ಬಿಗಿಯಾಗಿ" ಬಂಧಿಸಲ್ಪಟ್ಟಿದೆ. ಆ. B = ಹೊಸ B() ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ಬರೆದಿದ್ದರೆ; , ನಂತರ ವರ್ಗ A ಯಾವಾಗಲೂ ವರ್ಗ B ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬೇರೆ ಯಾವುದೇ ವರ್ಗವಿಲ್ಲ. ಅಥವಾ System.out.println("...") ಎಂದು ಹೇಳಿದರೆ; ನಂತರ ವರ್ಗವು ಯಾವಾಗಲೂ System.out ಗೆ ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬೇರೆಲ್ಲಿಯೂ ಇಲ್ಲ.

ಸಣ್ಣ ವರ್ಗಗಳಿಗೆ, ಅವಲಂಬನೆಗಳು ಭಯಾನಕವಲ್ಲ. ಅಂತಹ ಕೋಡ್ ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡಬಹುದು. ಆದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಿಮ್ಮ ವರ್ಗ A ವಿವಿಧ ವರ್ಗಗಳ ಪರಿಸರದಲ್ಲಿ ಸಾರ್ವತ್ರಿಕವಾಗಿ ಕೆಲಸ ಮಾಡಲು, ಇದು ವರ್ಗಗಳ ಇತರ ಅನುಷ್ಠಾನಗಳ ಅಗತ್ಯವಿರಬಹುದು - ಅವಲಂಬನೆಗಳು. ಆ. ನಿಮಗೆ ಬೇಕಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ವರ್ಗ B ಅಲ್ಲ, ಆದರೆ ಅದೇ ಇಂಟರ್ಫೇಸ್ನೊಂದಿಗೆ ಮತ್ತೊಂದು ವರ್ಗ, ಅಥವಾ System.out ಅಲ್ಲ, ಆದರೆ, ಉದಾಹರಣೆಗೆ, ಲಾಗರ್ಗೆ ಔಟ್ಪುಟ್ (ಉದಾಹರಣೆಗೆ, log4j).

ನೇರ ಅವಲಂಬನೆಯನ್ನು ಸಚಿತ್ರವಾಗಿ ಈ ರೀತಿ ಪ್ರದರ್ಶಿಸಬಹುದು:

ಆ. ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ವರ್ಗ A ಅನ್ನು ನೀವು ರಚಿಸಿದಾಗ: A a = ಹೊಸ A(); ವಾಸ್ತವವಾಗಿ, ಒಂದು ವರ್ಗ A ಅನ್ನು ರಚಿಸಲಾಗಿಲ್ಲ, ಆದರೆ ಅವಲಂಬಿತ ವರ್ಗಗಳ ಸಂಪೂರ್ಣ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲಾಗಿದೆ, ಅದರ ಉದಾಹರಣೆ ಮೇಲಿನ ಚಿತ್ರದಲ್ಲಿದೆ. ಈ ಕ್ರಮಾನುಗತವು "ಕಟ್ಟುನಿಟ್ಟಾಗಿದೆ": ಪ್ರತ್ಯೇಕ ವರ್ಗಗಳ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸದೆಯೇ, ಕ್ರಮಾನುಗತದಲ್ಲಿ ಯಾವುದೇ ವರ್ಗಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ಅಂತಹ ಅನುಷ್ಠಾನದಲ್ಲಿ ವರ್ಗ ಎ ಬದಲಾಗುತ್ತಿರುವ ಪರಿಸರಕ್ಕೆ ಸರಿಯಾಗಿ ಹೊಂದಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಹೆಚ್ಚಾಗಿ, ನೀವು ಅದನ್ನು ಬರೆದ ನಿರ್ದಿಷ್ಟ ಒಂದನ್ನು ಹೊರತುಪಡಿಸಿ, ಯಾವುದೇ ಕೋಡ್‌ನಲ್ಲಿ ಅದನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ನಿರ್ದಿಷ್ಟ ಅವಲಂಬನೆಗಳಿಂದ ವರ್ಗ A ಅನ್ನು ಬೇರ್ಪಡಿಸಲು, ಅನ್ವಯಿಸಿ ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್. ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ಎಂದರೇನು? ಕೋಡ್‌ನಲ್ಲಿ ಅಪೇಕ್ಷಿತ ವರ್ಗವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ರಚಿಸುವ ಬದಲು, ಅವಲಂಬನೆಗಳನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಮೂಲಕ ವರ್ಗ A ಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ:

ಸಾರ್ವಜನಿಕ ವರ್ಗ A (ಖಾಸಗಿ ಅಂತಿಮ B b; ಸಾರ್ವಜನಿಕ A(B b) ( this.b = b; ) ಸಾರ್ವಜನಿಕ ನಿರರ್ಥಕ ಕೆಲವು ವಿಧಾನ() (b.someMethodOfB(); ) )

ಅದು. ವರ್ಗ A ಈಗ ಅದರ ಅವಲಂಬನೆಯನ್ನು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಮೂಲಕ ಪಡೆಯುತ್ತದೆ. ಈಗ, ಎ ವರ್ಗವನ್ನು ರಚಿಸಲು, ನೀವು ಮೊದಲು ಅದರ ಅವಲಂಬಿತ ವರ್ಗವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಬಿ:

ಬಿ ಬಿ = ಹೊಸ ಬಿ(); A a = ಹೊಸ A(b); a.someMethod();

ಎಲ್ಲಾ ವರ್ಗಗಳಿಗೆ ಒಂದೇ ವಿಧಾನವನ್ನು ಪುನರಾವರ್ತಿಸಿದರೆ, ಅಂದರೆ. ವರ್ಗ D ಯ ನಿದರ್ಶನವನ್ನು ವರ್ಗ B ಯ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ, D ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ರವಾನಿಸಿ - ಅದರ ಅವಲಂಬನೆಗಳು E ಮತ್ತು F, ಇತ್ಯಾದಿ. ನಂತರ ನೀವು ಕೋಡ್ ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ, ಅದರ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ರಚಿಸಲಾಗಿದೆ:

ಜಿ ಜಿ = ಹೊಸ ಜಿ(); H h = ಹೊಸ H(); F f = ಹೊಸ (g,h); ಇ ಇ = ಹೊಸ ಇ(); D d = ಹೊಸ D(e,f); ಬಿ ಬಿ = ಹೊಸ ಬಿ(ಡಿ); A a = ಹೊಸ A(b); a.someMethod();

ಸಚಿತ್ರವಾಗಿ, ಇದನ್ನು ಈ ರೀತಿ ಪ್ರದರ್ಶಿಸಬಹುದು:

ನೀವು 2 ಚಿತ್ರಗಳನ್ನು ಹೋಲಿಸಿದರೆ - ಮೇಲಿನ ಚಿತ್ರವು ನೇರ ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಮತ್ತು ಎರಡನೇ ಚಿತ್ರವು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ನೊಂದಿಗೆ - ಬಾಣಗಳ ದಿಕ್ಕು ವಿರುದ್ಧವಾಗಿ ಬದಲಾಗಿರುವುದನ್ನು ನೀವು ನೋಡಬಹುದು. ಈ ಕಾರಣಕ್ಕಾಗಿ, ಭಾಷಾವೈಶಿಷ್ಟ್ಯವನ್ನು "ಅವಲಂಬಿತ ವಿಲೋಮ" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ವರ್ಗವು ತನ್ನದೇ ಆದ ಅವಲಂಬನೆಗಳನ್ನು ರಚಿಸುವುದಿಲ್ಲ ಎಂಬ ಅಂಶದಲ್ಲಿ ಅವಲಂಬನೆ ವಿಲೋಮವು ಇರುತ್ತದೆ, ಆದರೆ ಅವುಗಳನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ (ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ) ರಚಿಸಿದ ರೂಪದಲ್ಲಿ ಪಡೆಯುತ್ತದೆ.

ಅವಲಂಬನೆ ವಿಲೋಮ ಏಕೆ ಒಳ್ಳೆಯದು? ಅವಲಂಬನೆ ವಿಲೋಮದೊಂದಿಗೆ, ನೀವು ಅದರ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸದೆಯೇ ವರ್ಗದಲ್ಲಿನ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಮತ್ತು ಇದರರ್ಥ ನಿಮ್ಮ ವರ್ಗ A ಅನ್ನು ಮೂಲತಃ ಬರೆಯಲಾದ ಪ್ರೋಗ್ರಾಂಗಿಂತ ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಬಳಸಲು ಸುಲಭವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಅದು. ಅವಲಂಬನೆ ವಿಲೋಮ ತತ್ವ (ಕೆಲವೊಮ್ಮೆ ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ತತ್ವ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಹೊಂದಿಕೊಳ್ಳುವ, ಮಾಡ್ಯುಲರ್, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಮುಖವಾಗಿದೆ.

ಅವಲಂಬನೆ ಚುಚ್ಚುಮದ್ದಿನ ಅನನುಕೂಲವು ಮೊದಲ ನೋಟದಲ್ಲಿ ಗೋಚರಿಸುತ್ತದೆ - ಈ ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ವರ್ಗಗಳ ವಸ್ತುಗಳು ನಿರ್ಮಿಸಲು ಪ್ರಯಾಸದಾಯಕವಾಗಿವೆ. ಆದ್ದರಿಂದ, ಅವಲಂಬನೆ ಚುಚ್ಚುಮದ್ದನ್ನು (ವಿಲೋಮ) ಸಾಮಾನ್ಯವಾಗಿ ಈ ಕಾರ್ಯವನ್ನು ಸುಲಭಗೊಳಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಕೆಲವು ಗ್ರಂಥಾಲಯದ ಜೊತೆಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Google Guice ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಸೆಂ.