(ਜਾਵਾ) ਲੂਪ ਲਈ ਅਨੰਤ

ਜਾਵਾ ਵਿੱਚ, ਤਕਰੀਬਨ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ, ਕੁਝ ਖਾਸ ਟੁਕੜੇ ਕੋਡ ਦੀ ਪੁਨਰਾਵ੍ਰੱਤੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਸੰਦ ਹਨ ਜਾਂ, ਜਿਵੇਂ ਕਿ ਇਹ ਕਹਿੰਦੇ ਹਨ, ਚੱਕਰ. ਜਾਵਾ ਵਿਚ ਸਾਈਕ ਚਲਾਉਣ ਵਾਲੇ ਆਪਰੇਟਰਾਂ ਦੁਆਰਾ ਪ੍ਰਤੀਨਿਧਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਅਤੇ ਇਸ ਦੇ ਨਾਲ ਹੀ ਉਨ੍ਹਾਂ ਦੀਆਂ ਕਿਸਮਾਂ. ਇੱਕ ਨਿਯਮ ਦੇ ਤੌਰ ਤੇ, ਚੱਕਰਾਂ ਨੂੰ ਇਕ-ਅਯਾਮੀ ਅਤੇ ਬਹੁ-ਅਗਾਮੀ ਐਰੇ ਅਤੇ ਰੁਕੇ ਹੋਏ ਡਾਟਾ ਢਾਂਚਿਆਂ (ਸੰਗ੍ਰਹਿ ਸਮੇਤ) ਪਾਸ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਉਹਨਾਂ ਦੇ ਨਾਲ ਕੁਝ ਖਾਸ ਤੱਤ ਲੱਭਣ ਅਤੇ ਹੋਰ ਓਪਰੇਸ਼ਨ ਹੋ ਸਕਣ. ਹਾਲਾਂਕਿ, ਇਹ ਸਿਰਫ ਇਕ ਸਾਧਨ ਨਹੀਂ ਹੈ ਜਿਵੇਂ ਕਿ ਜਾਪਾਨ ਲੂਪ. ਵਰਤਣ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦਿੱਤੀਆਂ ਜਾਣਗੀਆਂ ਜਿਵੇਂ ਉਨ੍ਹਾਂ ਨੂੰ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ.

ਸਾਈਕ, ਜਦੋਂ ਕਿ ਜਾਵਾ: ਵੇਰਵਾ ਅਤੇ ਉਦਾਹਰਣ

ਜਾਵਾ ਵਿੱਚ ਅੰਡਰਲਾਈੰਗ ਚੱਕਰ ਬਿਆਨ ਇਸ ਸਮੇਂ ਹੁੰਦਾ ਹੈ. ਸੱਚਾਈ ਦੇ ਲਾਜ਼ੀਕਲ ਮੁੱਲ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਉਸਦੇ ਬ੍ਰੈਕਟਾਂ ਨਾਲ ਜੁੜੇ ਐਕਸਪ੍ਰੈਸ ਕੀਤੇ ਸ਼ਬਦ ਦੀ ਸਥਿਤੀ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਇਆ ਜਾਵੇਗਾ, ਜਦੋਂ ਤਕ ਇਹ ਬ੍ਰੈਕਟਾਂ ਨਾਲ ਸਬੰਧਤ ਕੋਡ ਦੀ ਦੁਹਰਾ ਨਾ ਲਏਗਾ. ਜਦਕਿ ਕਥਨ ਦੇ ਆਮ ਰੂਪ ਹਨ:

ਜਦਕਿ (ਹਾਲਤ) {

// ਲੂਪ ਦੇ ਸਰੀਰ ਦਾ

}

ਜਿਵੇਂ ਹੀ ਲਾਜ਼ੀਕਲ ਅਵਸਥਾ ਦਾ ਮੁੱਲ ਸੱਚ ਸਾਬਤ ਹੁੰਦਾ ਹੈ, ਲੂਪ ਦੇ ਸਰੀਰ ਵਿੱਚ ਨੱਥੀ ਕੋਡ ਖ਼ਤਮ ਹੋ ਜਾਵੇਗਾ ਅਤੇ ਨਿਯੰਤ੍ਰਣ ਤੁਰੰਤ ਹੇਠਲੇ ਲਾਈਨ ਨੂੰ ਟਰਾਂਸਫਰ ਕੀਤਾ ਜਾਵੇਗਾ. ਜੇ ਚੱਕਰ ਦੇ ਸਰੀਰ ਵਿਚ ਕੇਵਲ ਇਕ ਓਪਰੇਟਰ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਬ੍ਰੇਸ ਨੂੰ ਸੈੱਟ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਪਰ ਜੇ ਇਹ ਹਮੇਸ਼ਾਂ ਖੜ੍ਹੇ ਹੋਵੇ ਤਾਂ ਇਸ ਨੂੰ ਇਕ ਚੰਗਾ ਫਾਰਮ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ. ਉਪਰੋਕਤ ਚਿੱਤਰ ਇਸ ਆਪਰੇਟਰ ਦੇ ਆਪਰੇਸ਼ਨ ਦੇ ਬਲਾਕ ਡਾਇਗ੍ਰਾਮ ਦਿਖਾਉਂਦਾ ਹੈ.

ਸਪੱਸ਼ਟਤਾ ਲਈ, ਆਓ, ਹੇਠਾਂ ਦਿੱਤੇ ਗਏ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਉਦਾਹਰਣ ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ:

ਘੋਸ਼ਿਤ ਕੀਤੀ ਵੇਅਰਿਏਬਲ ਗਿਣਤੀ ਵਿੱਚ ਸ਼ੁਰੂ ਵਿੱਚ 1 ਦਾ ਮੁੱਲ ਹੁੰਦਾ ਹੈ. ਅੱਗੇ, ਅਸੀਂ ਆਪਰੇਟਰ ਦੇ ਨਾਮ ਤੋਂ ਬਾਅਦ ਬਰੈਕਟਸਸ ਵਿੱਚ ਇੱਕ ਲਾਜ਼ੀਕਲ ਐਕਸਪਰੈਸ਼ਨ ਰੱਖ ਲਿਆ ਹੈ. ਇਹ ਸੱਚ ਹੈ, i. ਸੱਚਾ ਵਾਪਸ ਪਰਤੋ ਜਦ ਤੱਕ ਗਿਣਤੀ ਦੇ ਮੁੱਲ ਦੀ ਕੀਮਤ 10 ਤੋਂ ਘੱਟ ਜਾਂ ਇਸਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ. ਲੂਪ ਦੇ ਸਰੀਰ ਵਿੱਚ, ਹਰ ਇਕ ਆਵਾਜਾਈ ਦੇ ਨਾਲ, ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ 1 ਨਾਲ ਵੱਧਦਾ ਹੈ ਅਤੇ ਕੰਸੋਲ ਸਕ੍ਰੀਨ ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ. ਨੋਟ ਕਰੋ ਕਿ ਜਦੋਂ ਵੈਰੀਐਬਲ ਦੇ ਮੁੱਲ 11 ਰਹੇ ਹਨ, ਤਾਂ ਚੱਕਰ ਨੇ ਕੰਮ ਬੰਦ ਕਰ ਦਿੱਤਾ.

ਜੇ ਵੇਰੀਏਬਲ ਗਿਣਤੀ ਦਾ ਮੁੱਲ ਸ਼ੁਰੂ ਵਿਚ 11 ਦੇ ਬਰਾਬਰ ਸੀ, ਤਾਂ ਲੂਪ ਦੀ ਸਥਿਤੀ ਝੂਠੀ ਹੋਵੇਗੀ, ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਉਸ ਦੇ ਸਰੀਰ ਵਿਚ ਵੀ ਨਹੀਂ ਜਾਂਦਾ.

ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਜਾਵਾ ਸੰਟੈਕਸ ਤੁਹਾਨੂੰ ਸਰੀਰ ਦੇ ਬਗੈਰ ਦੌਰਾਨ ਕਥਨ ਦਾ ਇਸਤੇਮਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ. ਆਓ ਇਕ ਉਦਾਹਰਣ ਦੇਈਏ. ਮੰਨ ਲਓ ਸਾਡੇ ਕੋਲ ਦੋ ਵੈਰੀਏਬਲ i = 100 ਅਤੇ j = 200 ਹਨ, ਅਸੀਂ ਉਹਨਾਂ ਦੇ ਗਣਿਤਕ ਅਰਥ ਅਨੁਸਾਰ ਪ੍ਰੋਗਰਾਮ ਦੇ ਹਿਸਾਬ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਾਂ - ਤੁਸੀਂ "ਖੋਖਲੇ" ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਦੋਂ ਕਿ:

ਜਦਕਿ (++ i <- j);

ਨਤੀਜੇ ਵਜੋਂ, ਦੋ ਵੇਰੀਏਬਲਾਂ ਦਾ ਮੁੱਲ ਉਨ੍ਹਾਂ ਦੇ ਮੂਲ ਮੁੱਲਾਂ ਦੇ ਔਸਤ ਦੇ ਬਰਾਬਰ ਹੋਵੇਗਾ. ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਚੱਕਰ ਸਰੀਰ ਤੋਂ ਬਿਨਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਸ਼ਰਤ ਦੇ ਪ੍ਰਗਟਾਵੇ ਵਿੱਚ ਸਾਰੇ ਜ਼ਰੂਰੀ ਕੰਮ ਕਰਦਾ ਹੈ.

Do-while ਲੂਪ

ਪਿਛਲੇ ਉਦਾਹਰਣਾਂ ਵਿੱਚ, ਜੇਕਰ ਕੰਡੀਸ਼ਨਲ ਐਕਸਪ੍ਰੈਸ ਸ਼ੁਰੂ ਵਿੱਚ ਝੂਠ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਗਿਆ, ਤਾਂ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਲੂਪ ਦੇ ਸਰੀਰ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਅੱਗੇ ਵਧਿਆ ਜਾਵੇਗਾ. ਹਾਲਾਂਕਿ, ਅਕਸਰ ਅਜਿਹੀਆਂ ਸਥਿਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਜਿਸ ਵਿੱਚ ਕੰਡੀਸ਼ਨਲ ਐਕਸਪ੍ਰੈਸ ਦੀ ਵੈਧਤਾ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਘੱਟੋ ਘੱਟ ਇੱਕ ਵਾਰ, ਲੂਪ ਦੇ ਸਰੀਰ ਵਿੱਚ ਮੌਜੂਦ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਅਜਿਹਾ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇੱਕ ਸ਼ਰਤੀਆ ਐਕਸਪ੍ਰੈਸ ਦੀ ਵੈਧਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨਾ ਸ਼ੁਰੂ ਵਿੱਚ ਜ਼ਰੂਰੀ ਨਹੀਂ, ਪਰ ਚੱਕਰ ਦੇ ਅੰਤ ਵਿੱਚ. ਇਹ ਸਹੂਲਤ ਇੱਕ ਕਿਸਮ ਦੇ ਦੁਆਰਾ ਮੁਹੱਈਆ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਕਰਨ ਦੌਰਾਨ-ਕਰਦੇ ਹੋਏ ਲੂਪ ਕਰਦੇ ਹਨ ਇਸ ਵਿੱਚ ਹੇਠ ਦਿੱਤੇ ਰੂਪ ਹਨ:

ਕੀ {
// ਲੂਪ ਦੇ ਸਰੀਰ ਦਾ

} ਜਦਕਿ (ਹਾਲਤ);

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ, ਲੂਪ ਬਾਡੀ ਪਹਿਲਾਂ ਚਲਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਫਿਰ ਕੰਡੀਸ਼ਨ ਦੀ ਸਚਾਈ ਦੀ ਤਸਦੀਕ ਕੀਤੀ ਗਈ ਹੈ- ਅਤੇ ਇਸ ਤਰਾਂ ਹਰ ਇਟਰੇਸ਼ਨ ਤੇ.

ਉਪਰੋਕਤ ਕੋਡ ਆਮ ਤੌਰ ਤੇ ਉਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰੇਗਾ ਜਿਵੇਂ ਕਿ ਆਮ ਸਮਾਂ. ਹਾਲਾਂਕਿ, ਜੇ ਅਸੀਂ ਕਾਊਂਟ ਵੈਰੀਏਬਲ 11 ਦਾ ਮੁੱਲ ਦਿੱਤਾ ਹੈ, ਤਾਂ ਲੂਪ ਬਾਡੀ ਅਜੇ ਵੀ ਇੱਕ ਵਾਰ ਐਕਜ਼ੀਕਿਯੂਟ ਕੀਤੀ ਜਾਏਗੀ ਜਦੋਂ ਤੱਕ ਓਪਰੇਟਰ ਐਕਸਪ੍ਰੈਸ ਦੀ ਵੈਧਤਾ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਕਰ ਸਕਦਾ.

ਜਾਵਾ ਚੱਕਰ ਲਈ ਵੇਰਵਾ ਅਤੇ ਉਦਾਹਰਨਾਂ

ਲੌਪ ਲਈ ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਵਿਆਪਕ ਅਤੇ ਕੁਸ਼ਲ ਭਾਸ਼ਾ ਫਾਰਮ ਹੈ. ਜਾਵਾ ਐਸਡੀਕੇ ਦੇ ਪੰਜਵੇਂ ਸੰਸਕਰਣ ਤੋਂ ਪਹਿਲਾਂ, ਸਟੇਟਮੈਂਟ ਦੇ ਲਈ ਕੇਵਲ ਇਕ ਹੀ ਪ੍ਰੰਪਰਾਗਤ ਰੂਪ ਸੀ ਅਤੇ ਫਿਰ ਹਰੇਕ ਲਈ ਇੱਕ ਨਵਾਂ. ਇਸ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਆਪਰੇਟਰ ਦੇ ਰਵਾਇਤੀ ਢੰਗ ਨਾਲ ਜਾਣੂ ਹੋਵਾਂਗੇ. ਜਾਵਾ ਲਈ, ਲੂਪ ਇਸ ਤਰਾਂ ਵੇਖਦਾ ਹੈ:

ਕੰਟ੍ਰੋਲ ਨੂੰ ਲੂਪ ਦੇ ਸਰੀਰ ਵਿਚ ਕੋਡ ਨੂੰ ਪਾਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਕਾਊਂਟਰ ਦੇ ਰੂਪ ਵਿਚ ਕੰਮ ਕਰਨ ਵਾਲੇ ਵੇਰੀਏਬਲ ਦਾ ਆਰੰਭ ਕਰਨਾ ਪਹਿਲੀ ਵਾਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਅਗਲਾ, ਅਸੀਂ ਕੰਡੀਸ਼ਨਲ ਐਕਸ਼ਨਸ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ, ਜਿਸ ਵਿੱਚ ਕਾਊਂਟਰ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਵੈਲਯੂ ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਜੇ ਇਹ ਸੱਚ ਹੈ ਤਾਂ, ਲੂਪ ਬਾਡੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ. ਫਿਰ ਕਾਊਂਟਰ ਦਾ ਮੁੱਲ ਇਕ ਪੂਰਵ ਨਿਰਧਾਰਤ ਕਦਮ ਤੇ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕੰਡੀਸ਼ਨਲ ਐਕਸਪਰੈਸ਼ਨ ਦੁਬਾਰਾ ਚੈੱਕ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇੰਨੀ ਦੇਰ ਤਕ ਜਦੋਂ ਤਕ ਇਹ ਸ਼ਰਤ ਝੂਠੀ ਬਣ ਜਾਂਦੀ ਹੈ. ਹੇਠਾਂ ਪ੍ਰਵਾਹਚੱਕਰ ਦੇ ਚੱਕਰ ਦੇ ਸਾਰੇ ਪੜਾਵਾਂ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ ਹੈ.

ਬਿਹਤਰ ਸਮਝ ਲਈ, ਆਓ ਇਸਦਾ ਇਕ ਉਦਾਹਰਣ ਦੇਈਏ ਕਿ ਜਾਵਾ ਲੂਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

ਅਸੀਂ ਵੇਖਦੇ ਹਾਂ ਕਿ ਲੂਪ-ਵੇਲ ਵੇਅਰਿਏਬਲ ਨੂੰ ਕਾਊਂਟਰ ਦੇ ਤੌਰ ਤੇ ਇਸਤੇਮਾਲ ਕੀਤਾ ਗਿਆ ਹੈ. ਲੂਪ ਦੇ ਹਰੇਕ ਆਵਾਜਾਈ ਦੇ ਬਾਅਦ, ਇਸਦਾ ਮੁੱਲ 1 ਤੋਂ ਵਧ ਜਾਵੇਗਾ, ਅਤੇ ਇਹ ਉਦੋਂ ਤੱਕ ਆ ਜਾਵੇਗਾ ਜਦੋਂ ਤਕ ਇਹ 11 ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ ਹੈ. ਧਿਆਨ ਦਿਓ ਕਿ ਨਿਯੰਤਰਣ ਵੇਰੀਏਬਲ ਨੂੰ for ਸਟੇਟਮੈਂਟ ਤੋਂ ਬਾਹਰ ਵੀ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਜੇ ਤੁਸੀਂ ਇਸ ਵੇਰੀਬਲ ਨੂੰ ਕਿਸੇ ਵੀ ਥਾਂ ਤੇ ਇਸਤੇਮਾਲ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ ਲੂਪ ਵਿੱਚ, ਇਸ ਨੂੰ ਬਿਆਨ ਵਿੱਚ ਸਿੱਧਾ ਘੋਸ਼ਿਤ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਹ ਧਿਆਨ ਵਿਚ ਰੱਖੋ ਕਿ ਸਟੇਟਮੈਂਟ ਵਿਚ ਘੋਸ਼ਿਤ ਵੇਅਰਿਏਬਲ ਦੀ ਇਕੋ ਜਿਹੀ ਲੂਪ ਦੇ ਵਿਚ ਇਕ ਗੁਣਾ ਹੈ.

ਅਜਿਹੇ ਹਾਲਾਤ ਹਨ ਜਿੱਥੇ ਤੁਸੀਂ ਕਈ ਲੂਪ ਨਿਯੰਤਰਣ ਵੇਅਰਿਏਬਲ ਘੋਸ਼ਣਾ ਚਾਹੁੰਦੇ ਹੋ. ਜਾਵਾ ਲਈ, ਇੱਕ ਲੂਪ ਤੁਹਾਨੂੰ ਕੋਮਾ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ ਦੋ ਜਾਂ ਵੱਧ ਪਰਿਵਰਤਨਾਂ ਨੂੰ ਦਰਸਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਅਰੰਭ ਦੇ ਦੌਰਾਨ ਅਤੇ ਦੁਨਿਆਂ ਦੌਰਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਅਜਿਹੇ ਇੱਕ ਓਪਰੇਟਰ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਰੂਪ ਹੋਣਗੇ:

ਲਈ (int i = 1, int j = 10; i

ਹਰੇਕ ਦੁਹਰਾਉਣ ਤੇ, ਮੈਂ ਦਾ ਮੁੱਲ 1 ਨਾਲ ਵਧੇਗਾ, ਅਤੇ ਜੇ ਦਾ ਮੁੱਲ 1 ਨਾਲ ਘੱਟ ਜਾਵੇਗਾ. ਦੁਹਰਾਓ ਉਦੋਂ ਤੱਕ ਲਾਗੂ ਹੋਣਗੇ ਜਦੋਂ ਤੱਕ ਮੈਂ ਜੰਮਣ ਨਾਲੋਂ ਜਿਆਦਾ ਜਾਂ ਇਸਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੋ ਜਾਂਦਾ.

ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਫੀਚਰ

ਇਸ ਲਈ ਲੂਪ ਇਕ ਬਹੁਤ ਹੀ ਲਚਕੀਲਾ ਬਣਤਰ ਹੈ, ਕਿਉਂਕਿ ਇਸਦੇ ਤਿੰਨ ਹਿੱਸਿਆਂ (ਸ਼ੁਰੂਆਤ, ਸ਼ਰਤ ਅਤੇ ਵਾਧਾ / ਹਦਬੰਦੀ) ਨੂੰ ਇਸ ਦੇ ਉਦੇਸ਼ ਲਈ ਵਰਤਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ. ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਕੰਡੀਸ਼ਨਲ ਐਕ੍ਸਪ੍ਰੈੱਸ਼ਨ ਦੀ ਬਜਾਏ ਕੰਟ੍ਰੋਲ ਵੈਰੀਐਬਲ ਨਾਲ, ਤੁਸੀਂ ਕੋਈ ਲਾਜ਼ੀਕਲ ਵੈਰੀਏਬਲ ਬਦਲ ਸਕਦੇ ਹੋ.

ਬੂਲੀਅਨ exit = false;

(Int i = 0;; ਬਾਹਰ;; ++ i) ਲਈ {

Exit = true;

}

ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਕਿਵੇਂ ਲੂਪ ਦਾ ਸੰਚਾਲਨ ਨਿਯੰਤ੍ਰਣ ਵੇਰੀਏਬਲ ਦੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸੁਤੰਤਰ ਹੈ ਅਤੇ ਇਸਦੀ ਦੁਹਰਾਏ ਜਾਣ ਦੀ ਗਿਣਤੀ ਇਸ ਗੱਲ ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਕਦੋਂ ਐਗਜ਼ੀਟਾ ਵੇਰੀਏਬਲ ਸਹੀ ਹੋਵੇਗਾ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕੰਟਰੋਲ ਵਾਇਰਲ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲੂਪ ਤੋਂ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸ ਨਾਲ ਇਸ ਦੇ ਕੰਮ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦਾ: ਲਈ (;; Exit;) {} ਹਾਲਾਂਕਿ ਇਹ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਸਭ ਤੋਂ ਵਾਜਬ ਤਰੀਕਾ ਨਹੀਂ ਹੈ, ਕਈ ਵਾਰ ਇਹ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ. ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਉਹ ਅਜਿਹੀ ਸਥਿਤੀ ਪ੍ਰਦਾਨ ਕਰਨਾ ਹੈ ਜਿਸ ਵਿਚ ਵੇਰੀਏਬਲ ਲੂਪ ਤੋਂ ਬਾਹਰ ਆਉਣ ਲਈ ਜ਼ਰੂਰੀ ਮੁੱਲ ਲੈ ਲਵੇਗਾ, ਤਾਂ ਕਿ ਇਸ ਨੂੰ ਅਨੰਤ ਵੈਲਯੂ ਵਿੱਚ ਬਦਲ ਨਾ ਸਕੇ.

ਜਾਵਾ ਲਈ, ਇੱਕ ਲੂਪ ਇਸ ਤਰੀਕੇ ਨਾਲ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ: for (;;) {} ਇਹ ਖਾਸ ਵਿਘਟਨ ਹਾਲਾਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਅਨੰਤ ਲੂਪ ਦੀ ਇੱਕ ਖਾਸ ਉਦਾਹਰਨ ਹੈ. ਇਸ ਕਿਸਮ ਦੇ ਚੱਕਰਾਂ ਨੂੰ ਕਿਵੇਂ ਵਿਘਨ ਦੇ ਬਾਰੇ, ਅਸੀਂ ਕੁਝ ਦੇਰ ਬਾਅਦ ਗੱਲ ਕਰਾਂਗੇ.

ਹਰੇਕ ਲਈ ਸਟਾਈਲ ਇਨ ਚੱਕਰ

ਫੋਰਚੈਕ ਜਾਵਾ ਲੂਪ ਨੂੰ ਹਮੇਸ਼ਾਂ ਇਕ ਐਰੇ ਦੇ ਤੱਤਾਂ ਜਾਂ ਕੁਝ ਡਾਟਾ ਢਾਂਚੇ ਰਾਹੀਂ ਖੋਜਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਤੇ ਕੁਝ ਦੁਹਰਾਵੇਂ ਕਿਰਿਆਵਾਂ ਕਰਦੇ ਹਨ. ਬਿਆਨ ਲਈ ਇਸ ਫਾਰਮ ਦਾ ਇੱਕ ਉਦਾਹਰਣ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:

ਇੱਕ ਦੁਹਰਾਉਣ ਵਾਲੇ ਵੇਰੀਏਬਲ ਦੇ ਤੌਰ ਤੇ, ਨਾਮ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਨਾਮਾਂ ਦੇ ਪਹਿਲਾਂ ਐਲਾਨ ਕੀਤੇ ਗਏ ਐਰੇ ਆਪਰੇਟਰ ਦਾ ਦੂਜਾ ਦਲੀਲ ਹੈ. ਵੇਰੀਏਬਲ ਨਾਂ ਇਕ ਸਮੇਂ ਇਕ ਵਿਚ ਐਰੇ ਦੇ ਹਰੇਕ ਐਲੀਮੈਂਟ ਦੇ ਮੁੱਲ ਲੈ ਲਵੇਗਾ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਸਾਰੇ ਤੱਤ ਐਕਸਟਰੈਕਟ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ. ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਨੂੰ ਅਰੇ ਵਿਚ ਸਟੋਰ ਕੀਤੇ ਗਏ ਤੱਤਾਂ ਦੇ ਪ੍ਰਕਾਰ ਨਾਲ ਅਨੁਕੂਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਸਦੇ ਨਾਲ, ਨਾਮ ਵੇਰੀਏਬਲ ਸਿਰਫ ਪੜਨ ਲਈ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਇਹ ਐਰੇ ਵਿਚਲੀ ਐਲੀਮੈਂਟ ਨੂੰ ਨਹੀਂ ਬਦਲੇਗਾ.

ਸਾਈਕਲ ਇੰਟਰੱਪਟ ਓਪਰੇਟਰ

ਲੂਪ ਲਈ ਤਿੰਨ ਇੰਟਰੱਪਟ ਸਟੇਟਮੈਂਟਾਂ ਹਨ: ਬਰੇਕ, ਵਾਪਸੀ, ਅਤੇ ਜਾਰੀ ਰੱਖੋ. ਪਹਿਲੇ ਦੋ ਲੂਪ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵਿਘਨ ਦੇ ਯੋਗ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਮੌਜੂਦਾ ਰੀਸਟਰੇਸ਼ਨ ਦੇ ਸਿਰਫ਼ ਸੰਚਾਲਨ ਨੂੰ ਜਾਰੀ ਰੱਖਦੇ ਹਨ. ਜੇ ਤੁਸੀਂ ਆਪਣੇ ਕੋਡ ਵਿਚ ਬੁੱਝ ਕੇ ਅਨੰਤ ਜਾਵਾ ਚੱਕਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਓਪਰੇਟਰ ਇਸ ਵਿਚ ਮੌਜੂਦ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ. ਬਰੇਕ ਵਰਤਣ ਦੀ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਤੇ ਵਿਚਾਰ ਕਰੋ:

ਭਾਵੇਂ ਸਟੇਟਮੈਂਟ ਲਈ ਇਸ ਵਿਚ 11 ਡੇਟਰੇਸ਼ਨ ਦਿੱਤੇ ਗਏ ਹਨ, ਕੇਵਲ 8 ਹੀ ਐਕਜ਼ੀਕਿਯੂਟ ਕੀਤੇ ਜਾਣਗੇ, ਜਦੋਂ ਕਾਊਂਟਰ I 7 ਸਾਲ ਦੀ ਸਥਿਤੀ ਵਿਚ, ਜਿਸ ਬਰੇਕ ਸਟੇਟਮੈਂਟ ਦਾ ਬਰੇਕ ਸਟੇਟਮੈਂਟ ਹੈ ਉੱਥੇ ਉਸ ਦੀ ਸਥਿਤੀ ਕੰਮ ਕਰੇਗੀ.

ਰਿਟਰਨ ਸਟੇਟਮੈਂਟ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ, ਇਸ ਦੇ ਨਾਲ ਫਰਕ ਇਹ ਹੈ ਕਿ ਇਹ ਨਾ ਕੇਵਲ ਜਾਵਾ ਲੂਪ ਤੋਂ ਬਾਹਰ ਨਿਕਲਦਾ ਹੈ, ਸਗੋਂ ਇਹ ਢੰਗ ਵੀ ਹੈ ਜਿਸ ਵਿੱਚ ਇਹ ਲੂਪ ਰੱਖਿਆ ਗਿਆ ਹੈ.

ਗੌਟ ਵਜੋਂ ਬ੍ਰੇਕ ਦੀ ਵਰਤੋਂ

ਇਹ ਇਸ ਗੱਲ ਨੂੰ ਧਿਆਨ ਵਿਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਬ੍ਰੇਕ ਨੂੰ ਉਸ ਸਰੀਰ ਵਿਚ ਸਿਰਫ ਚੱਕਰ ਦੇ ਕੰਮ ਵਿਚ ਰੁਕਾਵਟ ਹੈ ਜਿਸ ਦੀ ਸਿੱਧੀ ਇਹ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸਥਿਤ ਹੈ, i. ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ ਨੇਸਟੈਡ ਲੂਪ ਵਿੱਚ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਬਾਹਰੀ ਲੂਪ ਕੰਮ ਕਰਨਾ ਬੰਦ ਨਹੀਂ ਕਰੇਗਾ. ਇਸ ਲਈ, ਬਰੇਕ ਸਟੇਟਮੈਂਟ ਨੂੰ ਗੌਟ ਦੇ ਇੱਕ ਸਭਿਆਚਾਰਕ ਰੂਪ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.

ਇਸ ਵੇਰੀਏਂਟ ਵਿੱਚ, ਇਸ ਉਪਰੇਟਰ ਨੂੰ ਲੇਬਲ ਦੇ ਨਾਲ ਜੋੜ ਕੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਸਿਰਫ ਚੱਕਰਾਂ ਤੋਂ ਹੀ ਨਹੀਂ, ਪਰ ਕੋਡ ਦੇ ਕਿਸੇ ਵੀ ਬਲਾਕ ਤੋਂ ਆਉਟਪੁੱਟ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਇੱਕ ਲੇਬਲ ਇਸ ਤੋਂ ਬਾਅਦ ਇੱਕ ਕੌਲਨ ਦੇ ਨਾਲ ਢੁਕਵਾਂ ਨਾਂ ਪਛਾਣਕਰਤਾ ਹੈ ਲੇਬਲ ਕੋਡ ਦੇ ਚਿੰਨ੍ਹਿਤ ਬਲਾਕ ਦੀ ਸ਼ੁਰੂਆਤ ਤੇ ਐਲਾਨ ਕੀਤਾ ਗਿਆ ਹੈ. ਇੱਕ ਨਿਸ਼ਾਨਬੱਧ ਬਲਾਕ ਦੇ ਚੱਲਣ ਨੂੰ ਰੋਕਣ ਲਈ, ਸਹੀ ਜਗ੍ਹਾ ਤੇ, ਤੁਹਾਨੂੰ ਘੋਸ਼ਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ: break_name_name. ਹੇਠਲੇ ਚਿੱਤਰ ਵਿਚ ਉਦਾਹਰਨ 'ਤੇ ਗੌਰ ਕਰੋ:

ਕੋਡ ਕ੍ਰਮਵਾਰ ਲੇਬਲ ਇੱਕ, ਦੋ ਅਤੇ ਤਿੰਨ ਦੇ ਨਾਂ ਨਾਲ ਤਿੰਨ ਬਲਾਕਾਂ ਦੀ ਘੋਸ਼ਣਾ ਕਰਦਾ ਹੈ. ਦੋ ਲੇਬਲ ਦੇ ਬਰੇਕ ਸਟੇਟਮੈਂਟ ਨੂੰ ਸਾਰੇ ਤਿੰਨ ਬਲਾਕਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ, ਪਰ ਜਦੋਂ ਇਹ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਤਿੰਨ ਅਤੇ ਦੋ ਬਲਾਕਾਂ ਤੋਂ ਬਾਹਰ ਨਿਕਲਦਾ ਹੈ ਅਤੇ ਇੱਕ ਬਲਾਕ ਵਿੱਚ ਫਾਂਸੀ ਜਾਰੀ ਕਰਦਾ ਹੈ. Ie. ਕੰਸੋਲ ਵਿਚ ਅਸੀਂ ਦੋ ਸੰਦੇਸ਼ ਵੇਖਾਂਗੇ: ਤਿੰਨ ਅਤੇ ਇਕ.

ਸਿੱਟਾ

ਅਸੀਂ ਜਾਵਾ ਵਿੱਚ ਲੂਪਸ ਦੀ ਧਾਰਨਾ, ਮੁੱਖ ਸਮੇਂ ਅਤੇ ਸਟੇਟਮੈਂਟਾਂ, ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਅਤੇ ਹਰ ਇੱਕ ਫਾਰਮ ਲਈ, ਕ੍ਰਮਵਾਰ ਸਿੱਖਿਆ ਹੈ. ਬਿਹਤਰ ਸਮਝ ਲਈ, ਅਸੀਂ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਅਪਰੇਟਰਾਂ ਨੂੰ ਵੱਖ ਵੱਖ ਰੂਪਾਂ ਵਿੱਚ ਵਰਤ ਕੇ ਕਸਰਤਾਂ ਕਰੋ, ਅਤੇ ਨਾਲ ਹੀ ਉਨ੍ਹਾਂ ਨੂੰ ਰੋਕਣ ਦੇ ਵੱਖਰੇ ਤਰੀਕੇ ਅਤੇ ਇੱਕ ਬਲਾਕ ਤੋਂ ਦੂਜੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਵੋ