ਜਾਵਾ: ਅਪਵਾਦ ਹੈ ਅਤੇ ਆਪਣੇ ਪਰਬੰਧਨ

ਕੋਈ ਵੀ ਪ੍ਰੋਗਰਾਮ ਨੂੰ stably ਕੰਮ ਕਰੇਗਾ, ਸਿਰਫ ਜੇ ਸੋਰਸ ਕੋਡ debugged ਹੈ, ਅਤੇ ਕੋਈ ਵੀ ਹਾਲਾਤ, ਜੋ ਕਿ ਬੁਰਾ ਹਾਲਾਤ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ. ਸੰਭਵ ਅਸਫਲਤਾ ਫਲਾਈਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪੜਾਅ 'ਤੇ ਬਾਹਰ ਹੀ ਰਿਹਾ ਹੈ. ਇਹ ਕਰਨ ਲਈ, ਡਿਵੈਲਪਰ ਖਾਤੇ ਦੇ ਸਾਰੇ ਉਮੀਦ ਨਤੀਜੇ ਵਿੱਚ ਕਰਦਾ ਹੈ ਅਤੇ ਗਲਤੀ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਸੀਮਿਤ ਕਰਨ ਲਈ, ਇਸ ਲਈ ਹੈ, ਜੋ ਕਿ ਇਸ ਨੂੰ ਦੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਵਾਈ ਨਾਲ ਟਕਰਾ ਨਾ ਕਰ ਸਕਦਾ ਹੈ, ਜ ਇਸ ਦੇ ਢਹਿ ਕਰਨ ਦੀ ਅਗਵਾਈ ਕਰਦਾ ਹੈ.

ਤੁਹਾਨੂੰ ਅਪਵਾਦ ਪਰਬੰਧਨ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ, ਜਦ

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

ਜਾਵਾ ਅਪਵਾਦ ਦਾ ਕੰਟਰੋਲ

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

ਜਾਵਾ ਵਿੱਚ, ਇਸ ਕਰਤਾ ਨੇ ਲਗਾਇਆ ਹੈ ਇੱਕ ਅਪਵਾਦ ਨੂੰ ਫੜਨ ਲਈ ਹੈ, ਇਸ ਲਈ ਆਮ ਸਮੱਸਿਆ ਨੂੰ ਜਾਣਦੇ ਹਨ ਅਤੇ ਇੱਕ ਮਿਆਰੀ ਕਸਰਤ ਪੈਟਰਨ ਹੈ.

ਆਮ ਤੌਰ

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

ਨੂੰ ਕਾਰਵਾਈ ਕਰਨ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਰੋਕਿਆ ਨੂੰ ਜਾਵਾ ਵਿਧੀ ਇਸ ਨੂੰ ਦਿਸਦਾ ਹੈ:

• ਢੇਰ ਅਪਵਾਦ ਇਕਾਈ ਦੇ ਨਾਲ ਨਾਲ ਕਿਸੇ ਵੀ ਹੋਰ ਰੂਪ ਵਿੱਚ, ਨੂੰ ਬਣਾਇਆ ਹੈ;
• ਪ੍ਰੋਗਰਾਮ ਦੇ ਕੁਦਰਤੀ ਕੋਰਸ ਟੁੱਟ ਗਿਆ ਹੈ;
• ਬੇਦਖਲੀ ਵਿਧੀ ਕੋਡ ਜਾਰੀ ਕਰਨ ਲਈ ਇੱਕ ਬਦਲ ਤਰੀਕੇ ਦਾ ਪਤਾ ਕਰਨ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ;
• ਪ੍ਰੋਸੈਸਰ, ਕੰਮ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਦੇ ਇੱਕ ਸੁਰੱਖਿਅਤ ਚੱਲਣ ਲੱਭੋ ਜ ਨੂੰ ਮੁੜ, ਜ ਇੱਕ ਖਾਸ ਤਰੀਕੇ ਨਾਲ ਅਪਵਾਦ ਹੈ, ਦੇ ਬੋਧ ਹੋਵੇਗਾ.

ਇੱਕ ਗਲਤੀ ਬਣਾਉਣ ਲਈ ਇਸ ਵਰਗੇ ਹੀ ਹੋ ਸਕਦਾ ਦੀ ਸਧਾਰਨ ਉਦਾਹਰਨ:

ਜੇ (ਇੱਕ == ਨਾਜਾਇਜ਼)

ਨਵ NullPointerException ਸੁੱਟ ();

ਇੱਥੇ, ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਤੇ ਕੀਤੀ ਗਈ ਹੈ, ਭਾਵ, ਹੈ ਨਾ ਕਿ ਕੀ ਇੱਕ ਰੱਦ ਇਕਾਈ ਦਾ ਹਵਾਲਾ. ਇਸ ਸਥਿਤੀ ਪੈਦਾ ਹੈ ਅਤੇ ਖਾਸ ਪਰਬੰਧਨ ਦੀ ਲੋੜ ਹੈ, ਜੇ, ਇੱਕ ਅਪਵਾਦ ਨੂੰ ਇੱਕ ਸੁੱਟ ਨਵ NullPointerException ਕੇ ਸੁੱਟ ਦਿੱਤਾ ਗਿਆ ਹੈ ().

ਸ਼ਬਦ ਦੇ ਬਾਰੇ ਕੁਝ ਵੇਰਵੇ

ਜਦ ਅਪਵਾਦ ਦੇ ਨਾਲ ਨਜਿੱਠਣ ਅਕਸਰ ਕੀਵਰਡ ਜਾਵਾ ਨੂੰ ਵਰਤਣ ਲਈ ਇੱਕ ਖਾਸ ਕਾਰਵਾਈ ਕਰਨ ਲਈ ਵੇਖੋ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ. ਆਪਣੇ ਪੰਜ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਇਹ ਭਾਸ਼ਾ:

• ਕੋਸ਼ਿਸ਼ ਕਰੋ. ਇਹ ਕੀਵਰਡ ਹੈ ਹੀ ਮਿਲੇ, ਅਤੇ ਇਸ ਨੂੰ ਕੋਡ ਦਾ ਇੱਕ ਭਾਗ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟ ਸਕਦਾ ਹੈ ਵਿੱਚ ਇੱਕ ਤਬਦੀਲੀ ਦਾ ਮਤਲਬ ਹੈ. ਬਲਾਕ ਸੀਮਤ ਚ {}.
• ਕੈਚ. ਇਸ ਨੂੰ ਲੋੜੀਦੀ ਅਪਵਾਦ ਦੀ ਕਿਸਮ ਨੂੰ ਵੇਖਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਹੀ ਨੂੰ ਕੰਟਰੋਲ.
• ਅੰਤ ਵਿੱਚ. ਇਹ ਕੀਵਰਡ ਵਿਕਲਪਿਕ ਹੈ ਅਤੇ ਕੋਡ ਹੈ, ਜੋ ਕਿ ਕਿਸੇ ਵੀ ਲੋੜ ਹੈ ਦੀ ਇੱਕ ਨੂੰ ਕੁਝ ਟੁਕੜੇ ਕਰਨ ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ, ਵੀ, ਜੇ ਕੋਈ ਅਪਵਾਦ ਫੜਿਆ ਨਾ ਗਿਆ ਹੈ. ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਕੋਸ਼ਿਸ਼ ਬਲਾਕ ਦੇ ਬਾਅਦ ਜੋੜੇ.
• ਸੁੱਟ - ਤੁਹਾਨੂੰ ਕਿਤੇ ਵੀ ਜਾਵਾ ਅਪਵਾਦ ਬਣਾਉਣ ਲਈ ਸਹਾਇਕ ਹੈ.
• ਪਟਕਾ - ਇੱਕ ਕੀਵਰਡ ਹੈ, ਜੋ ਕਿ ਢੰਗ ਹੈ ਦਸਤਖਤ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ. ਇਹ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੇਠ ਕੋਡ ਇਸ ਕਿਸਮ ਜਾਵਾ ਦੇ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟ ਸਕਦਾ ਹੈ. ਢੰਗ ਨੂੰ ਉਸ ਦੀ ਉਮੀਦ ਮੁਤਾਬਕ ਕੰਮ ਨਾ ਕਰ ਸਕਦਾ ਹੈ - ਇਹ ਨਿਸ਼ਾਨ ਡਿਵੈਲਪਰ ਦੀ ਲੋੜ ਹੈ, ਜੋ ਕਿ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਕਰਨ ਲਈ ਇੱਕ ਸੰਕੇਤ ਦੇ ਤੌਰ ਤੇ ਸੇਵਾ ਕਰਦਾ ਹੈ.

ਇੱਕ ਕੋਸ਼ਿਸ਼ ਦੇ ਨਾਲ ਫਲਾਈਟ

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

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

ਪ੍ਰੋਸੈਸਿੰਗ ਯੂਨਿਟ ਨੂੰ ਸਭ ਆਮ ਕੋਡ ਇਸ ਪ੍ਰਕਾਰ ਹੈ:

ਕੋਸ਼ਿਸ਼ ਕਰੋ {

// ਕੁਝ ਕੋਡ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਅਪਵਾਦ ਬਣਾਉਣ ਸਕਦਾ ਹੈ

} ਕੈਚ (Tip_isklyucheniya_1 identifikator_1) {

// ਇੱਥੇ ਅਪਵਾਦ ਪਰਬੰਧਨ ਹੈ, ਇਸ ਦੀ ਕਿਸਮ ਅਤੇ ਹਾਲਾਤ ਅਨੁਸਾਰ;

} ਕੈਚ (Tip_isklyucheniya_2 identifikator_2) {

// ਇੱਥੇ ਅਪਵਾਦ ਪਰਬੰਧਨ ਹੈ, ਇਸ ਦੀ ਕਿਸਮ ਅਤੇ ਹਾਲਾਤ ਅਨੁਸਾਰ;

}

ਕੀਵਰਡ ਕੈਚ ਹੈ, ਜੋ ਕਿ ਕੋਡ ਦੀ ਰਿਪੋਰਟ ਹੈ, ਅਤੇ ਇੱਕ ਅਪਵਾਦ ਦੇ ਲਈ ਇਸ ਨੂੰ ਸਕੈਨ, ਦੇ ਤੌਰ ਤੇ ਹੇਠ ਦਿੱਤੇ ਇਲਾਜ ਕੀਤਾ ਜਾ ਕਰਨ ਲਈ, ਬਸ਼ਰਤੇ ਕਿ ਇਸ ਨੂੰ ਇਸ ਦੀ ਕਿਸਮ ਦੀ ਪਾਲਣਾ. ਪਛਾਣਕਰਤਾ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ਤੇ ਕੋਡ ਬਲਾਕ ਕਾਰਵਾਈ ਕਰਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.

ਅੰਤ

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

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

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

ਸੁੱਟ ਕੀਵਰਡ

ਸੁੱਟ ਇੱਕ ਅਪਵਾਦ ਬਣਾਉਦੀ ਹੈ. ਇਸ ਦਾ ਸੰਟੈਕਸ ਇਸ ਪ੍ਰਕਾਰ ਹੈ:

ਨਵ NewException ਸੁੱਟ ();

ਦੀ ਕਿਸਮ NewException ਕਰਨ ਲਈ ਇੱਕ ਨਵ ਅਪਵਾਦ ਉਪਲਬਧ ਬਣਾਇਆ ਗਿਆ ਹੈ (). ਇੱਕ ਕਿਸਮ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਹੀ ਮਿਆਰੀ ਜਾਵਾ ਲਾਇਬਰੇਰੀ ਕਲਾਸ ਵਿਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਪਿਛਲੀ ਇਸ ਦੇ ਆਪਣੇ ਹੀ ਦੇ ਉਤਪਾਦਨ ਦੇ ਡਿਵੈਲਪਰ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਹੈ.

ਇਹ ਡਿਜ਼ਾਇਨ ਨੂੰ ਕਿਸੇ ਵੀ ਢੰਗ ਦਾ ਵੇਰਵਾ, ਜੋ ਕਿ ਕਾਲ ਫਿਰ ਕੋਸ਼ਿਸ਼ ਬਲਾਕ ਦੇ ਅੰਦਰ ਵਾਪਰ ਚਾਹੀਦਾ ਹੈ, ਇਸ ਨੂੰ ਰੋਕਿਆ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ ਦਾ ਹਿੱਸਾ ਹੈ.

ਕੀਵਰਡ ਸੁੱਟ

ਕੀ ਜਿੱਥੇ ਇੱਕ ਦੀ ਸਥਿਤੀ ਦਾ ਢੰਗ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟ ਸਕਦਾ ਹੈ, ਪਰ ਸਹੀ ਢੰਗ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਯੋਗ ਨਹੀ ਹਨ ਦੇ ਵਿਕਾਸ ਦੀ ਪ੍ਰਕਿਰਿਆ 'ਚ ਹੈ. ਇਸ ਨੂੰ ਅੰਤ ਵਿੱਚ ਕਰਨ ਲਈ, ਢੰਗ ਹੈ ਦਸਤਖਤ ਵਿੱਚ ਨਿਰਧਾਰਿਤ ਕਰਦੀ ਹੈ ਸ਼ਬਦ ਦਾ ਸੁੱਟ ਅਤੇ ਸੰਭਵ ਅਪਵਾਦ ਦੀ ਕਿਸਮ.

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

ਵਸੀਲੇ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਜਾਵਾ ਵਰਜਨ 7 ਡਿਵੈਲਪਰ ਵਸੀਲੇ ਨਾਲ ਇਲਾਜ ਕੋਸ਼ਿਸ਼ ਬਲਾਕ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਵੱਡਾ ਨਵੀਨਤਾ, ਵੀ ਸ਼ਾਮਲ ਹੈ.

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

ਆਪਣੀ ਕਲਾਸ ਜਾਵਾ ਅਪਵਾਦ

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

ਸਧਾਰਨ ਤਰੀਕੇ ਨਾਲ ਬਣਾਉਣ ਲਈ - ਇਕਾਈ ਪ੍ਰਸੰਗ ਨੂੰ ਸਭ ਉਚਿਤ ਤੱਕ ਪਾਉਣ ਲਈ.

ਉੱਥੇ, ਅਪਵਾਦ ਤੱਕ ਵਾਰਸ ਨੂੰ ਕੀ ਹੋਇਆ ਕਲਾਸ ਹੈ, ਜੋ ਕਿ ਆਪਣੇ ਹੀ ਅਪਵਾਦ ਨੂੰ ਪ੍ਰਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ. ਇੱਕ ਮੂਲ, ਦੂਜਾ - - ਦਲੀਲ MSG ਕਿਸਮ ਦੇ ਸਤਰ ਨਾਲ MyException ਵਿੱਚ ਦੋ ਕੰਸਟਰੱਕਟਰ ਹਨ.

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

ਦੂਜਾ ਢੰਗ ਹੈ ਪਹਿਲੇ ਇੱਕ ਹੈ, ਜੋ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਅਪਵਾਦ ਬਣਾਉਣ ਲਈ, ਇਸ ਨੂੰ ਸਤਰ ਪੈਰਾਮੀਟਰ ਪਾਸ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਫਲਾਈਟ 'ਤੇ ਕੰਸੋਲ ਵਿੱਚ ਪ੍ਰਤੀਬਿੰਬਿਤ ਕੀਤਾ ਜਾਵੇਗਾ ਥੋੜ੍ਹਾ ਵੱਖ ਹੁੰਦਾ ਹੈ. ਮੁੱਖ ਵਿਚ ਇਹ ਸਪਸ਼ਟ ਹੈ ਕਿ f () ਅਤੇ g () ਇੱਕ ਕੋਸ਼ਿਸ਼ ਚੈਕਿੰਗ ਵਿੱਚ ਰੱਖੇ ਗਏ ਹਨ ਅਤੇ ਕੀਵਰਡ ਕੈਚ MyException ਨੂੰ ਹਾਸਲ ਕਰਨ ਲਈ ਸੰਰਚਿਤ ਹੈ. ਨੂੰ ਕਾਰਵਾਈ ਕਰਨ ਦੇ ਨਤੀਜੇ ਕੰਸੋਲ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਦਿਸਦਾ ਹੈ:

ਇਸ ਲਈ ਇਸ ਨੂੰ ਜਾਵਾ ਅਪਵਾਦ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਲਈ, ਉਸ ਦੇ ਆਪਣੇ ਹੱਥ ਦੇ ਕੇ ਆਇਆ ਸੀ.

ਆਰਕੀਟੈਕਚਰ ਅਪਵਾਦ

ਜਾਵਾ ਵਿੱਚ ਸਭ ਆਬਜੈਕਟ ਦੇ ਨਾਲ ਦੇ ਰੂਪ ਵਿੱਚ, ਅਪਵਾਦ ਨੂੰ ਵੀ ਵਿਰਸੇ ਵਿਚ ਹੈ ਅਤੇ ਇੱਕ ਲੜੀ ਬਣਤਰ ਹੈ ਕਰ ਰਹੇ ਹਨ. ਇਸ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਸੁੱਟ ਸਾਰੇ ਗਲਤੀ ਦੇ ਰੂਟ ਤੱਤ ਕਲਾਸ java.lang.Throwable ਹੈ. ਉਸ ਨੂੰ ਦੋ ਕਿਸਮ ਦੇ ਵਿਰਸੇ - ਗਲਤੀ ਹੈ ਅਤੇ ਅਪਵਾਦ.

ਗਲਤੀ - ਘਾਤਕ ਗਲਤੀ ਦਾ ਸੰਕੇਤ ਹੈ ਅਤੇ ਚੋਣ ਨਾ ਜਾਵਾ ਅਪਵਾਦ ਹੈ. ਵਿਘਨ ਅਤੇ ਸਭ ਮਾਮਲੇ ਵਿੱਚ ਕਾਰਵਾਈ ਕਰਨ ਲਈ ਅਜਿਹੇ ਡਾਟਾ ਡਿਜ਼ਾਇਨ ਪੜਾਅ 'ਤੇ ਹੁੰਦੀ ਹੈ ਅਤੇ ਫਾਈਨਲ ਕਾਰਜ ਨੂੰ ਕੋਡ ਵਿਚ ਸ਼ੁਰੂਆਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਨਾ.

ਸਭ ਆਮ ਵਰਤੇ ਬਣਾਉਣ ਅਤੇ ਅਪਵਾਦ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਕਲਾਸ ਅਪਵਾਦ ਹੈ. ਕਿਹੜੇ, ਬਦਲੇ ਵਿੱਚ, RuntimeException ਸਮੇਤ ਕਈ ਸ਼ਾਖਾ, ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ. ਕੇ RuntimeException ਰੰਨਟਾਈਮ ਅਪਵਾਦ, ਪ੍ਰੋਗਰਾਮ ਦੇ ਦੌਰਾਨ ਵਾਪਰਨ ਹਨ, ਜੋ ਕਿ ਹੈ. ਇਸ ਨੂੰ ਤੱਕ ਲਿਆ ਸਾਰੇ ਕਲਾਸ ਤਸਦੀਕ ਕਰਦੇ ਹਨ.

ਅਕਸਰ ਉਥੇ ਅਪਵਾਦ ਹਨ

ਜਾਵਾ ਅਪਵਾਦ ਵਿੱਚ, ਜੋ ਕਿ ਦੀ ਸੂਚੀ ਹੇਠ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ,, ਸਭ ਅਕਸਰ ਵਰਤਿਆ ਜਾਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਵਿਸਥਾਰ ਵਿੱਚ ਯਿਸੂ ਦੇ ਹਰ ਦਾ ਵਰਣਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

• ArithmeticException. ਇਹ ਹਿਸਾਬ ਓਪਰੇਸ਼ਨ ਨਾਲ ਸੰਬੰਧਿਤ ਗਲਤੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ. ਸਭ ਖੜਦੇ ਮਿਸਾਲ - ਜ਼ੀਰੋ ਨਾਲ ਵੰਡਿਆ ਜਾਵੇ.
• ArrayIndexOutOfBoundsException - ਐਰੇ ਤੱਤ ਦਾ ਨੰਬਰ ਹੈ, ਜੋ ਕਿ ਇਸ ਦੀ ਲੰਬਾਈ ਦੇ ਕੁੱਲ ਵੱਧ ਨੂੰ ਅਪੀਲ.
• ArrayStoreException - ਐਰੇ ਦੇ ਅਨੁਕੂਲ ਤੱਤ ਦੀ ਕਿਸਮ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼.
• ClassCastException - ਦੂਜੇ ਨੂੰ ਨੁਕਸਾਨ ਪਹੁੰਚਾ ਦੀ ਕਿਸਮ ਲਿਆਉਣ ਦਾ ਜਤਨ ਹੈ.
• IllegalArgumentException - ਢੰਗ ਦੀ ਕਾਲ ਵਿਚ ਗ਼ਲਤ ਦਲੀਲ ਨੂੰ ਵਰਤ.
• NegativeArraySizeException - ਇੱਕ ਅਪਵਾਦ ਤੁਹਾਨੂੰ ਨਕਾਰਾਤਮਕ ਆਕਾਰ ਦੇ ਇੱਕ ਐਰੇ ਬਣਾਉਣ.
• NullPointerException - ਹਵਾਲੇ ਦਾ ਗ਼ਲਤ NULL ਹੈ.
• NumberFormatException - ਵਾਪਰਦਾ ਹੈ ਪੂਰਨ ਅੰਕ 'ਚ ਗਲਤ ਸਤਰ ਤਬਦੀਲੀ ਹੈ.
• UnsupportedOperationException - ਓਪਰੇਸ਼ਨ ਸਹਾਇਕ ਨਹੀ ਹੈ.

ਇਹ ਉਦਾਹਰਣ ਚੁਣਿਆ ਨਾ ਜਾਵਾ ਅਪਵਾਦ ਦੀ ਕਿਸਮ ਦੀ ਪ੍ਰਤੀਨਿਧਤਾ. ਪਰ ਇਸ ਲਈ ਕੀਤੀ ਗਈ ਲਗਦੀ ਹੈ:

• ClassNotFoundException - ਕਲਾਸ ਵਿੱਚ ਨਾ ਲੱਭਿਆ.
• IllegalAcccessException - ਕਲਾਸ ਤੱਕ ਪਹੁੰਚ ਤੇ ਪਾਬੰਦੀ.
• InterruptedException - ਵਹਾਅ ਦੇ ਦਖਲ ਦੀ.
• NoSuchFieldException - ਕੋਈ ਵੀ ਇਸ ਦੀ ਲੋੜ ਹੈ ਖੇਤਰ ਹਨ.

ਅਪਵਾਦ ਦੀ ਵਿਆਖਿਆ

ਅਕਸਰ ਆਈ ਅਪਵਾਦ ਦੀ ਗੱਲ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਡਿਜ਼ਾਇਨ ਵਿੱਚ ਆਪਣੇ ਵਿਆਖਿਆ, ਗਲਤ ਸਮਝਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਅੱਗੇ ਇੱਕ ਛੋਟਾ ਹੋਰ ਵਿਸਥਾਰ, ਜਿੱਥੇ ਅਚਾਨਕ ਸਥਿਤੀ ਨੂੰ ਵੀ ਹੋ ਸਕਦਾ ਹੈ ਨੂੰ ਸਮਝਾਉਣ ਸੂਚੀ ਹੈ.

NullPointerException. ਬਹੁਤ ਹੀ ਪਹਿਲੇ ਕੇਸ ਇੱਕ ਅਪਵਾਦ ਹੈ, ਇੱਕ ਇਕਾਈ ਹੈ, ਜੋ ਕਿ NULL ਦੇ ਬਰਾਬਰ ਹੈ ਦਾ ਹਵਾਲਾ ਨੂੰ ਅਪੀਲ ਕਰਨ ਲਈ ਹੈ. ਇਸ ਵਿਚ ਇਹ ਵੀ ਜ਼ੀਰੋ ਕਲਾਸ ਮਿਸਾਲ ਢੰਗ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ. NullPointerException ਇੱਕ ਬਰਾਬਰ ਲੰਬਾਈ ਨਾਜਾਇਜ਼ ਐਰੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਮਾਮਲੇ 'ਚ ਸੁੱਟਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਲਗਾਤਾਰ ਪ੍ਰਭਾਵਹੀਣ ਤੇ ਸਾਈਟ ਚੈੱਕ ਜਾਵੇਗਾ ਅਜਿਹੇ ਹਾਲਾਤ ਬਚਣ ਲਈ.

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

ਰਿਪੋਰਟ

ਜਾਵਾ ਅਪਵਾਦ ਦਾ ਕੰਟਰੋਲ - ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੰਦ ਹੈ ਵਾਤਾਵਰਣ ਨੂੰ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਪਰੋਗਰਾਮਰ ਦੇ ਕੰਮ ਦੀ ਸਹੂਲਤ ਹੈ ਅਤੇ ਉਸ ਨੂੰ ਇੱਕ ਸਾਫ਼ ਅਤੇ ਕੋਡ ਗਲਤੀ ਦੀ ਸਬੂਤ ਬਣਾਉਣ ਲਈ ਸਹਾਇਕ ਹੈ. ਨੂੰ ਨਿਰਵਿਘਨ ਅਤੇ ਸਥਿਰ ਕੰਮਕਾਜ ਦੀ ਅਰਜ਼ੀ 'ਤੇ ਸਥਿਤੀ ਅਤੇ ਡਿਵੈਲਪਰ ਦੇ ਵੱਕਾਰ' ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ.

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

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