ಜಾವಾ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ಅವಲೋಕನ
ಜಾವಾದಲ್ಲಿ, ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳು-ಸಾರ್ವಜನಿಕ, ಸಂರಕ್ಷಿತ, ಪ್ಯಾಕೇಜ್-ಖಾಸಗಿ ಮತ್ತು ಖಾಸಗಿ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಪ್ರತಿಯೊಂದು ಪರಿವರ್ತಕವು ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶವನ್ನು ಪೂರೈಸುತ್ತದೆ ಮತ್ತು ವರ್ಗಗಳು, ವಿಧಾನಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳ ಗೋಚರತೆ ಮತ್ತು ಪ್ರವೇಶವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.
ಸೂಕ್ತವಾದ ಪ್ರವೇಶ ಪರಿವರ್ತಕವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್‌ನ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಮತ್ತು ಸುರಕ್ಷತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಆದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನ ವಿವಿಧ ಭಾಗಗಳು ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಆನುವಂಶಿಕತೆ ಸೇರಿದಂತೆ ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಈ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವ ನಿಯಮಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.
| ಆಜ್ಞೆ | ವಿವರಣೆ |
|---|---|
| protected | ಸದಸ್ಯರಿಗೆ ಅದರ ಸ್ವಂತ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮತ್ತು ಉಪವರ್ಗಗಳ ಮೂಲಕ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. |
| package-private | ಡೀಫಾಲ್ಟ್ ಪ್ರವೇಶ ಮಟ್ಟ; ತನ್ನದೇ ಆದ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. |
| @Override | ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನಲ್ಲಿ ವಿಧಾನವನ್ನು ಅತಿಕ್ರಮಿಸಲು ಒಂದು ವಿಧಾನವನ್ನು ಉದ್ದೇಶಿಸಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. |
| public class | ಯಾವುದೇ ವರ್ಗದಿಂದ ಪ್ರವೇಶಿಸಬಹುದಾದ ವರ್ಗವನ್ನು ವಿವರಿಸುತ್ತದೆ. |
| private | ಸದಸ್ಯರಿಗೆ ಅದರ ಸ್ವಂತ ವರ್ಗದೊಳಗೆ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ. |
| extends | ಒಂದು ವರ್ಗವು ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. |
| System.out.println() | ಕನ್ಸೋಲ್‌ಗೆ ಪಠ್ಯವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ. |
| public void | ಯಾವುದೇ ಇತರ ವರ್ಗದಿಂದ ಪ್ರವೇಶಿಸಬಹುದಾದ ವಿಧಾನವನ್ನು ವಿವರಿಸುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ. |
ಜಾವಾದಲ್ಲಿ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ವಿವರಣೆ
ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಜಾವಾ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ಬಳಕೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ: public, protected, package-private, ಮತ್ತು private. ಮೊದಲ ಲಿಪಿಯಲ್ಲಿ, ಒಂದು ವರ್ಗ AccessModifiersExample ವಿವಿಧ ಪ್ರವೇಶ ಹಂತಗಳ ಕ್ಷೇತ್ರಗಳೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ದಿ public ಕ್ಷೇತ್ರವನ್ನು ಯಾವುದೇ ಇತರ ವರ್ಗದಿಂದ ಪ್ರವೇಶಿಸಬಹುದು, ಇದು ಅತ್ಯಂತ ಅನುಮತಿಸುವ ಪ್ರವೇಶ ಮಟ್ಟವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ದಿ protected ಕ್ಷೇತ್ರವು ಒಂದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮತ್ತು ಉಪವರ್ಗಗಳ ಮೂಲಕ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ದಿ package-private ಕ್ಷೇತ್ರ, ಇದು ಡೀಫಾಲ್ಟ್ ಪ್ರವೇಶ ಮಟ್ಟವಾಗಿದೆ, ಅದರ ಸ್ವಂತ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದಾಗಿದೆ. ಅಂತಿಮವಾಗಿ, ದಿ private ಕ್ಷೇತ್ರವು ಒಂದೇ ವರ್ಗದೊಳಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರತಿ ಕ್ಷೇತ್ರಕ್ಕೂ ಅನುಗುಣವಾದ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳೊಂದಿಗೆ ಗೆಟರ್ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸಲಾಗುತ್ತದೆ, ಈ ಮಾರ್ಪಾಡುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.
ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳು ಉಪವರ್ಗದ ನಡವಳಿಕೆಯ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು ಉತ್ತರಾಧಿಕಾರವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ದಿ Parent ವರ್ಗವು ವಿಭಿನ್ನ ಪ್ರವೇಶ ಹಂತಗಳೊಂದಿಗೆ ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ: public, protected, package-private, ಮತ್ತು private. ದಿ Child ವರ್ಗ ವಿಸ್ತರಿಸುತ್ತದೆ Parent ಮತ್ತು ಅತಿಕ್ರಮಿಸುತ್ತದೆ public, protected, ಮತ್ತು package-private ವಿಧಾನಗಳು. ದಿ @Override ಈ ವಿಧಾನಗಳು ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಅತಿಕ್ರಮಿಸುವ ವಿಧಾನಗಳಾಗಿವೆ ಎಂದು ಸೂಚಿಸಲು ಟಿಪ್ಪಣಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಎಂಬುದನ್ನು ಗಮನಿಸಿ private ವಿಧಾನವನ್ನು ಉಪವರ್ಗದಲ್ಲಿ ಅತಿಕ್ರಮಿಸಲಾಗುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ತನ್ನದೇ ಆದ ವರ್ಗದ ಹೊರಗೆ ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ. ಈ ಉದಾಹರಣೆಗಳು ವಿಧಾನ ಪ್ರವೇಶಿಸುವಿಕೆ ಮತ್ತು ಆನುವಂಶಿಕತೆಯ ಮೇಲೆ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ಪ್ರಭಾವವನ್ನು ವಿವರಿಸುತ್ತದೆ, ಪ್ರತಿ ಮಾರ್ಪಾಡು ವಿಧಿಸುವ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಮಿತಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಜಾವಾದಲ್ಲಿ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ವಿವರವಾದ ವಿವರಣೆ
ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಉದಾಹರಣೆ
public class AccessModifiersExample {public String publicField = "Public Field";protected String protectedField = "Protected Field";String packagePrivateField = "Package-Private Field";private String privateField = "Private Field";public String getPublicField() {return publicField;}protected String getProtectedField() {return protectedField;}String getPackagePrivateField() {return packagePrivateField;}private String getPrivateField() {return privateField;}}
ಆನುವಂಶಿಕತೆಯಲ್ಲಿ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತಿದೆ
ಉತ್ತರಾಧಿಕಾರದೊಂದಿಗೆ ಜಾವಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಉದಾಹರಣೆ
public class Parent {public void publicMethod() {System.out.println("Public method in Parent");}protected void protectedMethod() {System.out.println("Protected method in Parent");}void packagePrivateMethod() {System.out.println("Package-private method in Parent");}private void privateMethod() {System.out.println("Private method in Parent");}}public class Child extends Parent {@Overridepublic void publicMethod() {System.out.println("Public method in Child");}@Overrideprotected void protectedMethod() {System.out.println("Protected method in Child");}@Overridevoid packagePrivateMethod() {System.out.println("Package-private method in Child");}}
ಪರಿಣಾಮಕಾರಿ ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ಗಾಗಿ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳನ್ನು ಬಳಸುವುದು
ಜಾವಾದಲ್ಲಿನ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳು ಡೇಟಾವನ್ನು ಎನ್ಕ್ಯಾಪ್ಸುಲೇಟ್ ಮಾಡುವಲ್ಲಿ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತವೆ ಮತ್ತು ವಸ್ತುವಿನ ಆಂತರಿಕ ಸ್ಥಿತಿಯನ್ನು ಅನಗತ್ಯವಾಗಿ ಬಹಿರಂಗಪಡಿಸುವುದಿಲ್ಲ. ದಿ public ಪ್ರವೇಶ ಪರಿವರ್ತಕವು ವರ್ಗ, ವಿಧಾನ ಅಥವಾ ವೇರಿಯಬಲ್ ಅನ್ನು ಯಾವುದೇ ಇತರ ವರ್ಗದಿಂದ ಪ್ರವೇಶಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ನಿಮ್ಮ ವರ್ಗದ API ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಕೆಲವು ವಿಧಾನಗಳು ಬಳಸಬಹುದಾದ ವರ್ಗಕ್ಕೆ ಸಾರ್ವಜನಿಕವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಅತಿಯಾದ ಬಳಕೆ public ತರಗತಿಗಳ ನಡುವೆ ಬಿಗಿಯಾದ ಜೋಡಣೆಗೆ ಕಾರಣವಾಗಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನ ನಮ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ಮತ್ತೊಂದೆಡೆ, ದಿ private ಪ್ರವೇಶ ಪರಿವರ್ತಕವು ಅತ್ಯಂತ ನಿರ್ಬಂಧಿತವಾಗಿದೆ, ಒಂದೇ ವರ್ಗದೊಳಗೆ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಯಾವುದೇ ಬಾಹ್ಯ ವರ್ಗವು ವಸ್ತುವಿನ ಆಂತರಿಕ ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಸ್ಪಷ್ಟವಾದ ಗಡಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅನಪೇಕ್ಷಿತ ಸಂವಹನಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ದಿ protected ಮಾರ್ಪಾಡು ನಡುವೆ ಸಮತೋಲನವನ್ನು ಹೊಡೆಯುತ್ತದೆ public ಮತ್ತು private, ಅದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮತ್ತು ಉಪವರ್ಗಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಅನುವಂಶಿಕ ಶ್ರೇಣಿಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ನೀವು ಉಪವರ್ಗಗಳಿಗೆ ಕೆಲವು ವಿಧಾನಗಳು ಅಥವಾ ಪೋಷಕ ವರ್ಗದ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುಮತಿಸಲು ಬಯಸಬಹುದು, ಆದರೆ ಉಳಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಅವುಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಬಾರದು. ದಿ package-private ಪ್ರವೇಶ ಮಟ್ಟ (ಡೀಫಾಲ್ಟ್, ಯಾವುದೇ ಪರಿವರ್ತಕವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದಾಗ) ಅದೇ ಪ್ಯಾಕೇಜ್‌ನೊಳಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ, ಪ್ಯಾಕೇಜ್ ಮಟ್ಟದಲ್ಲಿ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಅನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್‌ನ ಇತರ ಭಾಗಗಳಿಗೆ ತೆರೆದುಕೊಳ್ಳದ ಆಂತರಿಕ ಅನುಷ್ಠಾನಗಳಿಗೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದರೆ ಅದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ವರ್ಗಗಳ ನಡುವೆ ಹಂಚಿಕೊಳ್ಳಬೇಕಾಗಿದೆ. ಸೂಕ್ತವಾದ ಪ್ರವೇಶ ಪರಿವರ್ತಕವನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಆರಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಹೆಚ್ಚು ಮಾಡ್ಯುಲರ್, ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಸುರಕ್ಷಿತ ಕೋಡ್ ಅನ್ನು ರಚಿಸಬಹುದು.
ಜಾವಾ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು
- ಜಾವಾದಲ್ಲಿ ಅತ್ಯಂತ ನಿರ್ಬಂಧಿತ ಪ್ರವೇಶ ಮಾರ್ಪಾಡು ಯಾವುದು?
- ಅತ್ಯಂತ ನಿರ್ಬಂಧಿತ ಪ್ರವೇಶ ಮಾರ್ಪಾಡು private, ಇದು ಒಂದೇ ತರಗತಿಯೊಳಗೆ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
- ನಾನು ಯಾವಾಗ ಬಳಸಬೇಕು protected ಪ್ರವೇಶ ಪರಿವರ್ತಕ?
- ಬಳಸಿ protected ಅದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮತ್ತು ಉಪವರ್ಗಗಳ ಮೂಲಕ ಸದಸ್ಯರಿಗೆ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸಲು ನೀವು ಬಯಸಿದಾಗ.
- ಏನು ಮಾಡುತ್ತದೆ package-private ಪ್ರವೇಶ ಮಟ್ಟದ ಅರ್ಥ?
- Package-private (ಡೀಫಾಲ್ಟ್, ಯಾವುದೇ ಮಾರ್ಪಾಡು ಇಲ್ಲ) ಎಂದರೆ ಸದಸ್ಯನು ತನ್ನ ಸ್ವಂತ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು.
- ಮಾಡಬಹುದು ಎ private ವಿಧಾನವನ್ನು ಅತಿಕ್ರಮಿಸಬಹುದೇ?
- ಇಲ್ಲ, ಎ private ಅದರ ಸ್ವಂತ ವರ್ಗದ ಹೊರಗೆ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗದ ಕಾರಣ ವಿಧಾನವನ್ನು ಅತಿಕ್ರಮಿಸಲಾಗುವುದಿಲ್ಲ.
- ಎರಡರ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು public ಮತ್ತು protected?
- Public ಯಾವುದೇ ವರ್ಗದಿಂದ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ protected ಒಂದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಮತ್ತು ಉಪವರ್ಗಗಳ ಮೂಲಕ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
- ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವೇ a protected ಬೇರೆ ಪ್ಯಾಕೇಜ್‌ನಿಂದ ಸದಸ್ಯರೇ?
- ಹೌದು, ಆದರೆ ಉಪವರ್ಗದಿಂದ ಉತ್ತರಾಧಿಕಾರದ ಮೂಲಕ ಪ್ರವೇಶಿಸಿದರೆ ಮಾತ್ರ.
- ಯಾವಾಗ ಬಳಸಬೇಕು public ಪರಿವರ್ತಕ?
- ಬಳಸಿ public ಇತರ ಯಾವುದೇ ವರ್ಗದಿಂದ ಸದಸ್ಯನನ್ನು ಪ್ರವೇಶಿಸಲು ನೀವು ಬಯಸಿದಾಗ.
- ಹೇಗೆ ಮಾಡುತ್ತದೆ private ಸುತ್ತುವರಿಯುವಲ್ಲಿ ಸಹಾಯ ಮಾಡುವುದೇ?
- Private ಒಂದೇ ವರ್ಗದೊಳಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ, ಆಂತರಿಕ ಸ್ಥಿತಿ ಮತ್ತು ಅನುಷ್ಠಾನದ ವಿವರಗಳನ್ನು ಮರೆಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ಮಾಡಬಹುದು package-private ಉಪವರ್ಗಗಳ ಮೂಲಕ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಬಹುದೇ?
- ಹೌದು, ಆದರೆ ಉಪವರ್ಗವು ಒಂದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿದ್ದರೆ ಮಾತ್ರ.
ಜಾವಾ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ಬಳಕೆಯನ್ನು ಮುಚ್ಚಲಾಗುತ್ತಿದೆ
ಕೊನೆಯಲ್ಲಿ, ಜಾವಾ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳು ನಿಮ್ಮ ತರಗತಿಗಳು ಮತ್ತು ಅವರ ಸದಸ್ಯರ ಗೋಚರತೆ ಮತ್ತು ಪ್ರವೇಶವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅಗತ್ಯವಾದ ಸಾಧನಗಳಾಗಿವೆ. ಬಳಸಿಕೊಂಡು public, protected, package-private, ಮತ್ತು private ಸೂಕ್ತವಾಗಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನ ವಿವಿಧ ಭಾಗಗಳು ಪರಸ್ಪರ ಹೊಂದಿರುವ ಪ್ರವೇಶದ ಮಟ್ಟವನ್ನು ನೀವು ನಿಯಂತ್ರಿಸಬಹುದು. ಇದು ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ವರ್ಧಿಸುತ್ತದೆ ಆದರೆ ಉತ್ತಮವಾಗಿ-ರಚನಾತ್ಮಕ ಮತ್ತು ಮಾಡ್ಯುಲರ್ ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಮಾರ್ಪಾಡುಗಳನ್ನು ಸರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಅನ್ವಯಿಸುವುದು ಯಾವುದೇ ಜಾವಾ ಡೆವಲಪರ್‌ಗೆ ಪ್ರಮುಖ ಕೌಶಲ್ಯವಾಗಿದೆ.