Difference between revisions of "Java/C2/Nested-if/Gujarati"
From Script | Spoken-Tutorial
Jyotisolanki (Talk | contribs) (Created page with ' …') |
|||
| Line 13: | Line 13: | ||
|- | |- | ||
| 00:07 | | 00:07 | ||
| − | | આ | + | | આ ટ્યુટોરીયલના અંતમાં તમે નીચે આપેલ સમજાવવા માટે સમર્થ હશો: |
| − | '''*''' '''Nested-If સ્ટેટમેંટો''' અને '''ટર્નરી ઓપરેટરો''' | + | '''*''' '''Nested-If સ્ટેટમેંટો''' અને '''ટર્નરી ઓપરેટરો'''. |
'''*''' તેનો જાવા પ્રોગ્રામમાં ઉપયોગ કરવો. | '''*''' તેનો જાવા પ્રોગ્રામમાં ઉપયોગ કરવો. | ||
| Line 21: | Line 21: | ||
|- | |- | ||
| 00:17 | | 00:17 | ||
| − | | આ ટ્યુટોરીયલ માટે | + | | આ ટ્યુટોરીયલ માટે આપણે વાપરી રહ્યા છીએ: |
'''ઉબુન્ટુ આવૃત્તિ ૧૧.૧૦''' | '''ઉબુન્ટુ આવૃત્તિ ૧૧.૧૦''' | ||
| Line 39: | Line 39: | ||
|- | |- | ||
| 00:33 | | 00:33 | ||
| − | | અને '''if...else''' | + | | અને '''if...else''' કન્ટ્રોલ ફ્લો સ્ટેટમેંટો વિશે. |
|- | |- | ||
| Line 47: | Line 47: | ||
|- | |- | ||
| 00:41 | | 00:41 | ||
| − | | '''Nested if''' સ્ટેટમેંટ '''If''' | + | | '''Nested if''' સ્ટેટમેંટ, '''If''' સ્ટેટમેંટ જેમાં બીજું એક '''If''' સ્ટેટમેંટ આવેલ છે તેને '''nested-if સ્ટેટમેંટ''' કહેવાય છે. |
|- | |- | ||
| 00:49 | | 00:49 | ||
| − | | હવે ચાલો '''Nested if''' સ્ટેટમેંટ લખવા માટેની | + | | હવે ચાલો '''Nested if''' સ્ટેટમેંટ લખવા માટેની સીન્ટેક્ષનું સ્થાન નિર્ધારિત કરીએ. |
|- | |- | ||
| Line 75: | Line 75: | ||
|- | |- | ||
| 01:18 | | 01:18 | ||
| − | | તેનાં બદલે તે | + | | તેનાં બદલે તે સીધું તેના '''else''' સ્ટેટમેંટ પર જશે દા.ત. '''બ્લોક ૩'''. |
|- | |- | ||
| 01:24 | | 01:24 | ||
| − | | હવે તેને સારી રીતે સમજવા માટે ચાલો | + | | હવે તેને સારી રીતે સમજવા માટે ચાલો એક ઉદાહરણ લઈએ |
|- | |- | ||
| Line 87: | Line 87: | ||
|- | |- | ||
| 01:32 | | 01:32 | ||
| − | | | + | | આપણે '''NesedIfDemo''' ક્લાસ બનાવ્યો છે અને તેમાં મેઈન મેથડ ઉમેરી છે. |
|- | |- | ||
Revision as of 17:03, 11 September 2013
| 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 | જેવું કે આપણે જોઈ શકીએ છીએ, ધાર્યા મુજબ આઉટપુટ એક એકી ક્રમાંક છે. ચાલો બેકી ક્રમાંક પ્રયાસ કરીએ |
| 04:04 | n = 5 ને n = 10 બદલો. |
| 04:09 | હવે ફાઈલને સંગ્રહીત કરીને રન કરો |
| 04:12 | જેવું કે આપણે જોઈ શકીએ છીએ, ધાર્યા મુજબ આઉટપુટ એક બેકી ક્રમાંક છે. |
| 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 | ઓપરેન્ડ ૧ વેરીએબલ પરિણામની વેલ્યુ છે જો કંડીશન 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 સ્ટેટમેંટો અને ટર્નરી ઓપરેટર વિશે |
| * જાવા પ્રોગ્રામમાં 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 તરફથી સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે ભાષાંતર કરનાર હું, જ્યોતી સોલંકી વિદાય લઉં છું.
જોડાવાબદ્દલ આભાર. |
