Netbeans/C2/Netbeans-Debugger/Punjabi

From Script | Spoken-Tutorial
Jump to: navigation, search
Time Narration
00:01 ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ ਦੋਸਤੋ ।
00:02 Netbeans Debugger ਦੇ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਡਾ ਸਾਰਿਆ ਦਾ ਸਵਾਗਤ ਹੈ ।
00:06 ਜੇ ਤੁਸੀਂ Netbeans ਦੀ ਵਰਤੋਂ ਪਹਿਲੀ ਵਾਰ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਕ੍ਰਿਪਾ ਕਰਕੇ Spoken Tutorial ਵੈੱਬਸਾਈਟ ‘ਤੇ ਪਿਛਲੇ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਵੇਖੋ ।
00:14 ਇਸ ਦੇ ਲਈ, ਮੈਂ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹਾਂ ਲਿਨਕਸ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਊਬੰਟੂ v12.04,
00:21 ਅਤੇ Netbeans IDE v7.1.1
00:26 ਅਸੀਂ ਸਾਰੇ ਜਾਣਦੇ ਹਾਂ, ਪ੍ਰੋਗਰਾਮਸ debugg ਕਰਨਾ ਮਿਹਨਤ ਵਾਲਾ ਕੰਮ ਹੋ ਸਕਦਾ ਹੈ ।
00:31 ਇਸ ਲਈ, debugging ਟੂਲ ਦੇ ਬਾਰੇ ਵਿੱਚ ਜਾਣਨਾ ਅਤੇ ਇਸਦੇ ਫੀਚਰਸ ਦੇ ਨਾਲ ਜਾਣੂ ਹੋਣਾ, ਤੁਹਾਡੇ ਮਹੱਤਵਪੂਰਣ ਸਮੇਂ ਦੀ ਬਚਤ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ ।
00:39 ਇਹ ਸ਼ਕਤੀਸ਼ਾਲੀ debugging ਟੂਲ ਬਹੁਤ ਹੀ ਲਾਭਦਾਇਕ ਹੈ ।
00:42 ਖਾਸ ਤੌਰ 'ਤੇ ਉਸ ਸਮੇਂ, ਜਦੋਂ ਤੁਹਾਨੂੰ ਵੱਡੇ ਪ੍ਰੋਗਰਾਮਸ ਕੋਡ ਜਾਂ ਟੈਸਟ ਕਰਨੇ ਹੋਣ ।
00:46 ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ Netbeans Debugger ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੁੱਝ ਫੀਚਰਸ ਦੇ ਬਾਰੇ ਵਿੱਚ ਸਿੱਖਾਂਗੇ ।
00:53 ਇਹ ਟਿਊਟੋਰਿਅਲ ਤੁਹਾਨੂੰ
00:55 debugging ਵਿੰਡੋ
00:58 breakpoints ਕਾਂਫਿਗਰ ਕਰਨਾ,
01:00 expressions ਦਾ ਮੁਲਾਂਕਣ ਜਾਂ watches ਸੈੱਟ ਕਰਨਾ,
01:04 ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੇ ਲਈ ਚੋਣ ਜਾਂ ਵਿਕਲਪ,
01:17 ਅਤੇ debugger ਕਾਂਫਿਗਰ ਕਰਨ ਦੇ ਲਈ ਚੋਣ ਜਾਂ ਵਿਕਲਪ ਦੇ ਬਾਰੇ ਵਿੱਚ ਜਾਣੂ ਕਰਵਾਏਗਾ ।
01:12 ਹੁਣ ਇਸ ਸਿੰਪਲ ਕੋਡ ਨੂੰ ਸ਼ੁਰੂ ਅਤੇ debug ਕਰਦੇ ਹਾਂ ।
01:17 ਮੈਂ Netbeans IDE ‘ਤੇ ਜਾਵਾਂਗਾ ।
01:20 ਮੈਂ ਇਸ ਦੇ ਲਈ, ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਆਪਣੇ IDE ਵਿੱਚ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ sample Debug ਬਣਾ ਦਿੱਤੀ ਹੈ ।
01:27 ਇਹ ਇੱਕ ਛੋਟਾ ਪ੍ਰੋਗਰਾਮ ਹੈ, ਜੋ ਤਿੰਨ ਇੰਟਿਜਰ ਵੈਲਿਊ a,b, ਅਤੇ c ਨੂੰ ਇਨੀਸ਼ਿਲਾਇਜ ਕਰਦਾ ਹੈ ।
01:35 ਫਿਰ Hello World ! ਅਤੇ a ਦੀ ਵੈਲਿਊ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ।
01:40 ਇਹ ਇੱਕ ਕਲਾਸ ਆਬਜੈਕਟ SampleClass, ਵੀ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਪ੍ਰਾਇਵੇਟ ਇੰਟਿਜਰ ਵੈਲਿਊ ਦੇ ਰੂਪ ਵਿੱਚ value ਇੰਟਿਜਰ ਹੈ ।
01:52 ਫਿਰ, ਇਹ b ਦੀ ਵੈਲਿਊ ਦੀ ਗਿਣਤੀ ਕਰਦਾ ਹੈ ।
01:55 ਅਤੇ c ਦੀ ਵੈਲਿਊ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੇ ਲਈ ਫੰਕਸ਼ਨ ਕਾਲ ਕਰਦਾ ਹੈ ।
02:00 ਅਤੇ b ਅਤੇ c ਦੀ ਵੈਲਿਊ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ।
02:05 debugging ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੇ ਲਈ, ਪਹਿਲਾਂ ਬਰੇਕ ਪੁਆਇੰਟ ਨੂੰ ਸੈੱਟ ਕਰਦੇ ਹਾਂ ।
02:09 ਬਰੇਕ ਪੁਆਇੰਟ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੇ ਲਈ, ਲਾਈਨ ਨੰਬਰ ‘ਤੇ ਕਲਿਕ ਕਰੋ ।
02:13 ਮੈਂ ਇਸ ਲਾਈਨ ਨੂੰ ਸੈੱਟ ਕਰਾਂਗਾ ਜੋ Hello World ! ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦੀ ਹੈ ।
02:18 ਨੋਟ ਕਰੋ ਕਿ, ਲਾਈਨ ਜਿਸ ਵਿੱਚ ਬਰੇਕ ਪੁਆਇੰਟ ਸੈੱਟ ਹੈ ਇਸਦਾ ਰੰਗ ਪਿੰਕ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸਦੇ ਲਾਈਨ ਨੰਬਰ ਦੇ ਸਾਹਮਣੇ ਇੱਕ ਛੋਟੇ ਸਕਵੇਰ ਦੁਆਰਾ ਨਿਸ਼ਾਨ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ ।
02:28 ਜਦੋਂ ਤੁਸੀਂ ਟੂਲਬਾਰ ਵਿੱਚ Debug Project ਬਟਨ ‘ਤੇ ਕਲਿਕ ਕਰਕੇ
02:31 debugging ਮੋਡ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਰਨ ਕਰਦੇ ਹੋ
02:35 ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਉਸ ਲਾਈਨ ‘ਤੇ ਰੁਕ ਜਾਂਦੀ ਹੈ, ਜਿੱਥੇ ਬਰੇਕ ਪੁਆਇੰਟ ਸਥਿਤ ਹੈ ।
02:41 ਹੁਣ ਤੱਕ, a ਦੀ ਵੈਲਿਊ ਸੈੱਟ ਹੋ ਗਈ ਹੈ ।
02:45 ਇਸ ਦੀ ਵੈਲਿਊ ਚੈੱਕ ਕਰੋ ।
02:49 ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇਸ ਦੀ ਵੈਲਿਊ 10 ਹੈ ।
02:52 ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇੱਥੇ workspace ਦੇ ਹੇਠਾਂ ਕੁੱਝ ਹੋਰ ਵਿੰਡੋਜ਼ ਹਨ ।
02:59 ਇੱਥੇ Variables ਵਿੰਡੋ ਹੈ, ਜੋ ਵੈਰੀਏਬਲ ਦੀ ਸੂਚੀ ਅਤੇ ਉਸ ਦੀ ਵੈਲਿਊ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ।
03:07 ਹੁਣ ਤੱਕ ਕੇਵਲ ਵੈਰੀਏਬਲ a ਇਨੀਸ਼ਿਲਾਇਜ ਹੋਇਆ ਹੈ ।
03:11 ਅਸੀਂ ਸਿੰਪਲ debug ਆਉਟਪੁਟ ਦੇ ਨਾਲ Output ਵਿੰਡੋ ਨੂੰ ਵੀ ਵੇਖ ਸਕਦੇ ਹਾਂ ।
03:17 ਇੱਥੇ ਹੁਣ ਵੀ ਆਉਟਪੁਟ ਨਹੀਂ ਆਈ ਹੈ ।
03:19 ਇੱਥੇ Debugger Console ਵੀ ਹੈ, ਜੋ ਕਹਿੰਦਾ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਲਾਈਨ 29 ‘ਤੇ ਬਰੇਕ ਪੁਆਇੰਟ ਕਰੋ ਅਤੇ ਉੱਥੇ ਰੁਕ ਜਾਵੋ ।
03:28 ਇੱਥੇ Breakpoints ਵਿੰਡੋ ਵੀ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਕਹਿੰਦੀ ਹੈ ਕਿ ਬਰੇਕ ਪੁਆਇੰਟ ਲਾਈਨ ਨੰਬਰ 29 ‘ਤੇ ਸੈੱਟ ਹੈ ।
03:36 ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ, ਵੇਖਦੇ ਹਾਂ ਕਿ watch ਕਿਵੇਂ ਜੋੜੀਏ ।
03:40 ਉਦਾਹਰਣ ਦੇ ਲਈ, ਮੈਂ ਇੰਟਿਜਰ ਵੈਲਿਊ a Sample ‘ਤੇ watch ਚਾਹੁੰਦਾ ਹਾਂ ।
03:48 workspace ਦੇ ਹੇਠਾਂ Variables ਵਿੰਡੋ ਵਿੱਚ,ਮੈਂ Enter new Watch ਓਪਸ਼ਨ ‘ਤੇ ਡਬਲ ਕਲਿਕ ਕਰਾਂਗਾ ਅਤੇ ਵੈਰੀਏਬਲ a Sample.value ਦਾ ਨਾਮ ਦਰਜ ਕਰਾਂਗਾ ।
04:02 OK.’ਤੇ ਕਲਿਕ ਕਰੋ ।
04:06 ਹੁਣ ਤੱਕ a Sample ਨਹੀਂ ਬਣਿਆ ਹੈ, ਇਸ ਲਈ: ਇਹ ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਸਨੂੰ ਵੈਲਿਊ ਪਤਾ ਨਹੀਂ ਹੈ ।
04:12 ਇੱਕ ਵਾਰ ਇਹ ਲਾਈਨ ਚਲਾਉਂਦਾ ਹੈ, ਅਸੀਂ ਪਤਾ ਕਰਾਂਗੇ ਕਿ ਵੈਰੀਏਬਲ ਵਿੱਚ ਕੀ ਸ਼ਾਮਿਲ ਹੈ ।
04:16 ਇਸ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ watch ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ expressions ਦਾ ਮੁਲਾਂਕਣ ਕਰ ਸਕਦੇ ਹੋ ।
04:21 ਇੱਥੇ ਮੈਂ b = a + 10 ਲਈ ਚੈੱਕ ਕਰ ਰਿਹਾ ਹਾਂ ।
04:25 ਕੀ ਹੋਵੇਗਾ, ਜੇ ਮੈਂ ਜਾਣਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ a - 4 ਕੀ ਹੈ ।
04:29 ਇਸ ਲਈ: ਮੈਂ ਮੈਨਿਊ ਬਾਰ ਵਿੱਚ Debug ‘ਤੇ ਜਾਂਦਾ ਹਾਂ, ਅਤੇ Evaluate expression ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਚੁਣਦਾ ਹਾਂ ।
04:37 workspace ਵਿੱਚ Evaluate Code ਵਿੰਡੋ ਵਿਖਾਈ ਦਿੰਦੀ ਹੈ ।
04:41 ਇੱਥੇ ਮੈਂ expression a - 4.ਦਰਜ ਕਰਾਂਗਾ ।
04:45 ਇੱਥੇ Evaluate Expression ਬਟਨ ‘ਤੇ ਕਲਿਕ ਕਰੋ, ਅਤੇ Variable ਵਿੰਡੋ ਵਿੱਚ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ a - 4 ਦੀ ਵੈਲਿਊ 6 ਹੈ ।
04:56 ਹੁਣ ਅੱਗੇ ਵੱਧਦੇ ਹਾਂ ਅਤੇ ਕੋਡ ਦੀ ਇਸ ਇੱਕ ਲਾਈਨ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ।
05:00 ਅਜਿਹਾ ਕਰਨ ਦੇ ਲਈ, ਟੂਲਬਾਰ ਤੋਂ Step - Over ਬਟਨ ਚੁਣੋ ।
05:06 ਇਸਨੂੰ ਕੇਵਲ “Hello World” ਪ੍ਰਿੰਟ ਕਰਨ ਦੇ ਲਈ ਕੋਡ ਦੀ ਕੇਵਲ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ।
05:12 ਆਉਟਪੁਟ ਦੇਖਣ ਦੇ ਲਈ, ਆਉਟਪੁਟ ਵਿੰਡੋ ‘ਤੇ ਜਾਓ ਅਤੇ sampleDebug ਆਉਟਪੁਟ ਵਿੰਡੋ ਨੂੰ ਚੁਣੋ ।
05:17 ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ, Hello World ! a is 10.
05:22 ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਹੁਣ ਇੱਕ SampleClass ਆਬਜੈਕਟ ਬਣਾਉਣ ਦੇ ਲਈ ਲਾਈਨ ‘ਤੇ ਰੋਕਿਆ ਗਿਆ ਹੈ ।
05:28 ਹੁਣ, ਮੈਂ SampleClass.ਦੇ ਕੰਸਟਰਕਟਰ ਵਿੱਚ ਜਾਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ।
05:32 ਇਸ ਦੇ ਲਈ, ਮੈਂ ਟੂਲਬਾਰ [me] Step Into ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਨੂੰ ਚੁਣ ਸਕਦਾ ਹਾਂ ।
05:41 ਫਿਰ ਮੈਂ Step Over ਚੁਣ ਸਕਦਾ ਹਾਂ ਅਤੇ ਵੇਖਦਾ ਹਾਂ ਕਿ ਕੰਸਟਰਕਟਰ call ਵਿੱਚ ਆਈ ਹੋਈ ਵੈਲਿਊ ਹੁਣ 10 ਸੈੱਟ ਹੋ ਗਈ ਹੈ ।
05:51 ਤੁਸੀਂ ਉਸਨੂੰ ਵੈਰੀਏਬਲ ‘ਤੇ ਲੈ ਜਾ ਕੇ ਵੀ ਚੈੱਕ ਕਰ ਸਕਦੇ ਹੋ ।
05:55 ਜਦੋਂ ਮੈਂ ਅਗਲੇ ਸਟੈਪ ‘ਤੇ ਜਾਂਦਾ ਹਾਂ, ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ this.variable 10 ਸੈੱਟ ਹੋ ਗਿਆ ਹੈ ।
06:03 ਇਸ ਫੰਕਸ਼ਨ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਦੇ ਲਈ, ਮੈਂ ਜਾਂ ਤਾਂ Continue,Step Over ਜਾਂ Step Out.ਚੁਣ ਸਕਦਾ ਹਾਂ ।
06:11 ਮੈਥਡ ਤੋਂ ਬਾਹਰ ਜਾਣ ਦੇ ਲਈ ਮੈਂ Step - Out ਚੁਣਦਾ ਹਾਂ ।
06:14 ਅਤੇ ਹੁਣ ਮੈਂ ਉੱਥੇ ਹਾਂ ਜਿੱਥੇ ਫੰਕਸ਼ਨ call ਬਣਾਇਆ ਸੀ ।
06:19 ਜਦੋਂ ਮੈਂ ਫਿਰ ਤੋਂ Step - Over ਕਹਿੰਦਾ ਹਾਂ, ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ aSample.value ਹੁਣ 10 ਵਿੱਚ ਸੈੱਟ ਹੋ ਗਈ ਹੈ ।
06:27 ਇਹ ਉਹ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਸੀ ।
06:30 Breakpoints ਅਤੇ Step Overs ਦੇ ਇਲਾਵਾ, ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਕਰਸਰ ਦੀ ਲਾਈਨ ‘ਤੇ ਵੀ ਰੋਕ ਸਕਦੇ ਹੋ ।
06:38 ਉਦਾਹਰਣ ਦੇ ਲਈ, ਇੱਥੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਜਾਓ ਅਤੇ ਇਸ ਲਾਈਨ ‘ਤੇ ਕਰਸਰ ਸੈੱਟ ਕਰਨਾ ਹੈ, ਜੋ ਕਹਿੰਦਾ ਹੈ d = b - 5 ;.
06:49 ਹੁਣ ਟੂਲਬਾਰ ਵਿੱਚ Run To Cursor ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਚੁਣੋ ।
06:54 ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਫੰਕਸ਼ਨ ਵਿੱਚ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਲਾਈਨ ‘ਤੇ ਰੁੱਕ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਕਰਸਰ ਸਥਿਤ ਹੈ ।
07:05 ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ, ਇਸਨੇ 20 ਦੇ ਰੂਪ ਵਿੱਚ b ਦੀ ਵੈਲਿਊ ਦੀ ਗਿਣਤੀ ਕੀਤੀ ਹੈ ।
07:10 ਅਤੇ variable ਵਿੰਡੋ ਦੇ ਅੰਦਰ, b ਦੇ ਲਈ 20 ਸੈੱਟ ਕੀਤਾ ਹੈ ।
07:14 ਹੁਣ, ਮੈਂ ਫਿਰ ਤੋਂ Step Over ਚੁਣ ਸਕਦਾ ਹਾਂ ਅਤੇ d ਦੀ ਵੈਲਿਊ ਵੀ ਇਨੀਸ਼ਿਲਾਇਜ ਹੁੰਦੀ ਹੈ ਅਤੇ 15 ਹੋ ਜਾਂਦੀ ਹੈ ।
07:23 ਹੁਣ, ਮੈਂ ਜਾਂ ਤਾਂ ਰਿਟਰਨ ਚੁਣ ਸਕਦਾ ਹਾਂ ਜਾਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਪੂਰਾ ਕਰ ਸਕਦਾ ਹਾਂ ।
07:29 ਮੈਂ Step Out ਚੁਣਦਾ ਹਾਂ ਅਤੇ ਫੰਕਸ਼ਨ ਕਾਲ ‘ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ।
07:36 ਜਦੋਂ ਤੁਸੀਂ getC () ਫੰਕਸ਼ਨ ‘ਤੇ ਜਾਵੋਗੇ, ਤੁਸੀਂ ਧਿਆਨ ਦਿਓ ਕਿ ਫੰਕਸ਼ਨ ਨੇ 15 ਵੈਲਿਊ ਰਿਟਰਨ ਕੀਤੀ ਹੈ ।
07:43 ਵੈਰੀਏਬਲ c ਨੂੰ ਹੁਣ ਤੱਕ ਉਹ ਵੈਲਿਊ ਨਿਯੁਕਤ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ ।
07:47 ਇਸ ਲਈ: ਜਦੋਂ ਅਸੀਂ Step Over ਕਰਦੇ ਹਾਂ ਅਤੇ ਉਸ ਲਾਈਨ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ, c 15 ਵੈਲਿਊ ਪ੍ਰਾਪਤ ਕਰੇਗੀ ।
07:55 ਅਸੀਂ ਹੁਣ ਇਸ ਨੂੰ ਵੈਰੀਏਬਲ ਵਿੰਡੋ ਵਿੱਚ ਚੈੱਕ ਕਰ ਸਕਦੇ ਹਾਂ ਜਾਂ ਇਸ ਦੀ ਵੈਲਿਊ ਨੂੰ ਚੈੱਕ ਕਰਨ ਦੇ ਲਈ variable ‘ਤੇ ਜਾਓ ।
08:03 ਹੁਣ ਜੇ ਤੁਸੀਂ debugging ਸੈਸ਼ਨ ਰੋਕਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਟੂਲਬਾਰ ਤੋਂ Finish Debugger Session ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਚੁਣ ਸਕਦੇ ਹੋ ।
08:12 ਜੇ ਤੁਸੀਂ ਅਗਲੇ breakpoint ਦੇ ਲਈ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਜਾਰੀ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ Continue ਵਿਕਲਪ ਚੁਣ ਸਕਦੇ ਹੋ ।
08:19 ਇੱਕ ਵਾਰ ਪੂਰਾ ਕਰ ਲਵੋਂ, ਤੁਸੀਂ ਬਾਕੀ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੇ ਲਈ Continue option ਵੀ ਚੁਣ ਸਕਦੇ ਹੋ ।
08:25 ਮੈਂ ਇੱਥੇ Continue ਚੁਣਦਾ ਹਾਂ ।
08:27 ਆਉਟਪੁਟ ਵਿੰਡੋ ਵਿੱਚ, ਇਹ ਮੈਨੂੰ b is 20 ਅਤੇ c is 15 ਆਉਟਪੁਟ ਦਿਖਾਉਂਦਾ ਹੈ ।
08:34 ਇਹ netbeans ‘ਤੇ debugging ਦੇ ਵਿਕਲਪਾਂ ਦਾ ਇੱਕ ਨਿਰੀਖਣ ਸੀ ।
08:39 ਜੇ ਤੁਸੀਂ ਕੋਈ ਐਡਵਾਂਸ ਫੀਚਰਸ ਸੇਟਿੰਗ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ
08:42 Tools ਮੈਨਿਊ ‘ਤੇ ਜਾ ਸਕਦੇ ਹੋ, Options ‘ਤੇ ਕਲਿਕ ਕਰੋ, Miscellaneous ਵਿਕਲਪ ‘ਤੇ ਜਾਓ Java Debugger ਟੈਬ ‘ਤੇ ਕਲਿਕ ਕਰੋ ।
08:53 ਇੱਥੇ ਤੁਸੀਂ multi - threaded program breakpoint ਵਿਕਲਪਾਂ ਦੇ ਲਈ ਸੇਟਿੰਗ ਬਦਲ ਸਕਦੇ ਹੋ ।
08:59 ਜਾਂ ਜਿਨ੍ਹਾਂ ਮੈਥਡਸ ਦਾ ਤੁਸੀਂ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਉਸ ਦੇ ਨਿਰਮਾਣ ਦੇ ਲਈ ਫਿਲਟਰ ਕਰੋ ।
09:07 ਹੁਣ ਨਿਰਧਾਰਤ ਕੰਮ ਦੇ ਲਈ
09:09 ਨਿਰਧਾਰਤ ਕੰਮ ਦੇ ਰੂਪ ਵਿੱਚ, ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਲਵੋਂ, ਚੰਗਾ ਹੋਵੇਗਾ ਜੇ ਇਸ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਐਰਰਸ ਹੋਣ ।
09:16 ਜੇ ਨਹੀਂ, ਤਾਂ ਲਾਜਿਕ ਜਾਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਕੁੱਝ ਐਰਰਸ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ ।
09:20 ਕੋਡ ਵਿੱਚ breakpoints ਸੈੱਟ ਕਰੋ । ਆਮ ਤੌਰ ‘ਤੇ, ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਦੇ ਕਾਲਿੰਗ ਪੁਆਇੰਟ ‘ਤੇ ਬ੍ਰੇਕ ਨੂੰ ਸੈੱਟ ਕਰਦੇ ਹੋ ਜਿਸ ‘ਤੇ ਤੁਹਾਨੂੰ ਐਰਰ ਦਾ ਸ਼ੱਕ ਹੁੰਦਾ ਹੈ ।
09:29 Use ਫੰਕਸ਼ਨ ਵਿੱਚ ਜਾਣ ਦੇ ਲਈ Step - Into ਦੀ ਵਰਤੋਂ ਕਰੋ ।
09:32 ਲਾਈਨ ਚਲਾਉਣ ਦੇ ਲਈ Step - Overs ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਵੈਰੀਏਬਲ ਵਿੰਡੋ ਵਿੱਚ ਵੈਰੀਏਬਲ ਦੀ ਵੈਲਿਊ ਦਾ ਨਿਰੀਖਣ ਕਰਨ ਦੇ ਲਈ ਯਕੀਨੀ ਬਣਾਓ ।
09:41 ਐਰਰ ਨੂੰ ਪਛਾਣਨ ਅਤੇ ਠੀਕ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮੱਦਦ ਦੇ ਲਈ ਕੁੱਝ watches ਜੋੜੋ ।
09:45 ਮੈਥਡ ਤੋਂ ਬਾਹਰ ਜਾਓ ।
09:48 ਤੁਹਾਡੇ ਅਗਲੇ breakpoint ‘ਤੇ ਪਹੁੰਚਣ ਤੱਕ ਜਾਰੀ ਰੱਖੋ ।
09:51 ਅਤੇ ਅਖੀਰ ਵਿੱਚ, debugger ਸੈਸ਼ਨ ਖ਼ਤਮ ਕਰੋ ਅਤੇ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਰਨ ਕਰੋ ।
09:57 ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ netbeans debugger ਦੇ ਨਾਲ ਵਾਕਫ਼ ਹੋ ਗਏ ਹਾਂ ।
10:02 ਅਸੀਂ ਵੇਖਿਆ ਕਿ ਕਿਵੇਂ breakpoints ਅਤੇ watches ਨੂੰ ਸੈੱਟ ਕਰੀਏ ।
10:06 expressions ਜੋੜੋ, ਜਿਨ੍ਹਾਂ ਦੀ ਅਸੀਂ ਗਿਣਤੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ,ਜਦੋਂ ਕੋਡ ਰਨ ਹੋ ਰਿਹਾ ਹੋ ।
10:11 Step - Into, Step - Over, Step - Out [aur] Run - to - Cursor ਦੇ ਵਿਕਲਪਾਂ ਦੇ ਨਾਲ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਪਤਾ ਲਗਾਇਆ ।
10:19 ਇਹ ਵੀ ਵੇਖਿਆ ਕਿ ਐਡਵਾਂਸ debugging ਦੇ ਲਈ debugger ਨੂੰ ਕਿਵੇਂ ਕਾਂਫਿਗਰ ਕਰੀਏ ।
10:24 ਆਸ ਕਰਦੇ ਹਾਂ ਕਿ ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੇ ਤੁਹਾਡਾ ਟੈਸਟਿੰਗ ਅਤੇ debugging ਕੰਮ ਵਿੱਚ ਬਹੁਤ ਸਾਰਾ ਸਮਾਂ ਬਚਾਇਆ ਹੋਵੇਗਾ ।
10:30 ਸਕ੍ਰੀਨ ‘ਤੇ ਦਿਖਾਈ ਦੇ ਰਹੇ ਹੇਠ ਲਿਖੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਵੀਡੀਓ ਨੂੰ ਵੇਖੋ ।
10:33 ਇਹ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਾਰ ਕਰਦਾ ਹੈ ।
10:36 ਚੰਗੀ ਬੈਂਡਵਿਡਥ ਨਾ ਮਿਲਣ ‘ਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਡਾਊਂਨਲੋਡ ਕਰਕੇ ਵੀ ਵੇਖ ਸਕਦੇ ਹੋ ।
10:41 ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ, ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਰਕਸ਼ਾਪਾਂ ਚਲਾਉਂਦੀ ਹੈ ।
10:46 ਆਨਲਾਇਨ ਟੈਸਟ ਪਾਸ ਕਰਨ ਵਾਲਿਆ ਨੂੰ ਪ੍ਰਮਾਣ ਪੱਤਰ ਵੀ ਦਿੰਦੇ ਹਨ ।
10:49 ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਦੇ ਲਈ, ਕ੍ਰਿਪਾ ਕਰਕੇ contact@spoken-tutorial.org ‘ਤੇ ਲਿਖੋ ।
10:55 ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟਾਕ-ਟੂ-ਅ ਟੀਚਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਹਿੱਸਾ ਹੈ ।
10:59 ਇਹ ਭਾਰਤ ਸਰਕਾਰ ਦੇ ਐਮਐਚਆਰਡੀ ਦੇ “ਆਈਸੀਟੀ ਵਲੋਂ ਰਾਸ਼ਟਰੀ ਸਾਖਰਤਾ ਮਿਸ਼ਨ” ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਹੈ ।
11:05 ਇਸ ‘ਤੇ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਹੈ । http://spoken-tutorial.org/NMEICT-Intro
11:14 ਆਈ.ਆਈ.ਟੀ ਬੰਬੇ ਤੋਂ ਮੈਂ ਨਵਦੀਪ ਤੁਹਾਡੇ ਤੋਂ ਇਜਾਜ਼ਤ ਲੈਂਦਾ ਹਾਂ ।
11:18 ਸਾਡੇ ਨਾਲ ਜੁੜਣ ਦੇ ਲਈ ਧੰਨਵਾਦ ।

Contributors and Content Editors

Navdeep.dav