Computer Class 12 GSEB Solutions Chapter 7 જાવાની મૂળભૂત બાબતો

Students frequently turn to Computer Class 12 GSEB Solutions and GSEB Computer Textbook Solutions Class 12 Chapter 7 જાવાની મૂળભૂત બાબતો for practice and self-assessment.

GSEB Computer Textbook Solutions Class 12 Chapter 7 જાવાની મૂળભૂત બાબતો

પ્રશ્ન 1.
જાવામાં character ડેટાપ્રકારનું કદ કેટલું હોય છે?
ઉત્તર:
જાવામાં character ડેટાપ્રકારનું કદ 2 bytes હોય છે અને તે 16 bit Unicode Characterની રેન્જ ધરાવે છે.

પ્રશ્ન 2.
જાવામાં int અને long ડેટાપ્રકાર કેટલી બાઇટ રોકે છે તે જણાવો.
ઉત્તરઃ
જાવામાં int ડેટાપ્રકાર 4 bytes અને long ડેટાપ્રકાર 8 bytes સંગ્રહની જગ્યા રોકે છે.

પ્રશ્ન 3.
જાવામાં ઉપલબ્ધ if અને switch વિધાન
સમજાવો.
ઉત્તર :
if વિધાન (if Statement)

જ્યારે પ્રોગ્રામમાં if વિધાન વાપરવામાં આવે છે ત્યારે બુલિયન પદાવલીની કિંમત true છે કે false તેના પ્રમાણે બેમાંથી એક વિકલ્પ પ્રમાણે કાર્ય કરવા સમર્થ બનાવે છે. તે ‘branching’ અથવા ‘decision’ અથવા ‘selective’ કન્ટ્રોલ સ્ટ્રક્ચરનું ઉદાહરણ છે. if વિધાનનું સ્વરૂપ આકૃતિ માં દર્શાવ્યું છે.

જ્યારે if વિધાનનો અમલ થાય છે, ત્યારે સૌપ્રથમ બુલિયન પદાવલીની કિંમત શોધવામાં આવે છે.
જો કિંમત true હોય, તો તે statement1નો અમલ કરશે.
જો કિંમત false હોય, તો તે ચાવીરૂપ શબ્દ else પછી લખેલાં વિધાનોના બ્લૉકનો અમલ કરશે.
if વિધાનમાં <statement> સામાન્ય રીતે બ્લૉક સ્ટેટમેન્ટ હોય છે.
if વિધાનનું કાર્ય સમજવા માટે પૂર્ણાંક સંખ્યા એકી છે કે બેકી તે નક્કી કરવા માટેનો પ્રોગ્રામખંડ નીચે દર્શાવેલ છે :

if (x%2= =0)//assume int x
{//divisible by 2
system.out.print (x);
system.out.println (“is even");
}
else
{// not divisible by 2
system.out.println (x+“is odd");
}

જ્યારે if વિધાનની અંદર બીજું if વિધાન વાપરવામાં આવે, તો તેને nested_if વિધાન કહેવામાં આવે છે. હવે નીચે દર્શાવેલ પ્રોગ્રામખંડ જુઓ. તે nested_ifનો ઉપયોગ કરી મેળવેલા ગુણ પ્રમાણે ગ્રેડ નક્કી કરે છે.

if (marks> = 70) //int marks
{grade=A'; //char grade
}
else
{
if (marks > =60)
grade='B';
else if (marks>=50)
grade='C';
else
grade='F';
}

સ્વિચ સ્ટેટમેન્ટ (Switch Statement)

જ્યારે ચલ કે પદાવલીની કિંમત પ્રમાણે અલગ અલગ ઘણાં કાર્યોના વિકલ્પ હોય, ત્યારે સ્વિચ સ્ટેટમેન્ટ વાપરવામાં આવે છે.
સ્વિચ સ્ટેટમેન્ટમાં ટેસ્ટ પદાવલીનો પ્રકાર byte, char, short અથવા int હોવો જોઈએ.
સ્વિચ સ્ટેટમેન્ટનું સ્વરૂપ નીચે પ્રમાણે હોય છે :

switch (<expression>)
{
case <constant-1>:
<statement-1>
break;
case <constant-2>:
<statement-2>
break;
//more such cases
case <constant-n>:
<statement-n>
break;
default:
<statement-n1>
}

સ્વિચ સ્ટેટમેન્ટનો અમલ કરતા સમયે case1થી શરૂ કરી ટેસ્ટ પદાવલીની કિંમત દરેક case કિંમત સાથે સરખાવવામાં આવે છે. જો બંને કિંમત સમાન મળે, તો તે caseનાં વિધાનોનો અમલ થાય છે.
જો સમાન કિંમત ન મળે, તો default વિધાનનો અમલ થાય છે.
break વિધાનનો ઉપયોગ સ્વિચ સ્ટેટમેન્ટનો અંત લાવવા માટે થાય છે.

પ્રશ્ન 4.
જાવામાં ઉપલબ્ધ વિવિધ પુનરાવર્તિત માળખાં વિશે ચર્ચા કરો.
ઉત્તરઃ
રિપીટિટિવ કન્ટ્રોલ સ્ટ્રક્ચર (Repetitive Control Structures)

જાવા ત્રણ પ્રકારનાં લૂટિંગની રચના પૂરી પાડે છે :
1. for,
2. while અને
3. do… while
આકૃતિ માં આ બધા લૂપની વાક્યરચના (Syntax) અને માળખું (Structure) દર્શાવેલું છે.

for અને while લૂપમાં સૌપ્રથમ ટેસ્ટ પદાવલીની ગણતરી કરવામાં આવે છે અને જો શરત સાચી હોય, તો લૂપની અંદરનાં વિધાનોનો અમલ થાય છે. આ લૂપ પ્રવેશ-નિયંત્રિત (Entry-controlled) અથવા પ્રી-ટેસ્ટ (Pre-test) પ્રકારના લૂપ છે.
જ્યારે પુનરાવૃત્તિ(Iterations)ની સંખ્યા અગાઉથી નક્કી હોય, ત્યારે સામાન્ય રીતે for લૂપ વપરાય છે.
for લૂપમાં પહેલી પદાવલી પ્રારંભિક કિંમત આપે છે, બીજી પદાવલી શરત તપાસે છે અને ત્રીજી પદાવલી પુનરાવૃત્તિ કરનાર છે.
for (; 😉 આ લૂપમાં break વિધાનનો અમલ ન થાય, તો તે અનંત લૂપમાં પરિણમે છે.
do … while લૂપમાં પહેલાં પદાવલીઓનો અમલ થાય છે અને પછી પદાવલીની કિંમત ટેસ્ટ કરવામાં આવે છે. જો ટેસ્ટની શરતનું પરિણામ true મળે, તો લૂપમાં પુનરાવર્તન થાય છે.
do … while લૂપ નિર્ગમ-નિયંત્રિત (Exit- controlled) અથવા પોસ્ટ-ટેસ્ટ (Post-test) પ્રકારનું લૂપ છે.
do … while લૂપમાં લૂપની અંદરનાં વિધાનો ઓછામાં ઓછા એક વખત અમલમાં આવે જ છે.

પ્રશ્ન 5.
જાવા બ્લૉક અથવા લૂપ માટે લેબલ કઈ રીતે વાપરી શકાય?
ઉત્તરઃ
લેબલ કરેલા લૂપ અને લેબલ કરેલા break (Labelled loops and Labelled break)

જ્યારે આપણે નેસ્ટેડ લૂપ વાપરીએ છીએ, ત્યારે જો આપણે લૂપ અટકાવવું હોય અથવા કયા લૂપનું પુનરાવર્તન કરવું તેનું નિયંત્રણ કરવા ઇચ્છતા હોઈએ તો આપણે લેબલ કરેલા લૂપનો ઉપયોગ કરી શકીએ છીએ.
લેબલ કરેલું લૂપ વાપરવા માટે લૂપની શરૂઆત પહેલા લેબલ અને તેના પછી ગુરુવિરામ (:) લખવું પડે છે.
જે લૂપમાં હોય તેની બહાર નિયંત્રણ લઈ જવું હોય ત્યારે break અથવા continue કી-વર્ડ પછી લેબલનું નામ લખવામાં આવે છે.
આકૃતિ લેબલ કરેલા લૂપ અને breakનો ઉપયોગ કરેલ પ્રોગ્રામ દર્શાવે છે.

આકૃતિ માં 40થી 100 વચ્ચેની અવિભાજ્ય સંખ્યા છાપતો પ્રોગ્રામ દર્શાવ્યો છે. આ પ્રોગ્રામમાં પણ લેબલ કરેલા લૂપ અને breakનો ઉપયોગ કરેલ છે.

Computer Class 12 GSEB Notes Chapter 7 જાવાની મૂળભૂત બાબતો

જાવાનો પરિચય (Introduction to Java)

જાવા એક ઑબ્જેક્ટ આધારિત પ્રોગ્રામિંગ ભાષા છે.
જાવા ભાષા 1991માં Sun Microsystems દ્વારા વિકસાવવામાં આવી છે.
જાવા ભાષા સોર્સ પ્રોગ્રામ અને દ્વિઅંકી બંને સ્તરે વિવિધ પ્લૅટફૉર્મ (જુદા જુદા હાર્ડવેર) અને ઑપરેટિંગ સિસ્ટમ ઉપર નાની, સરળ અને સુવાહ્ય (Portable) બની રહે તેવી બનાવેલી છે.
જાવાને સામાન્ય ઉદેશવાળી પ્રોગ્રામિંગ ભાષા – GPPL (General Purpose Programming Language) પણ ગણવામાં આવે છે.
જાવા વિવિધ પ્રકારના ક્લાસની લાઇબ્રેરી ધરાવે છે, જે મૂળભૂત ડેટાપ્રકારો (Data Types), સિસ્ટમની નિવેશ (Input) અને નિર્ગમ (Output) ઉપયોગી ક્ષમતા તેમજ યુટિલિટી કાર્યો માટેની સગવડ પૂરી પાડે છે. આ મૂળભૂત ક્લાસનો સમૂહ જાવા ડેવલપમેન્ટ કિટ – JDK- (Java Development Kit)નો ભાગ છે.
JDKમાં નેટવર્કિંગ માટેના, સામાન્ય ઇન્ટરનેટ પ્રોટોકૉલના અને વપરાશકર્તાના સેતુ ટૂલકિટનાં કાર્યો માટેના અનેક ક્લાસ હોય છે.
જાવા સોર્સ પ્રોગ્રામ અને દ્વિઅંકી બંને સ્તરે પ્લૅટફૉર્મ સ્વતંત્ર છે. પ્લૅટફૉર્મ સ્વતંત્રતા એટલે જાવા પ્રોગ્રામની એક કમ્પ્યૂટર સિસ્ટમથી બીજી ઉપર સરળતાથી લઈ જવાની ક્ષમતા છે.
સોર્સ પ્રોગ્રામના સ્તરે જાવાના પ્રાથમિક ડેટાપ્રકારોનું કદ બધા વિકાસ પ્લૅટફૉર્મ ઉપર અચળ છે, પરંતુ દ્વિઅંકી સ્તરે બાઇટકોડ ઇન્ટરપ્રિટર(Byte code interpreter)ને કારણે પ્લૅટફૉર્મ સ્વતંત્રતા શક્ય છે.
આકૃતિ માં પ્લૅટફૉર્મ સ્વતંત્રતાની સ્થિતિ દર્શાવેલ છે.

જાવામાં લખેલા પ્રોગ્રામનું એવા કમ્પ્યૂટરની મશીનની ભાષામાં કમ્પાઇલેશન (Compilation) કરવામાં આવે છે, હકીકતમાં અસ્તિત્વમાં નથી. આ પ્રકારનાં ‘Virtual’ કમ્પ્યૂટર જાવા વર્ચ્યુઅલ મશીન (Java Virtual Machine – JVM) તરીકે ઓળખાય છે.
જાવા વર્ચ્યુઅલ મશીનની યાંત્રિક ભાષાને જાવા બાઇટકોડ (Byte code) કહેવામાં આવે છે.
બાઇટકોડ વાપરવાનો ગેરલાભ તેની અમલની ઓછી ઝડપ છે. એવા પ્રકારનાં ટૂલ્સ ઉપલબ્ધ છે, જે જાવા બાઇટકોડનું નૅટિવકોડ(Native code)માં રૂપાંતર કરે છે. નૅટિવકોડ અમલ કરવામાં ઝડપી છે પણ પછી તે મશીન સ્વતંત્ર રહેતાં નથી.

સાદા જાવા વિનિયોગનું નિર્માણ (Creating Simple Java Application)

કોઈ પણ જાવા વિનિયોગના નિર્માણ પહેલા એ બાબતનું ખાસ ધ્યાન રાખવું કે જાવા પ્રોગ્રામ અનેક ક્લાસનો બનેલો હોય છે અને તેમાં ઓછામાં ઓછો એક ક્લાસ હોવો જોઈએ અને main મેથડ હોવી જ જોઈએ.
કોઈ પણ જાવા વિનિયોગનું નિર્માણ કરવા નીચેનાં પગલાં અનુસરવા પડે :

પગલું 1 : કોઈ પણ સાદા ASCII ટેક્સ્ટ એડિટર વડે જાવા સોર્સ ફાઈલ બનાવો (ટેક્સ્ટ એડિટરમાં જાવા પ્રોગ્રામ ટાઇપ કરો.) આ સોર્સ ફાઈલનું નામ જે નામથી ક્લાસ વ્યાખ્યાયિત કરેલ હોય તે જ નામ અને ‘.java’ અનુલંબન (Extension) સાથેનું રાખો. (દા. ત., CallCost.java)

પગલું 2 : જાવા-કમ્પાઇલ૨(javac)નો ઉપયોગ કરીને સોર્સ ફાઈલને કમ્પાઇલ કરો. (દા. ત., javac CallCost.java)

જો કમ્પાઇલ૨ કોઈ પણ ભૂલ દર્શાવે, તો પાછા જાઓ અને જાવા પ્રોગ્રામના કોડ લખવામાં કંઈ ભૂલ થઈ હોય, તો તે સુધારો.
જ્યારે પ્રોગ્રામ કોઈ પણ ભૂલ વિના કમ્પાઇલ થાય, ત્યારે તમારી સોર્સ ફાઈલની ડિરેક્ટરીમાં કમ્પાઇલર ‘.class’ અનુલંબન સાથેની ફાઈલ બનાવશે. (દા. ત., CallCost. class) આ આપણી જાવા બાઇટકોડ ફાઈલ છે, જેનો અમલ કરવામાં આવશે.

પગલું 3 : જાવા-ઇન્ટરપ્રિટર વડે વિનિયોગનો અમલ કરો. JDKમાં ફક્ત java આપીને જાવા ઇન્ટરપ્રિટર વાપરી શકાય છે. (દા. ત., java CallCost)
જાવા પ્રોગ્રામને કમ્પાઇલ કરવાની અને અમલ કરવાની પ્રક્રિયા આકૃતિ માં દર્શાવી છે.

ટર્મિનલના ઉપયોગ દ્વારા linuxમાં પણ જાવા પ્રોગ્રામને કમ્પાઇલ કરી તેનો અમલ કરી શકાય છે.

પ્રયોગ 1

હેતુ : એવો જાવા વિનિયોગ બનાવવો કે જે ફોનકૉલના ખર્ચની ગણતરી કરી સિલક રકમમાં સુધારો કરે.
પગલું 1 : સૌપ્રથમ કોડ લિસ્ટિંગ 7.1માં દર્શાવેલ જાવા પ્રોગ્રામ કોઈ પણ સાદા ASCII ટેક્સ્ટ એડિટર જેવા કે SciTE કે Geditમાં ટાઇપ કરો અને આ સોર્સ ફાઈલને ‘CallCost.java’ નામથી સંગ્રહ કરો.

પગલું 2 : નીચે મુજબ આદેશ આપીને આ સોર્સ ફાઈલને કમ્પાઇલ કરો ઃ
javac CallCost.java.
જો કમ્પાઇલર કોઈ પણ ભૂલ દર્શાવે, તો તેને સુધારો.

પગલું 3 : નીચે મુજબ આદેશ આપીને પ્રોગ્રામનો અમલ કરો : ‘java CallCosť

પ્રયોગ 1ના કોડ લિસ્ટિંગ 7.1ની સમજૂતી :
લાઇન 1થી 4 : /* અને */ વચ્ચે લખાયેલી શાબ્દિક માહિતી(Text)ને કૉમેન્ટ કહે છે. આ જ પ્રમાણે // પછી લખાયેલ શાબ્દિક માહિતીને પણ કૉમેન્ટ કહે છે.
કૉમેન્ટ કમ્પાઇલ કે ઇન્ટરપ્રિટ થતી નથી. તે ફક્ત ઉપયોગકર્તાને પ્રોગ્રામ સમજવામાં મદદરૂપ થાય તે ઉદ્દેશથી લખવામાં આવે છે.

લાઇન 5 : Public class CallCost આ આદેશથી એક CallCost નામના ક્લાસની રચના કરવામાં આવી છે, જેમાં main મેથડનો ઉપયોગ કરવામાં આવ્યો છે. (જુઓ લાઇન 7)

લાઇન 7 : જ્યારે આપણે પ્રોગ્રામનો અમલ કરીએ છીએ, ત્યારે જાવા ઇન્ટરપ્રિટર પ્રથમ main( ) મેથડ પર જાય છે અને તેમાં રહેલાં વિધાનોનો અમલ કરે છે. – main( )ની પ્રથમ લીટીના શબ્દ ‘public’નો અર્થ એ છે કે આ પ્રોગ્રામની બહારથી આ રૂટિન બોલાવી શકાય છે. આ અનિવાર્ય છે, કારણ કે જાવા ઇન્ટરપ્રિટર વડે main( ) રૂટિન બોલાવવામાં આવે છે કે જે પ્રોગ્રામની બહાર છે.

લાઇન 10થી 14 : અહીં ડેટાપ્રકાર (data type) પછી ચલનું નામ (Variable name) જણાવી ચલને ઘોષિત (Declare) કરેલ છે.

લાઇન 16થી 19 : અહીં ચલને શરૂઆતની કિંમત (Initial value) આપવામાં આવી છે.

લાઇન 20 – 21 : અહીં ગણતરી માટે અસાઇનમેન્ટ વિધાનો સાથેની પદાવલીઓ છે.

લાઇન 24થી 27 : અહીં System.out.print તથા System.out.println મેથડનો ઉપયોગ પરિણામ દર્શાવવા માટે કરેલ છે.

System.out.println મેથડ જે માહિતી પ્રદર્શિત કરે છે, તેના પછી એક નવી લીટી (Linefeed) ઉમેરે છે, જ્યારે System.out.print ફક્ત માહિતી જ પ્રદર્શિત કરે છે.
અહીં લાઇન 24માં એક callથી balance પ્રદર્શિત થાય છે. પ્રાચલ તરીકે જાવામાં + પ્રક્રિયકનો ઉપયોગ અહીં ધ્યાન ઉપર લો.

જાવા વિનિયોગના નિર્માણ માટે SciTEનો ઉપયોગ (Using SciTE to Create a Java Application)
SciTEનો ઉપયોગ કરી સાદા વ્યાજની ગણતરી કરીને પરિણામ પ્રદર્શિત કરતો જાવા વિનિયોગ બનાવવા નીચે દર્શાવેલ પગલાં અનુસરો :
પગલું 1 : SciTE વિનિયોગ ચાલુ કરો અને File → New આદેશ પસંદ કરો.
પગલું 2 : હવે, આકૃતિ માં દર્શાવેલ કોડ લિસ્ટિંગ પ્રમાણે જાવા પ્રોગ્રામ ટાઇપ કરો અને તેને Interest.java નામ સાથે સંગ્રહ કરો. ફાઈલનો સંગ્રહ કરવા File → Save આદેશ પસંદ કરો.
પગલું 3 : Tools → Compile આદેશ આપીને સોર્સ પ્રોગ્રામને કમ્પાઇલ કરો. કમ્પાઇલર પ્રોગ્રામમાં કોઈ ભૂલ બતાવે તો તે સુધારો.
પગલું 4 : જો પ્રોગ્રામ કોઈ પણ ભૂલ વિના કમ્પાઇલ થઈ જાય, તો Tools → Go આદેશ આપીને તેનો અમલ ર કરો.

જાવા પ્રોગ્રામનું બંધારણ (Structure of a Java Program)

પ્રોગ્રામિંગ ભાષાના એ નિયમો કે જે નક્કી કરે કે શું માન્ય છે, તેને ભાષાની વાક્યરચના (Syntax) કહેવામાં આવે છે.
વાક્યરચનાના નિયમો (Syntax rules) ભાષાના મૂળભૂત શબ્દભંડોળનો ઉલ્લેખ કરે છે અને ચલ, પદાવલીઓ, વિધાનો, બ્રાન્ચ (Branch), લૂપ (Loops) અને મેથડ(Methods)નો ઉપયોગ કરીને કઈ રીતે પ્રોગ્રામની રચના કરી શકાય, તે જણાવે છે.
વાક્યરચનાની રીતે સાચો પ્રોગ્રામ એ છે કે જે સફળતાપૂર્વક કમ્પાઇલ કે ઇન્ટરપ્રિટ થઈ શકે.
જાવા પ્રોગ્રામનું માળખું આકૃતિ માં દર્શાવ્યું છે.

અહીં, < અને > કોણીય કૌંસ એક પ્લેસ હોલ્ડર (Placeholder) તરીકે વપરાય છે, જેમાં ખરેખર પ્રોગ્રામ લખતા સમયે કંઈક વાસ્તવિક ટાઇપ કરવાનું હોય છે.
જાવામાં મેથડ(ફંક્શન)ની વ્યાખ્યા ફંક્શન હેડર તથા { અને } કૌંસ વચ્ચે વિધાનોની શ્રેણી હોય છે.
જાવા ઑબ્જેક્ટ આધારિત ભાષા હોવાથી અહીં તમામ મેથડ ક્લાસના ભાગ તરીકે વ્યાખ્યાયિત કરવામાં આવે છે. આ રીતે, મેથડ સ્વતંત્ર રીતે હયાતી ધરાવતી નથી. તે ક્લાસનો એક ભાગ હોઈ શકે છે.
આકૃતિ માં દર્શાવેલ જાવા પ્રોગ્રામના માળખા બાબતે નીચે દર્શાવેલ મુદ્દા ધ્યાનમાં લો :
પ્રથમ લીટીમાં <class-name> એ ક્લાસનું નામ છે, જેમાં main ) મેથડ હોય છે.
નોંધ : જો ક્લાસનું નામ Interest હોય, તો જાવા સોર્સ ફાઈલનો સંગ્રહ Interest.java નામથી કરવો જોઈએ. જ્યારે આ ફાઈલને કમ્પાઇલ કરવામાં આવે છે, ત્યારે Interest.class નામની બીજી ફાઈલ બને છે. આ Interest.class નામની ક્લાસ ફાઈલ પ્રોગ્રામનું જાવા બાઇટકોડમાં થયેલું રૂપાંતર ધરાવે છે, જેનો જાવા-ઇન્ટરપ્રિટર દ્વારા અમલ કરી શકાય છે.
main ( ) મેથડ પહેલાં અને પછી ચલ (Variable) અને મેથડ (Method) ઘોષિત કરવા વૈકલ્પિક છે.
દરેક પ્રોગ્રામમાં એક ક્લાસ હોવો જ જોઈએ, જે પબ્લિક મેથડ main ( ) ધરાવે.
હવે આપણે જાવા ભાષાની વાક્યરચના (Syntax) સાથેની અન્ય બાબતોનો અભ્યાસ કરીશું.

ડેટાપ્રકાર (Data Types)

ડેટાપ્રકાર મેમરીનું જરૂરી કદ, મેમરીમાં રહેલી કિંમતોનો પ્રકાર, કિંમતનો ક્ષેત્ર વિસ્તાર અને તેની ઉપર શક્ય ક્રિયાઓનો પ્રકાર નક્કી કરે છે.
જાવા આઠ પ્રકારના પ્રાથમિક (પ્રિમિટિવ – Primitive) ડેટાપ્રકાર પૂરા પાડે છે, જે નીચે દર્શાવેલ છે :

ઉપર દર્શાવ્યા પ્રમાણે પ્રથમ ચાર પ્રકારોમાં પૂર્ણાંક સંખ્યા (જેમ કે 25, – 27 અને 0) હોય છે, તે પછીના બે પ્રકારોમાં અપૂર્ણાંક સંખ્યા(જેમ કે 25.8, – 27.5)નો સમાવેશ કરી શકાય.
Char પ્રકારમાં યુનિકોડ અક્ષરસમૂહ(Unicode Character Set)માંથી એક અક્ષર હોય છે.
બુલિયન (Boolean) પ્રકાર બે તાર્કિક કિંમતો true અથવા falseમાંથી એક કિંમત હોય છે.
કોષ્ટક 7.1માં ડેટાપ્રકારોની વિગત આપેલી છે.
b બીટની યથાર્થતા (Precision) સાથેની પૂર્ણાંક સંખ્યામાં(-2^{b – 1}-1થી 2^{b – 1})ની રેન્જમાં ચિહ્નિત કિંમતોનો સંગ્રહ કરી શકાય છે. જ્યારે તેની આગળ unsigned ચાવીરૂપ શબ્દ (Keyword) હોય, ત્યારે તેની કિંમત- (0થી 2^b−1)ની રેન્જમાં હોઈ શકે.

જાવામાં અપૂર્ણાંક સંખ્યા IEEE 754 સુસંગત છે.
જાવા યુનિકોડ અક્ષર સમૂહનો ઉપયોગ કરે છે. Char ડેટાપ્રકારની 16 બીટની પ્રીસિઝન અને અચિહ્નિત હોય છે. આ કારણે જાવા અનેક વિવિધ ભાષાઓના અલગ અલગ મૂળાક્ષરોના હજારો અક્ષરોનો ઉપયોગ કરી શકે છે.
Boolean ડેટાપ્રકાર એ સંખ્યા નથી અને તેને સંખ્યા તરીકે ગણી પણ ન શકાય.

ચલ (Variable)

જાવા જેવી ઉચ્ચસ્તરીય ભાષામાં ડેટાનો નિર્દેશ કરવા માટે મેમરી કે જ્યાં ડેટાનો સંગ્રહ થયેલ છે તે જગ્યાના આંકડાકીય સ્થાનાંકને બદલે નામનો ઉપયોગ કરવામાં આવે છે. પ્રોગ્રામરે ફક્ત નામ જ યાદ રાખવું પડે છે. મેમરીમાં સંગ્રહ કરેલા ડેટાનો નિર્દેશ કરવા માટે વાપરેલા નામને ચલ (Variable) કહેવામાં આવે છે.
પ્રોગ્રામના અમલ દરમિયાન જુદા જુદા સમયે ચલમાં અલગ અલગ ડેટાકિંમત હોઈ શકે પણ તે હંમેશાં એક જ મેમરી-સ્થાનાંકનો નિર્દેશ કરે છે. જાવા પ્રોગ્રામમાં જો પહેલા ચલ ઘોષિત (Declare) કરેલ હોય, તો જ વાપરી શકાય છે. → ચલ ઘોષિત કરવાની વાક્યરચના નીચે દર્શાવેલ છે :
<typename>{variable_names};
અહીં, {variable_names} ચલનાં નામોની યાદીનો નિર્દેશ કરે છે. જ્યારે યાદીમાં એક કરતાં વધારે ઘટક હોય, ત્યારે અલ્પવિરામથી જુદી પાડવામાં આવે છે. <typename>ને ચલના ડેટાપ્રકાર સૂચવતા ચાવીરૂપ શબ્દ વડે બદલવામાં આવે છે.
ચલ ઘોષિત કરવાનાં કેટલાંક ઉદાહરણ નીચે દર્શાવેલ છે :
int marks;
double amount, interest;
float rate;
char grade;
boolean ispass;

ચલનું નામ વ્યાખ્યાયિત કરવા માટે નીચે જણાવેલા કેટલાક નિયમોને અનુસરવા જરૂરી છે :
(1) ચલના નામની શરૂઆત કોઈ મૂળાક્ષર, અન્ડરસ્કોર (_) અથવા ડૉલરના ચિહ્ન($)થી કરવી જોઈએ. પહેલા અક્ષર પછી તેમાં અંક, મૂળાક્ષર, $ અને અન્ડરસ્કોર હોઈ શકે.
માન્ય ચલનાં નામ :
fname, birthdate,_fname, $price, top5, amounts વગેરે.
અમાન્ય ચલનાં નામ :
4me, birth date, % discount, #amount વગેરે.

(2) ચલના નામની વચ્ચે ખાલી જગ્યા (Space) માન્ય નથી.

(3) ચલ તરીકે જાવાનો આરક્ષિત શબ્દ (Reserved word) ન હોઈ શકે. દા. ત., class, public, static, while વગેરે.

ચલનું નામ આપવાની માર્ગદર્શિકા (Guidelines for Naming Variables)
ચલનું નામ આપતા સમયે નીચેની બાબતોનું ધ્યાન રાખવું જોઈએ :

ચલનું નામ અર્થપૂર્ણ હોવું જોઈએ.
જ્યારે ચલના નામમાં વધારે શબ્દો હોય ત્યારે પહેલા શબ્દ સિવાયના દરેક શબ્દનો પહેલો અક્ષર કૅપિટલ રાખવો જોઈએ. આ રીતને કૅમલકેસ (Camel case) કહેવામાં આવે છે. દા. ત., balanceAmount, birthDate વગેરે.
યાદ રાખો : જાવા કેસ-સેન્સિટિવ ભાષા છે. આથી કૅપિટલ અને સ્મૉલ અક્ષરો જુદા ગણવામાં આવે છે. આથી ચલના નામ amount અને Amount જુદા છે.
ક્લાસ(Class)ના નામ કૅપિટલ(Upper case)થી શરૂ કરવા જોઈએ, જ્યારે ચલનાં અને મેથડનાં નામ સ્મૉલ(Lower case)થી શરૂ કરવા જોઈએ.

જાવામાં ત્રણ પ્રકારના ચલ હોય છે :

ઇન્સ્ટન્સ વેરિએબલ (Instance Variable)
ક્લાસ વેરિએબલ (Class Variable)
લોકલ વેરિએબલ (Local Variable)

લિટરલ (Literals)

અચળ કિંમત માટે વાપરવામાં આવતું નામ લિટરલ તરીકે ઓળખાય છે.
જાવામાં સંખ્યા (Number), અક્ષર (Character), સ્ટ્રિંગ (String) અને બુલિયન (Boolean) કિંમતો માટે અલગ અલગ પ્રકારના લિટરલ હોય છે.

ન્યુમરિક લિટરલ (Numeric Literals)

પૂર્ણાંક અને અપૂર્ણાંક સંખ્યાઓ જેવી કે 156 અને 25.8 દર્શાવવા માટે ન્યુમરિક લિટરલ વપરાય છે.

જાવા 7 દ્વિઅંકી સંખ્યા(જેમાં 0 અને 1 અંક વપરાય છે)ને રજૂ કરવા માટે સંખ્યાની પહેલા Ob (અથવા OB) લખવામાં આવે છે. ઉદાહરણ : Ob10110
રિઅલ નંબર લિટરલને ફ્લૉટિંગ-પૉઇન્ટ લિટરલ (Floating Point Literals) પણ કહેવામાં આવે છે. આ સંખ્યા નીચે મુજબ બે પ્રકારની સંકેતિલિપ વડે લખી શકાય છે :
1. પ્રમાણભૂત (Standard) – દા. ત., 12.37 અને
2. વૈજ્ઞાનિક (Scientific) – દા. ત., 1.3e12
વૈજ્ઞાનિક માળખું અતિ મોટી સંખ્યા અથવા ખૂબ જ નાની સંખ્યા જણાવવા માટે વાપરી શકાય છે.
વૈજ્ઞાનિક માળખામાં દર્શાવેલ રિઅલ નંબર 12.3737e – 108માં “e – 108” એ 10નો ઘાતાંક રજૂ કરે છે. એટલે કે 12.3737e – 108 = 12.3737 વખત 10-108 11તથા 1.3e12 = 1.3 વખત 1012
જાવામાં ફ્લૉટિંગ-પૉઇન્ટ લિટરલનો પૂર્વનિર્ધારિત પ્રકાર double છે.

બુલિયન લિટરલ (Boolean Literals)

જાવામાં બુલિયન પ્રકાર માટે સ્પષ્ટ રીતે બે લિટરલ છે : True અને False.
બુલિયન કિંમતો મોટે ભાગે શરતી પદાવલીઓમાં જોવા મળે છે.
C ભાષામાં ને false તરીકે અને બિન-શૂન્ય કિંમતને true તરીકે ગણવામાં આવે છે. જ્યારે જાવામાં true અને false લિટરલ કોઈ આંકડાકીય કિંમત સાથે સંકળાયેલ નથી.

કૅરેક્ટર લિટરલ (Character Literals)

કૅરેક્ટર લિટરલને એક અવતરણચહ્ન વચ્ચે સમાવાયેલા એક અક્ષર દ્વારા જણાવવામાં આવે છે. દા. ત., ‘a’, ‘#’ અને ‘3’
જાવામાં અક્ષર (Character)ને 16 બીટ યુનિકોડ કૅરેક્ટર તરીકે સંગ્રહ કરવામાં આવે છે.
એસ્કેપ કૅરેક્ટર (Escape character) તરીકે બૅકસ્લેશ(\)નો ઉપયોગ થાય છે.
કોષ્ટક 7.2માં વિવિધ એસ્કેપ કોડ તથા તેમના અર્થ દર્શાવેલ છે.

કોષ્ટક : એસ્કેપ કોડ

Escape Code	Meaning
\n	New line
\t	Tab
\b	Backspace
\r	Carriage return
\f	Form feed (New Page)
\\	Back slash character
\’	Single quote character
\”	Double quote character
\ddd	Character represented by three octal digits (d: 0 to 7)
\xdd	Character represented by two hexadecimal digits (d: 0 to 9, a to f)
\udddd	Character represented by Unicode number dddd (d: hexadecimal digit)

સ્પ્રિંગ લિટરલ (String Literals)

સ્ટિંગ એ અક્ષરોની એક શ્રેણી છે. દા. ત., “Balance” સ્ટ્રિંગ લિટરલ એ બે અવતરણચહ્ન વચ્ચે અક્ષરોની એક શ્રેણી છે.
સ્ટ્રિંગની અંદર વિશિષ્ટ અક્ષરો કોષ્ટક 7.2માં દર્શાવ્યા પ્રમાણે બૅકસ્લેશ ચિહ્ન વાપરીને રજૂ કરી શકાય છે. દા. ત., Many, “Congratulations !” સ્ટ્રિંગ આપવા માટે આપણે “Many, \“Congratulations!\”” ટાઇપ કરવું પડે.

કૉમેન્ટ (Comments)

પ્રોગ્રામમાં કૉમેન્ટ ફક્ત ઉપયોગકર્તા માટે જ હોય છે, તેને કમ્પ્યૂટર દ્વારા સંપૂર્ણપણે અવગણવામાં આવે છે. ઉપયોગકર્તાને પ્રોગ્રામ સમજવો સરળ બનાવવા માટે કૉમેન્ટ લખવી અગત્યની છે.
જાવામાં ત્રણ પ્રકારની કૉમેન્ટ હોય છે :
(1) એક-લીટી કૉમેન્ટ,
(2) બહુ-લીટી કૉમેન્ટ અને
(3) દસ્તાવેજીકરણ કૉમેન્ટ.

(1) એક-લીટી કૉમેન્ટ : તેની શરૂઆત ડબલ સ્લેશ(//)થી થાય છે અને લીટીના અંત સુધી વિસ્તૃત થાય છે.
(2) બહુ-લીટી કૉમેન્ટ : તેની શરૂઆત /*થી અને અંત */થી થાય છે. આ પ્રકારની કૉમેન્ટનો ઉપયોગ સામાન્ય રીતે એક કરતાં વધારે લીટીની કૉમેન્ટ હોય ત્યારે થાય છે.
(3) દસ્તાવેજીકરણ કૉમેન્ટ : આ પ્રકારની કૉમેન્ટ /**થી શરૂ થાય છે અને */થી તેનો અંત આવે છે. તેનો ઉપયોગ કોડમાંથી API ડૉક્યુમેન્ટેશન બનાવવા માટે થાય છે, જે javadoc સિસ્ટમ માટે વપરાય છે.

પદાવલી (Expressions)

પદાવલીઓ પ્રોગ્રામિંગના અનિવાર્ય ભાગ છે. પદાવલીના પાયાના ઘટકો લિટરલ, ચલ અને ફંક્શન કૉલ છે.
પદાવલી “A + B * C”માં પહેલા B * Cની ગણતરી કરવામાં આવે છે અને તેનું પરિણામ Aમાં ઉમેરવામાં આવે છે. કારણ કે સરવાળા (+) કરતાં ગુણાકાર(*)નો અગ્રતાક્રમ વધુ છે. અહીં જો આપણે ઇચ્છતા હોય તે પૂર્વનિર્ધારિત અગ્રતાક્રમ ન હોય, તો આપણે જૂથ સ્પષ્ટ રીતે જણાવવા માટે કૌંસનો ઉપયોગ કરી શકીએ. દા. ત., “(A + B) * C” માં પહેલા A અને Bનો સરવાળો કરી તેના પરિણામનો C સાથે ગુણાકાર કરવામાં આવશે.

પ્રક્રિયકો (Operators)
પદાવલી બનાવવા માટે વપરાતા વિશિષ્ટ ચિહ્નો પ્રક્રિયક છે. હવે આપણે જાવામાં ઉપલબ્ધ વિવિધ પ્રકારના પ્રક્રિયકોનો અભ્યાસ કરીશું.

અંકગણિતીય પ્રક્રિયકો (Arithmetic Operators)

જાવામાં મૂળભૂત અંકગણિતીય પ્રક્રિયક સરવાળો (+), બાદબાકી (−), ગુણાકાર (*), ભાગાકાર (/) અને મૉડ્યુલસ (%) છે.
આ બધા પ્રક્રિયક બાયનરી છે, તેમાં બે સંકાર્ય (Operand) હોય છે.
પ્રક્રિયક + અને − યુનરી તરીકે પણ વપરાય છે.
કોષ્ટક માં અંકગણિતીય પ્રક્રિયકોનું વર્ણન આપેલ છે.

કોષ્ટક : અંકગણિતીય પ્રક્રિયકો

પ્રક્રિયક	અર્થ	ઉદાહરણ	પરિણામ
+	સરવાળો	2 + 8	10
–	બાદબાકી	2 – 8	-6
*	ગુણાકાર	2 * 8	16
/	ભાગાકાર	8/2	4
%	મૉડ્યુલસ (ભાગાકાર પછી શેષ જણાવે છે, ભાગળ પૂર્ણાંક સંખ્યા હોય છે.)	8 % 3 25.8 % 7	2 4.8

બાયનરી અંકગણિતીય પ્રક્રિયા પછી પરિણામનો ડેટાપ્રકાર નીચે પ્રમાણે હોય છે :
(1) જો બંને સંકાર્ય (Operands) એક જ પ્રકારના ડેટા હોય, તો પરિણામનો ડેટાપ્રકાર પણ સંકાર્યના પ્રકાર સમાન જ રહેશે.
ઉદાહરણ : 9/2નું પરિણામ 4.5 નહીં પણ 4 છે અને 9f/2fનું પરિણામ 4.5 છે.

(2) જ્યારે બંને સંકાર્ય (Operands) અલગ અલગ પ્રકારના ડેટા હોય ત્યારે :

સૌપ્રથમ જે ડેટાપ્રકારની નાની રેન્જ છે, તેને મોટી રેન્જના ડેટાપ્રકારમાં બદલવામાં આવે છે. આ પ્રકારના પરિવર્તનને પ્રમોશન (Promotion) પણ કહે છે.
હવે પદાવલીનું પરિણામ મોટી રેન્જના સંકાર્ય (Operand) સમાન બની રહેશે.
ઉદાહરણ : 4 + 3.7નું પરિણામ 7.7 મળશે. 9/2.0નું પરિણામ 4.5 મળશે અને 9f/2નું પરિણામ 4.5 મળશે.

(3) મૉડ્યુલસ પ્રક્રિયક %ના કિસ્સામાં, જો પહેલો સંકાર્ય (Operand) ઋણ હોય, તો પરિણામ ઋણ મળશે.
જાવામાં % પ્રક્રિયક સાથે અપૂર્ણાંક ડેટાપ્રકાર પણ વાપરી શકાય છે. અહીં પરિણામ ભાગફળ પછી રહેલી શેષ છે.
ઉદાહરણ : 25.8 % 7 ના જવાબ માટે ભાગફળ 3 અને શેષ 4.8 છે.

(4) પ્રક્રિયક +નો ઉપયોગ શાબ્દિક લખાણને જોડવા માટે પણ કરી શકાય છે.

અંકગણિતીય પ્રક્રિયકોનો ઉપયોગ દર્શાવતો જાવા પ્રોગ્રામ આકૃતિ માં દર્શાવેલ છે.

આકૃતિ ના કોડ લિસ્ટિંગમાં કમાન્ડ System.out.println(“x + y=” + (x + y));માં ૨હેલ (x + y)માંથી કૌંસ ( ) કાઢી નાખવાની અસર આકૃતિ માં દર્શાવેલ છે.

ઇન્ક્રિમેન્ટ અને ડિક્રિમેન્ટ પ્રક્રિયકો (Increment and Decrement Operators)

એકપદી પ્રક્રિયક ++ અને – -ને અનુક્રમે ઇન્ક્રિમેન્ટ પ્રક્રિયક અને ડિક્રિમેન્ટ પ્રક્રિયક કહેવામાં આવે છે.
++ પ્રક્રિયક ચલમાં 1 ઉમેરે છે.
પ્રક્રિયક ચલમાંથી 1 બાદ કરે છે.
જ્યારે ચલના નામ પાછળ ++ અથવા – – પ્રક્રિયકનો ઉપયોગ કરવામાં આવે, ત્યારે તેને પોસ્ટ-ઇન્ક્રિમેન્ટ અથવા પોસ્ટ-ડિક્રિમેન્ટ કહેવાય છે. આવા સંજોગોમાં પદાવલીની ગણતરી કરતાં સમયે ચલની જૂની કિંમત વપરાય છે અને પછી ચલની કિંમત વધારવામાં કે ઘટાડવામાં આવે છે.
ઉદાહરણ : y = 4 + x++; વિધાનના અમલ પહેલા ચલ xની કિંમત જો ૩ હોય, તો ગણતરી કરતા સમયે xની જૂની કિંમત વપરાશે પછી xની કિંમતમાં 1નો વધારો થશે. આથી જવાબ 7 આવે.
જ્યારે ચલના નામ પહેલાં ++ અથવા – – પ્રક્રિયકનો ઉપયોગ કરવામાં આવે, ત્યારે તેને પ્રી-ઇન્ક્રિમેન્ટ અથવા પ્રી-ડિક્રિમેન્ટ કહેવાય છે. આ કિસ્સામાં ચલની કિંમત પહેલા વધારવામાં કે ઘટાડવામાં આવે છે અને પછી પદાવલીની ગણતરી થાય છે.
ઉદાહરણ : y = 4+ ++x; માં જો xની જૂની કિંમત ૩ હોય, તો પહેલા ૪ની કિંમતમાં 1નો વધારો થાય છે અને પછી ગણતરી થાય છે. આમ જવાબ 8 આવે.
નોંધ : જ્યારે ++ અથવા – -પ્રક્રિયક ફક્ત એક જ પદના વિધાનમાં વાપરવામાં આવે, ત્યારે ચલની પહેલાં કે પછીમાં કોઈ તફાવત નથી.

તુલનાત્મક પ્રક્રિયકો (Comparision Operators)

તુલનાત્મક પ્રક્રિયકને સંબંધાત્મક પ્રક્રિયક (Relational Operators) પણ કહેવાય છે. જાવામાં વપરાતા તુલનાત્મક પ્રક્રિયક અને તેમના અર્થ નીચે મુજબ છે :
A = = B A અને B “સમાન” છે?
A ! = B A અને B “સમાન નથી”?
A B A “B કરતાં મોટો” છે?
A < = B A “B કરતાં નાનો અથવા સમાન’’ છે?
A > = B A “B કરતાં મોટો અથવા સમાન” છે?
આ પ્રક્રિયકો કોઈ પણ પ્રકારના આંકડાકીય (Numeric) પ્રકારોની અને કૅરેક્ટર (Char) પ્રકારની કિંમતોની સરખામણી કરવા માટે વપરાય છે.
તુલનાત્મક પ્રક્રિયકના ઉપયોગથી પદાવલીનું પરિણામ બુલિયન મળે છે, એટલે કે પરિણામ true અથવા false હોય છે.
સામાન્ય રીતે, તુલનાત્મક પ્રક્રિયકોનો ઉપયોગ if વિધાનો અને લૂપ(Loops)માં થાય છે.

તાર્કિક પ્રક્રિયકો (Logical Operators)

તાર્કિક પ્રક્રિયકોને બુલિયન ઑપરેટર (Boolean Operator) પણ કહેવાય છે.
જાવામાં AND, OR, XOR અને NOT જેવાં તાર્કિક કાર્યો કરવા માટે અનુક્રમે &&, ||, ^ અને ! પ્રક્રિયકો વપરાય છે.
તાર્કિક પ્રક્રિયકો અને તેમના અર્થ નીચે મુજબ છે :

પ્રક્રિયકો	અર્થ	ઉપયોગ
A && B	જો A અને B બંને true હોય, તો પરિણામ true મળે નહીં તો false મળે.	AND કાર્ય માટે
A \|\| B	જો A અથવા B true હોય, તો પરિણામ true મળે નહીં તો false મળે.	OR માટે
A^B	જો A અને B અલગ અલગ હોય, તો જ true કિંમત મળે નહીં તો false મળે.	XOR (exclusive OR) માટે

તાર્કિક NOT માટે પ્રક્રિયક ! છે અને તે એકપદી (Unary) પ્રક્રિયક છે. તેનું પરિણામ પૂરકમાં (Compliment) પરિણમે છે. જો સંકાર્ય true હોય, તો પરિણામ false મળે અને એથી વિપરીત રીતે પણ.

શૉર્ટ સર્કિટિંગ (Short Circuiting)

જ્યારે શરતી પ્રક્રિયકો AND અથવા OR (&& અથવા ||) વા૫૨વામાં આવે છે, ત્યારે જાવા બીજા સંકાર્યની ગણતરી કરશે નહીં, જ્યાં સુધી પરિણામ મેળવવા તે જરૂરી ન હોય.
જો &&ના કિસ્સામાં પહેલું સંકાર્ય false હોય, તો બીજા સંકાર્યની ગણતરી કરવાની જરૂર નથી. એ જ પ્રમાણે ||ના કિસ્સામાં જો પહેલું સંકાર્ય true, હોય, તો બીજા સંકાર્ય કરવાની જરૂર નથી, જેને શૉર્ટ સર્કિટિંગ કહે છે.
ઉદાહરણ : (x ! = 0) && (y/x > 1)

શરતી પ્રક્રિયકો (Conditional Operators)

જાવામાં શરતી પ્રક્રિયક ત્રિપદી પ્રક્રિયક (Ternary Operator) છે, જેમાં ત્રણ સંકાર્ય (Operand) હોય છે.
તે ત્રણ સંકાર્ય (Operand) જુદા પાડવા માટે પદાવલીમાં બે ચિહ્નો ? અને ઃ નો ઉપયોગ કરે છે.
વાક્યરચના :

<boolean expression> ?
<expression1> : <expression2>

ઉદાહરણ :
next = (N % 2 = 0)? (N/2) : (3 * N + 1);
અહીં જો N % 2 = 0 મળે, તો next = N / 2 થશે નહીં તો next = 3* N + 1 થશે.
એટલે કે જો N = 8 હોય, તો next = 4 મળે અને જો N = 7 હોય, તો next = 22 મળે.

અસાઇનમેન્ટ (Assignment)

જાવામાં જે પદાવલી અસાઇનમેન્ટ પ્રક્રિયક (=) ધરાવતી હોય, તેને સામાન્ય રીતે અસાઇનમેન્ટ સ્ટેટમેન્ટ (Assignment Statement) કહેવામાં આવે છે.
આપણે એક વખત ચલ ઘોષિત (Declare) કરીએ પછી તેને કિંમત અસાઇનમેન્ટ પ્રક્રિયક “=” વડે આપી શકીએ છીએ.
વાક્યરચના : <ચલ> = <પદાવલી>
ઉદાહરણ : rate = 10.02 f;
balance = balance – cost;

શૉર્ટહૅન્ડ અસાઇનમેન્ટ પ્રક્રિયકો (Short-hand Assignment Operators)
જાવા પણ અસાઇનમેન્ટની શૉર્ટલૅન્ડ આવૃત્તિ પૂરી પાડે છે. તે ટાઇપ કરવાનો સમય બચાવે છે.
વાક્યરચના : <variable>
<operator> = <expression>
ઉદાહરણ : a += b એટલે કે a = a + b
q&& = p એટલે કે q = q && p

ટાઇપકાસ્ટ (Type-cast)

કેટલાક કિસ્સાઓમાં આપણે ફરજિયાતથી રૂપાંતર ઇચ્છતા હોઈએ કે જે આપમેળે ન બને, આ માટે આપણે જે વાપરીએ છીએ, તેને ટાઇપકાસ્ટ (Type-cast) કહે છે.
આપણે જે કિંમતનું રૂપાંતર ઇચ્છતા હોઈએ, તેની આગળ કૌંસમાં ટાઇપ-નેઇમ લખીને ટાઇપકાસ્ટ જણાવી શકાય છે.
ઉદાહરણ : inta; short b;
a = 17;
b = (short) a;
અહીં ચલ aનું ટાઇપકાસ્ટ વાપરીને short પ્રકારની કિંમતથી ચોક્કસપણે (Explicitly) રૂપાંતર કરેલું છે.

જાવા પ્રક્રિયકોના પ્રિસિડન્સ અને ઍસોસિ- ઍટિવિટી (Precedence and Associ- ativity of Java Operators)
જ્યારે પદાવલીમાં કેટલાક પ્રક્રિયકો હોય ત્યારે પદાવલીના પ્રક્રિયકોની કયા ક્રમમાં ગણતરી કરવી તે જણાવતા સારી રીતે વ્યાખ્યાયિત કરેલા નિયમો જાવા ધરાવે છે. આ પ્રક્રિયકોની અગ્રતા (Priority અથવા Precedence) પ્રમાણે પદાવલીની ગણતરી કરવામાં આવે છે.

અગ્રતાક્રમ કે પ્રિસિડન્સ ઑર્ડર (Precedence Order)
જ્યારે બે પ્રક્રિયકની અલગ અલગ અગ્રતા હોય, ત્યારે ઉચ્ચ અગ્રતા (Higher Precedence) ધરાવતા પ્રક્રિયક ઉપર પહેલાં પ્રક્રિયા કરવામાં આવે છે.
ઉદાહરણ : a + b * માં પહેલા b * cની ગણતરી થાય અને પરિણામને aમાં ઉમેરવામાં આવે છે.

સહચારિતા કે ઍસોસિઍટિવિટી (Associativity)

જ્યારે પદાવલીમાં એકસમાન પ્રિસિડન્સ ધરાવતા બે પ્રક્રિયકો હોય ત્યારે પદાવલીની ગણતરી તેના ઍસોસિઍટિવિટી પ્રમાણે કરવામાં આવે છે.
ઍસોસિઍટિવિટી કઈ દિશામાં (ડાબી બાજુથી જમણી બાજુ અથવા જમણી બાજુથી ડાબી બાજુ) કાર્ય કરવાનું છે, તે નક્કી કરે છે.
મોટા ભાગના કિસ્સામાં ઍસોસિઍટિવિટી ડાબી બાજુથી જમણી બાજુ હોય છે.
એકપદી કાર્યો અને અસાઇનમેન્ટમાં ઍસોસિઍટિવિટી જમણી બાજુથી ડાબી બાજુ હોય છે.
કોષ્ટક 7.4માં પ્રક્રિયકો અને તેનું પ્રિસિડન્સ દર્શાવેલ છે.

કોષ્ટક 7.4 : પ્રક્રિયકો અને તેનું પ્રિસિડન્સ

Operations	Operators	Associativity
Unary operations	++, –, !, unary – and +, type-cast	Right-to-left
Multiplication, division, modulus	*, ?, %	Left-to-right
Addition and subtraction	+, –	Left-to-right
Relational operators	<,>, <=, >=	Left-to-right
Relational operators (Equality and inequality)	= =, ! =	Left-to-right
Logical AND	&&	Left-to-right
Logical OR	\|\|	Left-to-right
Conditional operator	? :	Right-to-left
Assignment operators	=, +=, -=, *=, /=, %=	Right-to-left

કન્ટ્રોલ સ્ટ્રક્ચર (Control Structure)

સામાન્ય રીતે, પ્રોગ્રામમાં વિધાનોનો અમલ (Execution) એક પછી એક એમ ક્રમિક થાય છે. અમુક સમયે પ્રોગ્રામના તર્કને આ ક્રમનો પ્રવાહ બદલવાની જરૂર પડે છે. જે વિધાનોના અમલના પ્રવાહને નિયંત્રણ કરવા સમર્થ બનાવે છે, તેને નિયંત્રણ માળખાં કે કન્ટ્રોલ સ્ટ્રક્ચર (control structure) ગણવામાં આવે છે.
કન્ટ્રોલ સ્ટ્રક્ચર બે પ્રકારના હોય છે :
1. લૂપ (Loops) અને
2. બ્રાન્સિસ (Branches).
લૂપનો ઉપયોગ અમુક શરત સંતોષાય ત્યાં સુધી વિધાનોની શ્રેણીનું પુનરાવર્તન કરવાનો હોય ત્યારે થાય છે.
બ્રાન્ચનો ઉપયોગ જ્યારે બે કે વધુ શક્ય કાર્ય દિશામાંથી પસંદગી કરવાની હોય ત્યારે થાય છે. આથી તેને સિલેક્ટિવ સ્ટ્રક્ચર (Selective Structure) પણ કહેવામાં આવે છે.

કન્ટ્રોલ સ્ટ્રક્ચરના માળખાં એક વિધાન કે વિધાનોનો બ્લૉક હોઈ શકે છે.

બ્લૉક (Block)

બ્લૉક સ્ટેટમેન્ટ એ કોંસની જોડી “{” અને “}” વચ્ચે લખાયેલાં વિધાનોનું જૂથ છે.
બ્લૉકનો હેતુ સામાન્ય રીતે કન્ટ્રોલ સ્ટ્રક્ચરમાં વિધાનોની શ્રેણીના જૂથને એક-એક બનાવી એક વિધાન તરીકે ગણવા માટેનો હોય છે.
બ્લૉકની અંદર વિધાનોના સ્થાનિક અવકાશ (Local Scope) સાથે નવા ચલ બનાવી શકાય છે.

ઉદાહરણ :

{//This_block_exchanges the value of x and y
int temp;
temp=x;
x = y;
y = temp;
}

જ્યારે આપણે કોઈ પણ બ્લૉકની અંદર ચલ ઘોષિત કરીએ છીએ, ત્યારે તે ચલ તે બ્લૉકમાં જ સ્થાનિક (Local) રહે છે અને બ્લૉકની બહાર તેનું અસ્તિત્વ રહેતું નથી.
ઉપરના ઉદાહરણમાં temp એ સ્થાનિક ચલ છે. બ્લૉકની બહાર tempનો ઉપયોગ કરી શકાતો નથી.
ચલની કાર્યક્ષેત્રની મર્યાદા (Scope) પ્રોગ્રામનો એ ભાગ છે, જેમાં તે ચલ માન્ય છે. જે બ્લૉકમાં ચલ વ્યાખ્યાયિત કરેલો હોય તે બ્લૉક પૂરતો જ ચલનો સ્કોપ મર્યાદિત રહે છે.
જ્યારે આપણે કોઈ ચલના સ્કોપની અંદર બીજો ચલ તે જ નામનો ઘોષિત કરવા પ્રયત્ન કરીએ, ત્યારે ભૂલ (Error) મેળવીએ છીએ.
આકૃતિ માં આપેલા કોડ લિસ્ટિંગમાં આપણે blk2 નામના બ્લૉકમાં ચલ ૪ ઘોષિત કરવા પ્રયત્ન કરેલ છે. આથી કમ્પાઇલર ભૂલ દર્શાવશે.

આકૃતિ માં કોડમાં ફેરફાર કરીને દર્શાવ્યો છે.

રિપીટિટિવ કન્ટ્રોલ સ્ટ્રક્ચર (Repetitive Control Structures)
breakઅને continue વિધાનનો ઉપયોગ (Use of Break and Continue Statement)

break વિધાનનો ઉપયોગ સ્વિચ કે લૂપ પ્રકારની રચનાની બહાર પ્રોગ્રામનું નિયંત્રણ ફેરવવા માટે થાય છે.
જ્યારે સ્વિચ (Switch) સાથે break વાપરવામાં આવે છે, ત્યારે તે પછીનાં વિધાનોનો અમલ કર્યા વિના તેમને છોડી દઈને switch વિધાનના અંત પછીના પહેલા વિધાન ઉપર નિયંત્રણનું સ્થાનાંતર થાય છે.
લૂપમાં break વિધાન લૂપમાંથી નિર્ગમન (Exit) માટે વપરાય છે.
જ્યારે લૂપમાં break વિધાનનો અમલ થાય છે, ત્યારે લૂપમાં સમાયેલાં બધાં વિધાનો અમલ કર્યા વિના છોડી દેવામાં આવે છે અને પુનરાવર્તન અટકી જાય છે અને પ્રોગ્રામનું નિયંત્રણ લૂપના અંત પછીના પહેલા વિધાન ઉપર સ્થાનાંતર થાય છે.
continue વિધાનનો ઉપયોગ લૂપમાંના તેના પછીનાં વિધાનોને છોડી દેવા માટે અને તે પછીના પુનરાવર્તન માટે થાય છે.

નેસ્ટેડ લૂપ (Nested loops)
જાવામાં સમાન પ્રકારના કે અલગ પ્રકારના લૂપનું નેસ્ટિંગ (Nesting) કરી શકાય છે. આકૃતિ માં નેસ્ટેડ લૂપ, break અને continue વિધાનનો ઉપયોગ દર્શાવ્યો છે.

GSEB Computer Textbook Solutions Class 12 Chapter 7 જાવાની મૂળભૂત બાબતો

Computer Class 12 GSEB Notes Chapter 7 જાવાની મૂળભૂત બાબતો

Leave a Comment Cancel Reply