(ಜಾವಾ) ಲೂಪ್ಗಾಗಿ ಇನ್ಫೈನೈಟ್

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

ಸೈಕಲ್ ಸಂದರ್ಭದಲ್ಲಿ ಜಾವಾ: ವಿವರಣೆ ಮತ್ತು ಉದಾಹರಣೆಗಳು

ಜಾವಾದಲ್ಲಿನ ಆಧಾರವಾಗಿರುವ ಸೈಕಲ್ ಹೇಳಿಕೆಯು ಹಾಗೆಯೇ ಇದೆ. ಅದರ ತಾರ್ಕಿಕ ಮೌಲ್ಯವನ್ನು ತೃಪ್ತಿಗೊಳಿಸಿದ ನಂತರ ಆವರಣದ ಆವರಣದ ಆವರಣವು ಆವರಣದಲ್ಲಿ ಸುತ್ತುವರೆಯುವವರೆಗೆ ಅದರ ದೇಹದಲ್ಲಿ ಆವರಿಸಲ್ಪಟ್ಟ ಕೋಡ್ ತುಣುಕು ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ. ಹೇಳಿಕೆ ಹೇಳುವುದಾದರೆ ಸಾಮಾನ್ಯ ರೂಪ:

ಆದರೆ (ಷರತ್ತು) {

/ ಲೂಪ್ನ ದೇಹ

}

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

ಸ್ಪಷ್ಟತೆಗಾಗಿ, ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಿದ ಉದಾಹರಣೆಯನ್ನು ನಾವು ನೋಡೋಣ:

ಡಿಕ್ಲೇರ್ಡ್ ವೇರಿಯೇಬಲ್ ಎಣಿಕೆ ಆರಂಭದಲ್ಲಿ 1 ರ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ. ಮುಂದೆ, ಆಪರೇಟರ್ ಹೆಸರಿನ ನಂತರ ಆವರಣದಲ್ಲಿ ಆವರಿಸಿರುವ ಲಾಜಿಕಲ್ ಎಕ್ಸ್ಪ್ರೆಶನ್ ಅನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ. ಇದು ನಿಜ, ನಾನು. ಎಣಿಕೆ ವೇರಿಯಬಲ್ನ ಮೌಲ್ಯವು 10 ಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿರುತ್ತದೆ ತನಕ ನಿಜವಾದ ಹಿಂತಿರುಗಿ. ಲೂಪ್ನ ದೇಹದಲ್ಲಿ, ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ, ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಕನ್ಸೋಲ್ ಪರದೆಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು 11 ತಲುಪಿದಾಗ, ಚಕ್ರವು ಕೆಲಸ ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸಿತು.

ವೇರಿಯೇಬಲ್ ಎಣಿಕೆ ಮೌಲ್ಯವು ಆರಂಭದಲ್ಲಿ 11 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆಯಾದರೆ, ಲೂಪ್ ಸ್ಥಿತಿ ತಪ್ಪಾಗಿರುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಅವನ ದೇಹಕ್ಕೆ ಹೋಗುವುದಿಲ್ಲ.

ದೇಹವಿಲ್ಲದೆ ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸಲು ಜಾವಾ ಸಿಂಟ್ಯಾಕ್ಸ್ ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ನಮಗೆ ಒಂದು ಉದಾಹರಣೆ ನೀಡೋಣ. ನಾವು ಎರಡು ಅಸ್ಥಿರಗಳಾದ = = 100 ಮತ್ತು j = 200 ಹೊಂದಿದ್ದಲ್ಲಿ, ನಾವು ಅವರ ಅಂಕಗಣಿತದ ಸರಾಸರಿ ಗಣನೆಯನ್ನು ಕ್ರಮಬದ್ಧವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಕಾರ್ಯವನ್ನು ಎದುರಿಸುತ್ತೇವೆ - ನೀವು "ಹಾಲೊ"

ಹಾಗೆಯೇ (++ i <- j);

ಪರಿಣಾಮವಾಗಿ, ಎರಡು ಅಸ್ಥಿರಗಳ ಮೌಲ್ಯವು ಅವುಗಳ ಮೂಲ ಮೌಲ್ಯಗಳ ಸರಾಸರಿಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ನೀವು ನೋಡುವಂತೆ, ಆವರ್ತವು ದೇಹವಿಲ್ಲದೆ ಸಂಪೂರ್ಣವಾಗಿ ಕೆಲಸ ಮಾಡಿತು ಮತ್ತು ಷರತ್ತುಬದ್ಧ ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಎಲ್ಲ ಕ್ರಮಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಮಾಡುವಾಗ ಲೂಪ್

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

{
/ ಲೂಪ್ನ ದೇಹ

} ಆದರೆ (ಪರಿಸ್ಥಿತಿ);

ನಾವು ನೋಡುವಂತೆ, ಲೂಪ್ ದೇಹವನ್ನು ಮೊದಲು ಮರಣದಂಡನೆ ಮಾಡಲಾಗುವುದು, ಮತ್ತು ನಂತರ ಕೇವಲ ಸ್ಥಿತಿಯ ಪರೀಕ್ಷೆ-ಮತ್ತು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಮೇಲೆ.

ಮೇಲಿನ ಸಂಕೇತವು ಸಾಮಾನ್ಯ ಸಮಯದಲ್ಲಿಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಹೇಗಾದರೂ, ನಾವು ಎಣಿಕೆ ವೇರಿಯಬಲ್ ಅನ್ನು 11 ರ ಮೌಲ್ಯವನ್ನು ನೀಡಿದರೆ, ಆಪರೇಟರ್ನ ಸಿಂಧುತ್ವವನ್ನು ನಿರ್ವಾಹಕರು ಪರಿಶೀಲಿಸುವ ಮೊದಲು ಲೂಪ್ ದೇಹವನ್ನು ಇನ್ನೂ ಒಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ವಿವರಣೆ ಮತ್ತು ಉದಾಹರಣೆಗಳು - ಜಾವಾ ಚಕ್ರ

ಫಾರ್ ಲೂಪ್ ಜಾವಾದಲ್ಲಿ ಸಾರ್ವತ್ರಿಕ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಭಾಷೆಯ ರೂಪವಾಗಿದೆ. ಜಾವಾ ಎಸ್ ಡಿ ಕೆನ ಐದನೇ ಆವೃತ್ತಿಯ ಮೊದಲು, ಹೇಳಿಕೆಗಾಗಿ ಕೇವಲ ಒಂದು ಸಾಂಪ್ರದಾಯಿಕ ರೂಪ ಮಾತ್ರ ಇತ್ತು, ತದನಂತರ ಪ್ರತಿಯೊಂದಕ್ಕೂ ಹೊಸದು. ಈ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಆಪರೇಟರ್ನ ಸಾಂಪ್ರದಾಯಿಕ ರೂಪವನ್ನು ಪರಿಚಯಿಸುತ್ತೇವೆ. ಜಾವಾಗೆ, ಲೂಪ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ, ಜಾವಾ ಲೂಪ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ನಾವು ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೀಡೋಣ:

ಲೂಪ್ವಾಲ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಕೌಂಟರ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಲೂಪ್ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ನಂತರ, ಇದರ ಮೌಲ್ಯವು 1 ರಿಂದ ಹೆಚ್ಚಾಗುತ್ತದೆ, ಮತ್ತು ಇದು 11 ತಲುಪುವ ತನಕ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ನಿಯಂತ್ರಣ ವೇರಿಯಬಲ್ ಸಹ ಹೇಳಿಕೆಗಾಗಿ ಹೊರಗೆ ಘೋಷಿಸಲ್ಪಡುತ್ತದೆ, ಆದರೆ ನೀವು ಈ ವೇರಿಯಬಲ್ ಅನ್ನು ಎಲ್ಲಿಯಾದರೂ ಬಳಸದೆ ಹೋದರೆ ಒಂದು ಲೂಪ್ನಲ್ಲಿ, ಹೇಳಿಕೆಗೆ ನೇರವಾಗಿ ಅದನ್ನು ಘೋಷಿಸಲು ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಹೇಳಿಕೆಯಲ್ಲಿ ಡಿಕ್ಲೇರ್ಡ್ ಮಾಡಲಾದ ವ್ಯತ್ಯಯವು ಇದೇ ಲೂಪ್ನಲ್ಲಿ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

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

ಫಾರ್ (ಇಂಟ್ ನಾನು = 1, ಇಂಟ್ ಜೆ = 10; ನಾನು <ಜೆ; ++ ನಾನು, --j) {}

ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ, ನಾನು 1 ರ ಮೌಲ್ಯವು ಹೆಚ್ಚಾಗುತ್ತದೆ, ಮತ್ತು ಜೆ ಮೌಲ್ಯವು 1 ರಿಂದ ಕಡಿಮೆಯಾಗುತ್ತದೆ. ನಾನು j ಗೆ ಹೆಚ್ಚಿರುತ್ತದೆ ಅಥವಾ ಸಮನಾಗಿರುತ್ತದೆ ತನಕ ಪುನರಾವರ್ತನೆಗಳು ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತವೆ.

ಹೇಳಿಕೆಗಾಗಿ ಬಳಸುವ ವೈಶಿಷ್ಟ್ಯಗಳು

ಫಾರ್ ಲೂಪ್ ಸಾಕಷ್ಟು ಸರಳವಾದ ರಚನೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದರ ಎಲ್ಲಾ ಮೂರು ಭಾಗಗಳನ್ನು (ಆರಂಭಿಸುವಿಕೆ, ಷರತ್ತು ಮತ್ತು ಹೆಚ್ಚಳ / ಇಳಿಕೆ) ಉದ್ದೇಶಿತ ಉದ್ದೇಶಕ್ಕಾಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ನಿಯಂತ್ರಣ ವೇರಿಯಬಲ್ನ ಷರತ್ತುಬದ್ಧ ಅಭಿವ್ಯಕ್ತಿಯ ಬದಲಿಗೆ, ನೀವು ಯಾವುದೇ ತಾರ್ಕಿಕ ವೇರಿಯಬಲ್ ಅನ್ನು ಬದಲಿಸಬಹುದು.

ಬೂಲಿಯನ್ ನಿರ್ಗಮನ = ಸುಳ್ಳು;

ಫಾರ್ (ಇಂಟ್ ನಾನು = 0 ;! ನಿರ್ಗಮನ; ++ ನಾನು) {

ನಿರ್ಗಮಿಸು = ನಿಜವಾದ;

}

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾನು ಲೂಪ್ನ ಕಾರ್ಯಾಚರಣೆ ಹೇಗೆ ನಿಯಂತ್ರಣ ವೇರಿಯಬಲ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವತಂತ್ರವಾಗಿದೆಯೆಂದು ಮತ್ತು ನಾವು ಪುನರಾವರ್ತನೆಯ ಸಂಖ್ಯೆಯು ನಿರ್ಗಮನ ವೇರಿಯಬಲ್ ನಿಜವಾಗಿದ್ದಾಗ ಮಾತ್ರ ಅವಲಂಬಿಸಿರುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಗಮನಿಸಬಹುದು. ಇದಲ್ಲದೆ, ನಿಯಂತ್ರಣ ವೇರಿಯಬಲ್ ಲೂಪ್ನಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ತೆಗೆಯಬಹುದು ಮತ್ತು ಇದು ಅದರ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ: ಫಾರ್ (;! ನಿರ್ಗಮಿಸಿ;) {}. ಇದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ನ ಅತ್ಯಂತ ಸಮಂಜಸವಾದ ಮಾರ್ಗವಲ್ಲವಾದರೂ, ಕೆಲವೊಮ್ಮೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಲೂಪ್ನಿಂದ ನಿರ್ಗಮಿಸಲು ಅವಶ್ಯಕವಾದ ಮೌಲ್ಯವನ್ನು ವೇರಿಯಬಲ್ ತೆಗೆದುಕೊಳ್ಳುವ ಪರಿಸ್ಥಿತಿಯನ್ನು ಒದಗಿಸುವುದು ಮುಖ್ಯ ವಿಷಯ, ಹಾಗಾಗಿ ಇದು ಅನಂತ ಮೌಲ್ಯಕ್ಕೆ ತಿರುಗಿರುವುದಿಲ್ಲ.

ಜಾವಾಗೆ, ಲೂಪ್ ಅನ್ನು ಈ ರೀತಿಯಾಗಿ ಘೋಷಿಸಬಹುದು: ಫಾರ್ (;;) {}. ಇದು ವಿಶೇಷ ಅಡ್ಡಿ ಪರಿಸ್ಥಿತಿಗಳೊಂದಿಗೆ ಅನಂತ ಲೂಪ್ನ ಒಂದು ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಯಾಗಿದೆ. ಈ ರೀತಿಯ ಚಕ್ರಗಳನ್ನು ಹೇಗೆ ಅಡ್ಡಿಪಡಿಸುವುದು ಎಂಬುದರ ಕುರಿತು, ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ನಾವು ಮಾತನಾಡುತ್ತೇವೆ.

ಪ್ರತಿ ಶೈಲಿಯಲ್ಲಿ ಸೈಕಲ್

ಫಾರೆಚ್ ಜಾವಾ ಲೂಪ್ ಅನ್ನು ಯಾವಾಗಲೂ ಅನುಕ್ರಮ ಅಥವಾ ಕೆಲವು ಡೇಟಾ ರಚನೆಯ ಅಂಶಗಳ ಮೂಲಕ ಅನುಕ್ರಮವಾಗಿ ಹುಡುಕಲು ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಕೆಲವು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಫಾರ್ಮೆಂಟ್ನ ಈ ಫಾರ್ಮ್ನ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ತೋರಿಸಲಾಗಿದೆ:

ಒಂದು ಪುನರಾವರ್ತಿತ ವೇರಿಯೇಬಲ್ನಂತೆ, ಹೆಸರು ಘೋಷಿಸಲ್ಪಟ್ಟಿದೆ, ಮತ್ತು ಹಿಂದೆ ಘೋಷಿಸಿದ ಸರಣಿಗಳ ಹೆಸರುಗಳು ಆಯೋಜಕರು ನ ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿದೆ. ವ್ಯುತ್ಪತ್ತಿಯ ಹೆಸರು ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಅದರ ಹೊರತೆಗೆಯುವ ತನಕ ರಚನೆಯ ಒಂದು ಪ್ರತಿ ಅಂಶದ ಮೌಲ್ಯಗಳನ್ನು ಒಂದೇ ಸಮಯದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ವೇರಿಯೇಬಲ್ನ ಪ್ರಕಾರವು ರಚನೆಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಅಂಶಗಳ ಪ್ರಕಾರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು ಎಂದು ಗಮನಿಸಬೇಕು. ಅಲ್ಲದೆ, ಹೆಸರು ವೇರಿಯೇಬಲ್ ಓದಲು-ಮಾತ್ರವಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಬದಲಿಸಲು ಪ್ರಯತ್ನಿಸುವುದರಿಂದ ಅಂಶವನ್ನು ಸ್ವತಃ ರಚನೆಯಲ್ಲಿ ಬದಲಾಯಿಸುವುದಿಲ್ಲ.

ಸೈಕಲ್ ಇಂಟರಪ್ಟ್ ಆಪರೇಟರ್ಸ್

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

ಹೇಳಿಕೆಯಲ್ಲಿ ಈ 11 ಪುನರಾವರ್ತನೆಯನ್ನು ನೀಡಲಾಗಿದ್ದರೂ, ಕೇವಲ 8 ಕಾರ್ಯಗತಗೊಳಿಸಲ್ಪಡುತ್ತದೆ, ಏಕೆಂದರೆ ನಾನು ಕೌಂಟರ್ 7 ಆಗಿದ್ದರೆ, ಬ್ರೇಕ್ ಹೇಳಿಕೆ ಇರುವ ದೇಹದಲ್ಲಿನ ಸ್ಥಿತಿಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಹಿಂದಿರುಗಿದ ಹೇಳಿಕೆಯು ಇದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇದು ಜಾವಾ ಲೂಪ್ನಿಂದ ನಿರ್ಗಮಿಸುವುದನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಈ ಲೂಪ್ ಅನ್ನು ಇರಿಸಿದ ವಿಧಾನದಿಂದಲೂ.

ಗೊಟೊ ಎಂದು ಬ್ರೇಕ್ ಬಳಸಿ

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

ಈ ರೂಪಾಂತರದಲ್ಲಿ, ಈ ಆಪರೇಟರ್ ಅನ್ನು ಲೇಬಲ್ನೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಔಟ್ಪುಟ್ ಅನ್ನು ಚಕ್ರಗಳಿಂದ ಮಾತ್ರ ಜೋಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಕೋಡ್ನ ಯಾವುದೇ ಬ್ಲಾಕ್ನಿಂದ. ಒಂದು ಲೇಬಲ್ ಅದರ ನಂತರ ಒಂದು ಕರುಳಿನೊಂದಿಗೆ ಸೂಕ್ತವಾಗಿ ಹೆಸರಿಸಲಾದ ಗುರುತಿಸುವಿಕೆಯಾಗಿದೆ. ಸಂಕೇತದ ಗುರುತು ಬ್ಲಾಕ್ನ ಪ್ರಾರಂಭದಲ್ಲಿ ಲೇಬಲ್ ಅನ್ನು ಘೋಷಿಸಲಾಗಿದೆ. ಗುರುತಿಸಲಾದ ಬ್ಲಾಕ್ನ ಕಾರ್ಯವನ್ನು ತಡೆಗಟ್ಟಲು, ಸರಿಯಾದ ಸ್ಥಳದಲ್ಲಿ, ನೀವು ಘೋಷಿಸಬೇಕಾಗಿದೆ: name_name ಅನ್ನು ಮುರಿಯಿರಿ. ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

ಕೋಡ್ ಕ್ರಮವಾಗಿ ಮೂರು ಬ್ಲಾಕ್ಗಳನ್ನು ಒಂದು, ಎರಡು ಮತ್ತು ಮೂರು ಲೇಬಲ್ಗಳ ಹೆಸರಿನೊಂದಿಗೆ ಘೋಷಿಸುತ್ತದೆ. ಎರಡು ಲೇಬಲ್ನೊಂದಿಗಿನ ಬ್ರೇಕ್ ಹೇಳಿಕೆ ಎಲ್ಲಾ ಮೂರು ಬ್ಲಾಕ್ಗಳಲ್ಲಿ ಅಡಕವಾಗಿದೆ, ಆದರೆ ಅದು ಪ್ರಚೋದಿಸಿದಾಗ ಪ್ರೋಗ್ರಾಂ ಮೂರು ಮತ್ತು ಎರಡು ಬ್ಲಾಕ್ಗಳನ್ನು ನಿರ್ಗಮಿಸುತ್ತದೆ ಮತ್ತು ಒಂದು ಬ್ಲಾಕ್ನಲ್ಲಿ ಮರಣದಂಡನೆಯನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ. ಐ. ಕನ್ಸೋಲ್ನಲ್ಲಿ ನಾವು ಎರಡು ಸಂದೇಶಗಳನ್ನು ನೋಡಬಹುದು: ಮೂರು ಮತ್ತು ಒನ್.

ತೀರ್ಮಾನ

ನಾವು ಜಾವಾದಲ್ಲಿ, ಮುಖ್ಯ ಸಮಯದಲ್ಲಿ ಮತ್ತು ಹೇಳಿಕೆಗಳಿಗಾಗಿ ಲೂಪ್ ಪರಿಕಲ್ಪನೆಯನ್ನು, ಮತ್ತು ಅವುಗಳ ಮಾಡಬೇಕಾದ ಸಮಯ ಮತ್ತು ಪ್ರತಿಯೊಂದು ಪ್ರಕಾರಗಳಿಗೆ ಕ್ರಮವಾಗಿ ಕಲಿತಿದ್ದೇವೆ. ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ, ಈ ನಿರ್ವಾಹಕರನ್ನು ವಿವಿಧ ಸ್ವರೂಪಗಳಲ್ಲಿ ಬಳಸಿ ವ್ಯಾಯಾಮ ಮಾಡುವುದನ್ನು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ, ಜೊತೆಗೆ ಅವುಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಮತ್ತು ಒಂದು ಬ್ಲಾಕ್ನಿಂದ ಮತ್ತೊಂದಕ್ಕೆ ತೆರಳಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ.