Java/C2/Nested-if/Gujarati

Time	Narration
00:02	જાવામાં Nested-If અને Ternary Operator પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે.
00:07	આ ટ્યુટોરીયલના અંતમાં તમે નીચે આપેલ સમજાવવા માટે સમર્થ હશો: * Nested-If સ્ટેટમેંટો અને ટર્નરી ઓપરેટરો. * તેનો જાવા પ્રોગ્રામમાં ઉપયોગ કરવો.
00:17	આ ટ્યુટોરીયલ માટે આપણે વાપરી રહ્યા છીએ: ઉબુન્ટુ આવૃત્તિ ૧૧.૧૦ જેડીકે ૧.૬, અને એક્લીપ્સ IDE ૩.૭.૦
00:27	આ ટ્યુટોરીયલનાં અનુસરણ માટે, તમને જાણ હોવી જોઈએ,
00:29	રીલેશનલ અને લોજીકલ ઓપરેટરોનાં ઉપયોગ વિશે.
00:33	અને if...else કન્ટ્રોલ ફ્લો સ્ટેટમેંટો વિશે.
00:36	જો નથી, તો સંદર્ભિત ટ્યુટોરીયલ માટે બતાવ્યા પ્રમાણે અમારી વેબસાઈટનો સંદર્ભ લો.
00:41	Nested if સ્ટેટમેંટ, If સ્ટેટમેંટ જેમાં બીજું એક If સ્ટેટમેંટ આવેલ છે તેને nested-if સ્ટેટમેંટ કહેવાય છે.
00:49	હવે ચાલો Nested if સ્ટેટમેંટ લખવા માટેની સીન્ટેક્ષનું સ્થાન નિર્ધારિત કરીએ.
00:53	આ કિસ્સામાં, જો કંડીશન ૧ true હોય, તો પ્રોગ્રામ કંડીશન ૨ માટે તપાસ કરે છે.
00:59	કંડીશન ૨ બીજા એક If સ્ટેટમેંટનાં ઉપયોગ દ્વારા અપાય છે.
01:03	જો કંડીશન ૨ true હોય, તો પ્રોગ્રામ સ્ટેટમેંટને અથવા બ્લોક ૧ ને એક્ઝેક્યુટ કરે છે.
01:09	નહી તો, તે સ્ટેટમેંટ અથવા બ્લોક ૨ ને એક્ઝેક્યુટ કરે છે.
01:13	જો કંડીશન ૧ false હોય, તો પ્રોગ્રામ કંડીશન ૨ ને તપાસ કરશે નહી.
01:18	તેનાં બદલે તે સીધું તેના else સ્ટેટમેંટ પર જશે દા.ત. બ્લોક ૩.
01:24	હવે તેને સારી રીતે સમજવા માટે ચાલો એક ઉદાહરણ લઈએ
01:28	આપણી પાસે એક્લીપ્સ IDE અને બચેલા કોડ માટે જોઈતું માળખું છે.
01:32	આપણે NesedIfDemo ક્લાસ બનાવ્યો છે અને તેમાં મેઈન મેથડ ઉમેરી છે.
01:37	આપણે તપાસ કરીશું કે આપેલ ક્રમાંક એકી ક્રમાંક છે કે બેકી ક્રમાંક છે.
01:42	આપણે nested-if નાં ઉપયોગ દ્વારા નેગેટીવ ક્રમાંકોને પણ નિયંત્રિત કરીશું.
01:46	તો મેઈન મેથડમાં ટાઈપ કરો
01:49	int n = minus 5;
01:54	આપણે નેગેટીવ ક્રમાંકને સંગ્રહીત કરવા માટે વેરીએબલ n બનાવ્યો છે.
01:58	હવે આપણે if કંડીશનો લખીશું.
02:01	પછીની લાઈનમાં ટાઈપ કરો
02:02	if (n < 0)
02:07	ખુલ્લો કર્લી કૌંસ. એન્ટર દબાવો
02:10	System.out.println કૌંસમાં અને ડબલ અવતરણ ચિહ્નમાં (“Negative number”) ;
02:22	પહેલા આપણે જોઈશું કે ક્રમાંક નેગેટીવ છે કે નહી.
02:25	જો છે, તો આપણે એકી કે બેકી માટે તપાસ કરીશું નહી.
02:29	જો ક્રમાંક નેગેટીવ નથી, તો આપણે એકી કે બેકી માટે તપાસ કરીશું.
02:34	પછીની લાઈનમાં ટાઈપ કરો else { } એન્ટર દબાવો
02:42	હવે જો એક્ઝીક્યુશન એલ્સ ભાગ પર આવ્યું છે.
02:45	એનો અર્થ એ છે કે ક્રમાંક નેગેટીવ નથી.
02:48	તેથી આપણે આ એલ્સ ભાગની અંદર એકી કે બેકી માટે તપાસ કરીએ છીએ.
02:52	ટાઈપ કરો
02:53	if (n modules 2 double equal to 0) { એન્ટર દબાવો
03:03	System.out.println(“Even number”); } else { એન્ટર દબાવો ટાઈપ કરો System.out.println(“Odd number”); }
03:29	તો આપણે એ ખાતરી કરીશું કે નેગેટીવ ક્રમાંકો એકી કે બેકી તપાસ માટે ગણતરીમાં લેવાતા નથી.
03:34	હવે ચાલો કોડને ક્રિયામાં જોઈએ.
03:37	ફાઈલને સંગ્રહ કરી રન કરો. આપણે જોઈ શકીએ છીએ, આઉટપુટ “negative number” તરીકે મળે છે.
03:43	હવે ચાલો પોઝીટીવ ક્રમાંક પ્રયાસ કરીએ
03:46	n = -5 ને n = 5 થી બદલો
03:53	હવે ફાઈલને સંગ્રહીત કરી રન કરો
03:57	જેવું કે આપણે જોઈ શકીએ છીએ, ધાર્યા મુજબ આઉટપુટ, odd number છે. ચાલો બેકી ક્રમાંક પ્રયાસ કરીએ
04:04	n = 5 ને n = 10 થી બદલો.
04:09	હવે ફાઈલને સંગ્રહીત કરીને રન કરો
04:12	આપણે જોઈ શકીએ છીએ, ધાર્યા મુજબ આઉટપુટ even number છે.
04:17	if સ્ટેટમેંટને બીજા એક if સ્ટેટમેંટમાં સમાવેશ કરવાની પ્રક્રિયાને, nested-if કહેવાય છે.
04:22	નેસ્ટીંગનાં માત્રાની કોઈ મર્યાદા નથી.
04:25	પરંતુ ૩ સ્તરની નેસ્ટીંગ કરતા આગળ ન જવું એ એક સારો અભ્યાસ છે.
04:31	હવે આપણે ટર્નરી ઓપરેટર જોઈશું.
04:33	પહેલા હું મેઈન મેથડ ને સાફ કરીશ.
04:37	આપણે એક એવો પ્રોગ્રામ લખીશું જે ક્રમાંકને ૨ વડે ભાગ કરે.
04:40	આ અત્યંત સરળ પ્રોગ્રામ છે પરંતુ સમસ્યા એકી ક્રમાંકોનાં ભાગ કરતી વખતે આવે છે.
04:45	જયારે ૭ ને ૨ થી ભાગવામાં આવે છે, આપણને ૩ મળે છે.
04:48	પણ શું થશે જયારે આપણે પરિણામને નજીકનાં ક્રમાંકમાં આવરી લેવાનું ઈચ્છીએ છીએ.
04:50	એનો અર્થ એ કે, જયારે ૭ ને ૨ થી ભાગવામાં આવે છે, તો આપણને ૪ મળે છે ન કે ૩
04:56	સાદા અર્થમાં, આપણને આગળનો ક્રમાંક જોઈએ છે.
04:59	ચાલો જોઈએ આવો પ્રોગ્રામ કેવી રીતે લખવું.
05:01	જુઓ મેઈન મેથડ અંદર ટાઈપ કરો int n, nHalf ;
05:08	આપણે ક્રમાંકને n માં અને અર્ધો ક્રમાંક nHalf માં સંગ્રહીત કરીશું
05:13	પછીની લાઈનમાં ટાઈપ કરો n = 5;
05:18	પછીની લાઈનમાં ટાઈપ કરો if (n % 2 == 0) { એન્ટર દબાવો
05:28	ટાઈપ કરો nHalf = n / 2 ; } else { nHalf = (n + 1) / 2 ; }
05:50	આપણે તપાસ કરીશું કે ક્રમાંક એકી છે કે બેકી અને એ અનુસાર ભાગ કરીશું.
05:55	હવે પ્રોગ્રામને ક્રિયામાં જોવા માટે પ્રીંટ સ્ટેટમેંટ ઉમેરીએ.
05:59	તો ટાઈપ કરો System.out.println(nHalf) ;
06:11	હવે ફાઈલને સંગ્રહીત કરીને રન કરો
06:14	જેવું કે આપણે જોઈ શકીએ છીએ, આપણું ઉદ્દેશ મળ્યું છે. આપણને આઉટપુટ ૩ મળ્યું છે ન કે ૨
06:21	પણ જો આપણે નોંધ લઈએ, તો આપણે શું કરીએ છીએ કે, કંડીશન પર આધાર રાખીને વેરીએબલની વેલ્યુને સુયોજિત કરીએ છીએ.
06:27	આપણા પ્રોગ્રામમાં લોજીક કરતા વધારે સીન્ટેક્ષ છે.
06:31	આમ જયારે ટર્નરી ઓપરેટર કોડને સરળ બનાવે છે.
06:35	ટર્નરી ઓપરેટર કંડીશનલ ઓપરેટર છે, જે પરિણામ nested-if ની જેમ જ આપે છે.
06:40	આ નાની સીન્ટેક્ષ આપે છે અને તે પ્રશ્ન ચિન્હ દ્વારા દર્શાવાય છે.
06:45	આ એક સમયે ત્રણ ઓપરેન્ડો લે છે.
06:48	ચાલો ટર્નરી ઓપરેટરની સીન્ટેક્ષ વિશે શીખીએ.
06:53	એક્સપ્રેશન, એક કંડીશન છે જેને આપણે તપાસવું છે.
06:56	ઓપરેન્ડ ૧ એ Result વેરીએબલની વેલ્યુ છે જો કંડીશન true હોય.
07:03	જો કંડીશન false હોય તો ઓપરેન્ડ ૨ એ વેલ્યુ છે.
07:09	હવે ચાલો તેને આપણા પ્રોગ્રામમાં વાપરીએ.
07:12	પહેલા ચાલો if-else સ્ટેટમેંટને રદ્દ કરીએ.
07:17	ટાઈપ કરો nHalf = n % 2 == 0 ? n / 2 : (n + 1) / 2 અર્ધવિરામ
07:41	આ સ્ટેટમેંટ આ રીતે વંચાય છે,
07:43	જો n બેકી હોય, nHalf એ n ભાગ્યા ૨ છે, નહી તો, તે n વત્તા ૧ ભાગ્યા ૨ છે.
07:50	હવે ચાલો આને ક્રિયામાં જોઈએ.
07:52	ફાઈલને સંગ્રહીત કરી રન કરો. Ctrl S અને Ctrl F11 કી દબાવો
07:59	જેવું કે આપણે જોઈ શકીએ છીએ, આઉટપુટ ધાર્યા મુજબનું છે.
08:02	આ રીતે, ટર્નરી ઓપરેટર કોડમાં વેરવિખેરને ઘટાડે છે અને વાંચનમાં સુધાર કરે છે.
08:09	અહીં આ ટ્યુટોરીયલ સમાપ્ત થાય છે.
08:11	આ ટ્યુટોરીયલમાં આપણે શીખ્યા:
08:13	* Nested-If સ્ટેટમેંટો અને ટર્નરી ઓપરેટર વિશે
08:15	* જાવા પ્રોગ્રામમાં Nested-If સ્ટેટમેંટો અને ટર્નરી ઓપરેટર નાં ઉપયોગ વિશે
08:22	હવે આપેલ ઉપર એક એસાઈનમેંટ લો
08 :23	Nested-If અને ટર્નરી ઓપરેટર. નીચે આપેલ માટે જાવા પ્રોગ્રામ લખો.
08:28	* nested-if નાં ઉપયોગ વડે તપાસ કરો કે ક્રમાંક બેકી છે કે નહી અને સાથે જ ૧૧ નો ગુણાંક છે કે નહી.
08:34	* ટર્નરી ઓપરેટર નાં ઉપયોગ વડે આપેલ બે ક્રમાંકોમાંથી મોટા ક્રમાંકને ઓળખો.
08:40	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ વિશે વધુ જાણકારી માટે, આપેલ લીંક પર ઉપલબ્ધ વિડીયો જુઓ.
08:45	તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટનો સારાંશ આપે છે. જો તમારી બેન્ડવિડ્થ સારી ન હોય, તો તમે ડાઉનલોડ કરી તે જોઈ શકો છો.
08:52	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ.
08:54	સ્પોકન ટ્યુટોરીયલો ની મદદથી વર્કશોપોનું આયોજન કરે છે અને
08:57	જેઓ ઓનલાઈન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્રો આપે છે. વધુ વિગત માટે, કૃપા કરી contact AT spoken HYPHEN tutorial DOT org પર સંપર્ક કરો.
09:07	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ એ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે અને
09:11	જે આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે.
09:17	આ મિશન પર વધુ માહીતી આપેલ લીંક પર ઉપલબ્ધ છે spoken HYPHEN tutorial DOT org SLASH NMEICT HYPHEN Intro.
09:26	IIT-Bombay તરફથી સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે ભાષાંતર કરનાર હું, જ્યોતી સોલંકી વિદાય લઉં છું. જોડાવા બદ્દલ આભાર.

Contributors and Content Editors

Jyotisolanki, Krupali, PoojaMoolya