Students frequently turn to Computer Class 12 GSEB Solutions and GSEB Computer Textbook Solutions Class 12 Chapter 8 જાવામાં ક્લાસ અને ઑબ્જેક્ટ for practice and self-assessment.
GSEB Computer Textbook Solutions Class 12 Chapter 8 જાવામાં ક્લાસ અને ઑબ્જેક્ટ
પ્રશ્ન 1.
ઑબ્જેક્ટનું ઇન્સ્ટિન્સએશન એટલે શું?
ઉત્તરઃ
ઑબ્જેક્ટ બનાવવા (Creating Objects)
ક્લાસમાંથી ઑબ્જેક્ટ બનાવવા માટે નીચે જણાવેલાં પગલાઓની જરૂર પડે છે :
(1) ઘોષણા (Declaration),
(2) દૃષ્ટાંતીકરણ (Instantiation) અને
(3) શરૂઆતની કિંમત આપવી (Initialization).
(1) ઘોષણા (Declaration) : આ વિભાગમાં ઑબ્જેક્ટને ક્લાસ પ્રકારના ચલ તરીકે ઘોષિત કરવામાં આવે છે.
વાક્યરચના (Syntax) :
<classname> <variable name>
(2) દૃષ્ટાંતીકરણ (Instantiation) : આ વિભાગમાં મેમરી ફાળવીને ઑબ્જેક્ટ બનાવવા માટે new ચાવીરૂપ શબ્દ વપરાય છે.
(3) શરૂઆતની કિંમત આપવી (Initialization) : નવા બનાવેલા ઑબ્જેક્ટને શરૂઆતની કિંમત આપવા માટે કન્સ્ટ્રક્ટર (Constructor) કૉલ કરવામાં આવે છે.
ઉદાહરણ :
(1) ઘોષણા (Declaration) :
- ‘Room’ નામના ક્લાસનો ઑબ્જેક્ટ ઘોષિત કરવા માટેનું વિધાન Room r1; છે.
- ચલને ઘોષિત કરવાથી ઑબ્જેક્ટ બનતો નથી. જાવામાં કોઈ પણ ચલ ક્યારેય ઑબ્જેક્ટનો સંગ્રહ કરી શકતો નથી. ક્લાસ પ્રકારના ઉપયોગ વડે ઘોષિત કરેલો ચલ ફક્ત ઑબ્જેક્ટના નિર્દેશનો સંગ્રહ કરે છે. આથી ક્લાસ પ્રકારના ચલને નિર્દેશિત ચલ (Reference Variable) પણ કહેવામાં આવે છે. અહીં, r1 નિર્દેશિત ચલ (Reference Variable) છે.
(2) દૃષ્ટાંતીકરણ (Instantiation) :
- મેમરી ફાળવીને ઑબ્જેક્ટ બનાવવા માટે new ચાવીરૂપ શબ્દ વપરાય છે. પ્રક્રિયક new ઑબ્જેક્ટ માટેની મેમરી ફાળવશે અને ભવિષ્યમાં તેનો ઉપયોગ કરી શકાય તે માટે તે ઑબ્જેક્ટનો સ્થાનાંક (Address) પરત કરશે.
- રેફરન્સ (Reference) એ મેમરીનો સ્થાનાંક છે, જ્યાં ઑબ્જેક્ટનો સંગ્રહ કરેલો છે.
નોંધ : મેમરીનો ખાસ ભાગ કે જ્યાં ઑબ્જેક્ટ રાખવામાં આવે છે, તેને હીપ (Heap) કહેવામાં આવે છે.
r1 = new Room( ); - અહીં કૌંસ અગત્યના છે. ચલ (Argument) વગરના ખાલી કૌંસ પૂર્વનિર્ધારિત કન્સ્ટ્રક્ટરને કૉલ કરશે. તે પૂર્વનિર્ધારિત કિંમતો વડે ઑબ્જેક્ટના ઍટ્રિબ્યૂટની પ્રારંભિક કિંમત તેમાં મૂકશે.
- કૌંસમાં ચલ(Arguments)ની કિંમતો પણ હોઈ શકે છે, જે ચલની પ્રારંભિક કિંમત નક્કી કરે. આ વપરાશકર્તા નિર્મિત કન્સ્ટ્રક્ટરનો ઉપયોગ કરીને શક્ય છે.
નોંધ : ઑબ્જેક્ટ ઘોષિત કરવા અને બનાવવા માટે ઉપર જણાવેલા બંને પગલાંને નીચે જણાવ્યા પ્રમાણે એક વિધાનમાં ભેગાં કરી શકાય છે :
Room r2 = new Room( );
અહીં ચલ r2 મેમરી સ્થાનાંક ધરાવે છે, જ્યાં નવો ઑબ્જેક્ટ બનાવેલો છે. - ક્લાસ ફક્ત ચલનો પ્રકાર નક્કી કરે છે. ડેટા હકીકતમાં વ્યક્તિગત ઑબ્જેક્ટની અંદર હોય છે અને ક્લાસની અંદર નહીં. આમ દરેક ઑબ્જેક્ટને પોતાનો ડેટા સેટ હોય છે. આકૃતિ માં દર્શાવ્યા પ્રમાણે ઑબ્જેક્ટ r1 અને r2 તેમની ડેટાની કિંમતને રાખવા માટે અલગ અલગ મેમરીની ફાળવણી કરવામાં આવેલી છે.
- જાવામાં જ્યારે ઑબ્જેક્ટની પછી જરૂર રહેતી નથી, ત્યારે તે મેમરી ફરી વાપરવા માટે છૂટી કરવામાં આવે છે.
- જાવામાં ગાર્બેજ કલેક્ટર (Garbage Collector) હોય છે, જે વણવપરાયેલા ઑબ્જેક્ટને શોધે છે અને આ ઑબ્જેક્ટ દ્વારા રોકાયેલ મેમરી પાછી મેળવે છે, એટલે કે છૂટી કરે છે.
- જાવામાં મેમરી મુક્ત કરવા આપણે બાહ્ય રીતે કશું કરવાની જરૂર નથી હોતી.
જાવામાં વિવિધ ઇન્સ્ટન્સ (Instance)
-
- ઑબ્જેક્ટ ઇન્સ્ટિન્સએશન (Object Instantiation)
- ઇન્સ્ટન્સ (Instance)
- ઇન્સ્ટન્સ વેરિએબલ (Instance Variable)
- ઇન્સ્ટન્સ મેથડ (Instance Method)
- ઑબ્જેક્ટ આધારિત પ્રોગ્રામિંગ (oop) ભાષામાં ઑબ્જેક્ટ બનાવવાની ક્રિયાને ઑબ્જેક્ટ ઇન્સ્ટિન્સિએશન (Object Instatiation) કહેવામાં આવે છે.
- ઑબ્જેક્ટ માટે ડેટાનો સંગ્રહ કરવા માટે મેમરી ફાળવીને ઑબ્જેક્ટનો ઇન્સ્ટન્સ (Instance) નિર્મિત કરવામાં આવે છે.
- કોઈ ક્લાસનો જે ઑબ્જેક્ટ ભાગ હોય, તેને ક્લાસનો ઇન્સ્ટન્સ (Instance) કહેવામાં આવે છે.
નોંધ : ક્લાસ એ ઑબ્જેક્ટનું અમૂર્ત (Abstract) સ્વરૂપ છે, જ્યારે ઇન્સ્ટન્સ એ મૂર્ત કે સાકાર સ્વરૂપ છે. - ક્લાસનો દરેક ઇન્સ્ટન્સ ક્લાસમાં ઘોષિત કરેલા ચલના ઍટ્રિબ્યૂટ માટે અલગ અલગ કિંમત ધરાવી શકે છે. આ પ્રકારના ચલને ઇન્સ્ટન્સ વેરિએબલ (Instance Variable) કહે છે. ઑબ્જેક્ટ બનાવતા સમયે ઇન્સ્ટન્સ વેરિએબલનું નિર્માણ થાય છે અને ઑબ્જેક્ટના સંપૂર્ણ અસ્તિત્વ સુધી તે રહે છે.
- જાવામાં મેથડ ફક્ત ક્લાસની અંદર જ વ્યાખ્યાયિત કરી શકાય છે. આ મેથડ ઇન્સ્ટન્સ વેરિએબલની કિંમત મેળવવા અથવા બદલવા માટે ઑબ્જેક્ટનો ઉપયોગ કરીને ઇન્વોક (Invoke) કરી શકાય છે. આવી મેથડ ઇન્સ્ટન્સ મેથડ (Instance Method) તરીકે ઓળખાય છે.
કોડ લિસ્ટિંગ 1માં દર્શાવેલ Room નામના ક્લાસમાં
સારાંશ :
- new કી-વર્ડથી ઑબ્જેક્ટ બનાવી શકાય છે.
- new કી-વર્ડ ક્લાસના ઇન્સ્ટન્સને રજૂ કરતો ઑબ્જેક્ટનો નિર્દેશ પરત કરે છે.
- ક્લાસના બધા ઇન્સ્ટન્સની હીપ (Heap) તરીકે ઓળખાતા ડેટા સ્ટ્રક્ચરમાં મેમરીની ફાળવણી થાય છે.
- દરેક ઑબ્જેક્ટ ઇન્સ્ટન્સનો પોતાનો ડેટા સેટ હોય છે.
પ્રશ્ન 2.
ક્લાસ વેરિએબલની જરૂરિયાત બાબત એક ઉદાહરણ આપો.
ઉત્તરઃ
ક્લાસ વેરિએબલ અને ક્લાસ મેથડ (Class Variables and Class Methods)
- જ્યારે new કી-વર્ડ વડે ઑબ્જેક્ટ બનાવવામાં આવે છે, ત્યારે તેના મૅટ્રિબ્યૂટની કિંમતોનો સંગ્રહ કરવા હીપ (Heap) વિસ્તારમાંથી મેમરીની ફાળવણી કરવામાં આવે છે. આ રીતે દરેક ઑબ્જેક્ટના પોતાના ઇન્સ્ટન્સ વેરિએબલ હોય છે, જે મેમરીમાં અલગ અલગ જગ્યા રોકે છે.
- ધારો કે કોડ લિસ્ટિંગ 1માં દર્શાવેલ જાવા પ્રોગ્રામમાં બધા Room ઑબ્જેક્ટની windowની કુલ સંખ્યા આપણે જોઈએ છે, તો આ કિંમતનો સંગ્રહ કરવા માટે દરેક ક્લાસદીઠ આપણે ફક્ત એક જ ચલની જરૂર પડશે. આ ચલને દરેક ઑબ્જેક્ટના ઍટ્રિબ્યૂટ તરીકે રાખવો એ અર્થહીન છે. હકીકતમાં તે ઑબ્જેક્ટનો ઍટ્રિબ્યૂટ નથી પણ તે ક્લાસનો ઍટ્રિબ્યુટ છે.
- જ્યારે કેટલાક ચલની જરૂર હોય અને તે એક જ ક્લાસના બધા ઑબ્જેક્ટ ઇન્સ્ટન્સ વચ્ચે વાપરવાના હોય, તો દરેક ક્લાસદીઠ ચલને મેમરી ફક્ત એક વાર ફાળવવી જોઈએ. અહીં ચલ ક્લાસનો ભાગ છે ઑબ્જેક્ટનો નહીં.
- આવા ચલ ડેટાના પ્રકાર પહેલા static કી-વર્ડ વાપરીને ક્લાસમાં ઘોષિત કરવામાં આવે છે અને આ સ્ટેટિક વેરિએબલ (Static Variables) ક્લાસ વેરિએબલ (Class Variables) કહેવાય છે.
- ઇન્સ્ટન્સ વેરિએબલ કિંમત ઇન્સ્ટન્સ(ઑબ્જેક્ટ માટે ફાળવવામાં આવેલી મેમરી)માં સંગ્રહ કરવામાં આવે છે, જ્યારે ક્લાસ વેરિએબલ(સ્ટેટિક વેરિએબલ)ની કિંમત ક્લાસના પોતાનામાં જ સંગ્રહ કરે છે.
- ચાલો હવે ઇન્સ્ટન્સ વેરિએબલ સાથેના Room નામના ક્લાસમાં નીચેનું વિધાન ઉમેરીને totWindowsની કિંમત પ્રદર્શિત કરવા આપણે પ્રયત્ન કરીએ :
static int totWindows;
નોંધ : સ્ટેટિક વેરિએબલને ક્લાસના ઇન્સ્ટન્સ (ઑબ્જેક્ટ) બનાવ્યા વિના મેળવી શકાય છે. - ક્લાસ વેરિએબલની ક્લાસ મેથડ મેથડ ડેફિનેશન (Method Definition) પહેલા static કી-વર્ડ લખીને ઘોષિત કરી શકાય છે.
- કુલ બારીની સંખ્યા પ્રદર્શિત કરવા ‘Room’ ક્લાસની નીચેની મેથડ લખી શકાય :
static void displayTotalWindows( )
{
System.out.println(“Total Windows:" +totWindows);
}
- ક્લાસની બહાર <classname>.<class variable / class method>નો ઉપયોગ કરીને ક્લાસ વેરિએબલ અને ક્લાસ મેથડનો ઉપયોગ કરી શકાય છે :
દા. ત.,- Room.totWindows
- Room.displayTotalWindows( )
- આકૃતિ માં ક્લાસ વેરિએબલ totWindowsનો ઉપયોગ કરી જાવા પ્રોગ્રામ દર્શાવેલ છે. અહીં એ નોંધ કરશો કે ક્લાસના નામ વિના એક જ ક્લાસની મેથડનો ઉપયોગ કરી ક્લાસના સભ્યો(વેરિએબલ અને મેથડ)નો ઉલ્લેખ કરેલ છે.
- ક્લાસ મેથડ એ જાતે ક્લાસથી વૈશ્વિક હોય છે અને બીજા ક્લાસ કે ઑબ્જેક્ટને તે ઉપલબ્ધ હોય છે. આથી ક્લાસ મેથડ ક્લાસના ઇન્સ્ટન્સ અસ્તિત્વમાં છે કે નહીં તે ધ્યાનમાં લીધા વિના ગમે ત્યાં વાપરી શકાય છે.
- જે મેથડ કોઈ ચોક્કસ ઑબ્જેક્ટ ઉપર કાર્ય કરે અથવા ઑબ્જેક્ટને અસર કરે, તો તે ઇન્સ્ટન્સ મેથડ તરીકે વ્યાખ્યાયિત કરવી જોઈએ તથા જે મેથડ કેટલીક સામાન્ય યુટિલિટી પૂરી પાડે પણ ક્લાસના ઇન્સ્ટન્સ પર સીધી અસર ન કરે, તેને ક્લાસ મેથડ તરીકે ઘોષિત કરવી જોઈએ.
- ઉદાહરણ તરીકે, આપેલી કોઈ સંખ્યા અવિભાજ્ય (Prime) છે કે નહીં તે નક્કી કરતા વિધેયને ક્લાસ મેથડ તરીકે વ્યાખ્યાયિત કરવું જોઈએ. આકૃતિ માં આ માટેનું કોડ લિસ્ટિંગ તથા આઉટપુટ દર્શાવેલ છે.
ક્લાસ વેરિએબલ અને ક્લાસ મેથડ બાબતે યાદ રાખવાના મુદ્દા
- ક્લાસ વેરિએબલ અને ક્લાસ મેથડને ક્લાસ નેઇમ અથવા રેફરન્સ વેરિએબલથી એક્સેસ કરી શકાય છે.
- ક્લાસ વેરિએબલ અને ક્લાસ મેથડને ઇન્સ્ટન્સ મેથડમાંથી પણ એક્સેસ કરી શકાય છે.
- ઇન્સ્ટન્સ વેરિએબલ અને ઇન્સ્ટન્સ મેથડને ક્લાસ મેથડમાંથી એક્સેસ કરી ન શકાય. કારણ કે, ક્લાસ મેથડ કોઈ ઑબ્જેક્ટની હોતી નથી.
પ્રશ્ન 3.
મેથડ અને કન્સ્ટ્રક્ટર વચ્ચેનો તફાવત જણાવો.
ઉત્તર:
મેથડ અને કન્સ્ટ્રક્ટર વચ્ચેનો તફાવત (Difference between Method and Constructor)
| મેથડ (Method) | કન્સ્ટ્રક્ટર (Constructor) |
| 1. મેથડનું નામ ક્લાસના નામથી અલગ હોય છે. | 1. કન્સ્ટ્રક્ટરનું નામ ક્લાસના નામ સમાન જ હોવું જોઈએ. |
| 2. મેથડને પરત પ્રકા૨ (Return Type) હોઈ શકે છે. | 2. કન્સ્ટ્રક્ટરને પરત પ્રકાર (Return Type) હોતો નથી. |
| 3. મેથડ અંતર્ગત રીતે (Implicitly) ઇન્વોક કરી શકાતી નથી. | 3. જ્યારે new વાપરીને ઑબ્જેક્ટ બનાવવામાં આવે છે, ત્યારે જ કન્સ્ટ્રક્ટર અંતર્ગત રીતે (Implicitly) ઇન્વોક કરવામાં આવે છે. |
| 4. મેથડને પ્રોગ્રામમાં અન્ય કોઈ પણ જગ્યાએ સ્પષ્ટ રીતે (Explicitly) ઇન્વોક કરવામાં આવે છે. | 4. કન્સ્ટ્રક્ટર પ્રોગ્રામમાં અન્ય કોઈ પણ જગ્યાએ સ્પષ્ટ રીતે (Explicitly) ઇન્વોક કરવામાં આવતો નથી. |
- આકૃતિ માં આપેલ જાવા પ્રોગ્રામમાં કન્સ્ટ્રક્ટરનો ઉપયોગ દર્શાવેલ છે.
- અહીં ક્લાસનું નામ Room છે, તેમાં અલગ અલગ ઍટ્રિબ્યૂટને અલગ અલગ પ્રાચલોથી પ્રારંભિક કિંમત આપવા Room(float l, float w, float h, byte n) તથા Room(float l, float w) કન્સ્ટ્રક્ટરનો ઉપયોગ કરેલ છે.
- ઉપરાંત, નોંધ લેશો કે અહીં કન્સ્ટ્રક્ટરનું પણ ઓવરલોડિંગ કરવામાં આવેલ છે.
- ક્લાસમાં વપરાશકર્તા વ્યાખ્યાયિત કન્સ્ટ્રક્ટર(User Defined Constructor)ની ગેરહાજરીમાં ઑબ્જેક્ટ ચલ વગરના ડિફૉલ્ટ કન્સ્ટ્રક્ટર(Default Constructor)નો ઉપયોગ કરીને બનાવવામાં આવે છે અને પૂર્વનિર્ધારિત કિંમત ઍટ્રિબ્યૂટને આપવામાં આવે છે.
- ક્લાસમાં વપરાશકર્તા વ્યાખ્યાયિત કન્સ્ટ્રક્ટર(User Defined Constructor)ની હાજરીમાં ડિફૉલ્ટ કન્સ્ટ્રક્ટર (Default Constructor) ઉપલબ્ધ હોતા નથી.
- ચલ વગરના કન્સ્ટ્રક્ટર સાથેનો ઑબ્જેક્ટ બનાવવાનો પ્રયત્ન કરવામાં આવે, તો કમ્પાઇલ૨ એ૨૨ (Error) પરત કરે છે. આ સમસ્યાનું નિરાકરણ લાવવા માટે આપણે નીચે જણાવ્યા પ્રમાણે વપરાશકર્તા દ્વારા વ્યાખ્યાયિત કન્સ્ટ્રક્ટર પૂરો પાડવો જોઈએ :
<class name> ( ) { }; - આકૃતિ માં આપેલા કોડ લિસ્ટિંગ પ્રમાણે નીચે જણાવ્યા પ્રમાણે main મેથડમાં Room ઑબ્જેક્ટ બનાવવાનો પ્રયત્ન કરવામાં આવે, તો કમ્પાઇલર દ્વારા error દર્શાવવામાં આવશે :
Room r3=new Room( ); - આ error દૂર કરવા માટે વપરાશકર્તા વ્યાખ્યાયિત (User Defined) ચલ વગરનો કન્સ્ટ્રક્ટર ‘Room() { };’ ઉમેરો પછી તે પ્રોગ્રામનો અમલ કરો.
પ્રશ્ન 4.
એક્સેસર અને મ્યુટેટર મેથડ વિશે જણાવો.
ઉત્તરઃ
એક્સેસર અને મ્યુટેટર મેથડ (Accessor and Mutator Methods)
- અગાઉ આપણે સમજ્યા તે મુજબ ડેટાને private ઘોષિત કરીને તેનો એક્સેસ મર્યાદિત કરી શકાય છે અને તેનો મુખ્ય હેતુ અન્ય ક્લાસની મેથડ વડે તે સીધેસીધા એક્સેસ કરવાથી અથવા તેમાં ફેરફાર કરવાથી તેનું રક્ષણ કરવાનો છે.
- જો આપણે private ઘોષિત કરેલ ડેટાનો ઉપયોગ અન્ય (વ્યક્તિ) દ્વારા માન્ય રાખતા હોઈએ, તો આપણે એક્સેસર (Accessor) મેથડ લખીએ અને જો આ ડેટામાં ફેરફાર અન્ય (વ્યક્તિ) દ્વારા માન્ય રાખતા હોઈએ, તો આપણે મ્યુટેટર (Mutator) મેથડ લખીએ.
- પ્રણાલિકા પ્રમાણે એક્સેસર અને મ્યુટેટર મેથડના નામ ચલના પ્રથમ અક્ષર કૅપિટલ બનાવીને તેના પૂર્વગ તરીકે અનુક્રમે get અને set લખવામાં આવે છે. આ પ્રણાલીને એક્સેસર મેથડ ‘getter’ તરીકે અને મ્યુટેટર મેથડ ‘setter’ તરીકે પણ ઓળખવામાં આવે છે.
- આકૃતિ માં દર્શાવેલ કોડ લિસ્ટિંગમાં આપણે ‘getter’s મેથડ getLength( ) અને getWidth( ) મેથડનો ઉપયોગ કર્યો છે.
- જો આપણે અન્ય મેથડને ડેટાની કિંમતમાં ફેરફાર કરવાની પરવાનગી આપવા ઇચ્છતા હોય, તો આપણે ‘setter’ મેથડ વાપરવી જોઈએ. ઉદાહરણ તરીકે, setLength( ) મેથડને ‘length’ ઍટ્રિબ્યુટની કિંમત નીચે જણાવ્યા પ્રમાણે ચલ પસાર કરીને સેટ કરવા માટે વ્યાખ્યાયિત કરી શકાય છે :
void setlength(float l) {length = l;}
પ્રશ્ન 5.
સબક્લાસમાંથી સુપરક્લાસનો કન્સ્ટ્રક્ટર કેવી રીતે ઇન્વોક કરી શકાય?
ઉત્તર:
સબક્લાસમાંથી સુપરક્લાસનો કન્સ્ટ્રક્ટર કૉલ કરવા માટે સબક્લાસના કન્સ્ટ્રક્ટરમાં ચાવીરૂપ શબ્દ ‘super’ વાપરવો જોઈએ. કન્સ્ટ્રક્ટરમાં આ કૉલ પહેલું વિધાન હોવું જોઈએ.
પ્રશ્ન 6.
સુપરક્લાસની ઉપેક્ષા કરેલી મેથડ સબક્લાસમાંથી કેવી રીતે ઇન્વોક કરી શકાય?
ઉત્તરઃ
સુપરક્લાસની ઉપેક્ષા કરેલી મેથડ સબક્લાસમાંથી ઇન્વોક કરવા ચાવીરૂપ શબ્દ ‘super’ સાથે ડોટ પ્રક્રિયક અને મેથડનું નામ વાપરવું જોઈએ.
દા. ત., super.display( );
પ્રશ્ન 7.
‘એક્સેસ મૉડિફાયર’ વિશે ટૂંક નોંધ લખો.
ઉત્તર:
એક્સેસ કન્ટ્રોલ માટેના વિઝિબિલિટી મૉડિફાયર (Visibility Modifiers for Access Control)
- એક્સેસ કન્ટ્રોલ એટલે દૃશ્યતાનું નિયંત્રણ અને એક્સેસ મૉડિફાયર એટલે વિઝિબિલિટી મૉડિફાયર.
- જો મેથડ અથવા વેરિએબલ અન્ય ક્લાસમાં દૃશ્યમાન (Visible) હોય, તો જ અન્ય ક્લાસમાં તેનો ઉલ્લેખ કરી શકાય છે. આ પ્રકારના નિર્દેશથી મેથડ અથવા વેરિએબલને સુરક્ષિત રાખવા માટે આપણે ચાર સ્તરના વિઝિબિલિટીનો ઉપયોગ જરૂરી સુરક્ષા પૂરી પાડવા માટે કરીએ છીએ.
- સુરક્ષા કે પ્રૉટેક્શનના ચાર P’s છે.
- પબ્લિક (Public)
- પૅકેજ (Package) (પૂર્વનિર્ધારિત સુરક્ષા)
- પ્રૉટેક્ટેડ (Protected)
- પ્રાઇવેટ (Private)
નોંધ : જ્યારે કોઈ પણ મૉડિફાય૨ વાપરેલો ન હોય, ત્યારે તે પૂર્વનિર્ધારિત પ્રકારની વિઝિબિલિટી (Default Visibility) પૅકેજ છે, જેનો ક્લાસમાં સમાવેશ થાય છે.
- પૅકેજ (Package) વિવિધ ક્લાસને વ્યવસ્થિત રૂપ આપવા માટે વપરાય છે. આ માટે સોર્સ ફાઈલમાં પૅકેજ વિધાન સૌપ્રથમ કૉમેન્ટ ન હોય અને બૅન્ક લીટી ન હોય તે રીતે ઉમેરવામાં આવે છે.
- જ્યારે ફાઈલમાં પૅકેજ વિધાન ન હોય ત્યારે ફાઈલમાં વ્યાખ્યાયિત ક્લાસને ડિફૉલ્ટ પૅકેજમાં રાખવામાં આવે છે.
પૅકેજ વિધાનની વાક્યરચના (Syntax)
<package Name>; છે. - કોષ્ટક 1માં એક્સેસ મૉડિફાય૨ અને તેની વિઝિબિલિટી દર્શાવી છે.
પબ્લિક (Public)
- કોઈ પણ મેથડ કે ચલ જે ક્લાસમાં વ્યાખ્યાયિત કરેલા હોય તેમાં જ તે ઉપલબ્ધ (Visible) હોય છે. જો આપણે એ ક્લાસની બહાર બધા ક્લાસમાં તેમને ઉપલબ્ધ બનાવવા ઇચ્છતા હોઈએ, તો તે મેથડ અથવા ચલને પબ્લિક (Public) એક્સેસ માટે ઘોષિત કરવા જોઈએ.
- પબ્લિક (Public) એક્સેસ ચલ અથવા મેથડને અન્ય પૅકેજમાં વ્યાખ્યાયિત ક્લાસને પણ વિઝિબિલિટી પૂરી પાડે છે.
ઉદાહરણ : public float length;
public double area( );
અહીં, ચલ length અને મેથડ area( ) બધી જ જગ્યાએ વિઝિબલ હોય છે. આથી તેમને અન્ય સોર્સ ફાઈલ તથા પૅકેજમાં પણ એક્સેસ કરી શકાય છે.
પૅકેજ (કોઈ પણ મૉડિફાયર વિના) Package (Without any Modifier)
- પૅકેજ એ બીજા સ્તરનો એક્સેસ છે, જેને કોઈ નિશ્ચિત નામ નથી.
- પૅકેજ ઘોષિત કરવાના વિધાનમાં કોઈ પણ પ્રકારના એક્સેસ મૉડિફાયરની ગેરહાજરી વડે જણાવવામાં આવે છે.
- પૅકેજ એડિફૉલ્ટ (Default) સ્તરનું રક્ષણ પૂરું પાડે છે. તેનો વિસ્તાર (Scope) પબ્લિક ચલ કરતાં ઓછો છે.
- પૅકેજમાં બધી જગ્યાએથી ચલ કે મેથડને એક્સેસ કરી શકાય છે કે જ્યાં ક્લાસનો સમાવેશ થયેલ છે. પણ તે પૅકેજની બહાર નહીં.
- આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં ‘Rectangle’ ક્લાસના બે ઍટ્રિબ્યુટ છે : length અને width. તેને અનેક મેથડ પણ છે.
- આપણે અહીં કોઈ પણ મૉડિફાયર ચાવીરૂપ શબ્દ વાપર્યો નથી. આથી તેનું પૂર્વનિર્ધારિત રીતે package પ્રૉટેક્શન રહેશે.
- આથી સોર્સ ફાઈલમાં વ્યાખ્યાયિત અન્ય ક્લાસ ‘RectangleDemo’માં તે સીધેસીધા મેળવી શકાય છે.
પ્રૉટેક્ટેડ (Protected)
- આ સ્તરના પ્રૉટેક્શનનો ઉપયોગ ફક્ત સબક્લાસને એક્સેસ કરવા માટે અથવા ‘friend’ તરીકે ઘોષિત કરેલી મેથડ સાથે સહિયારા ઉપયોગ માટે થાય છે.
- પ્રૉટેક્ટેડની વિઝિબિલિટી પબ્લિક તથા પૅકેજ બંને કરતાં ઓછી હોય છે, પરંતુ પ્રાઇવેટ કરતાં વધુ હોય છે.
પ્રાઇવેટ (Private)
- પ્રાઇવેટ (Private) કક્ષાનું પ્રૉટેક્શન વાપરવાથી સૌથી ઉચ્ચ કક્ષાનું પ્રૉટેક્શન મેળવી શકાય છે.
- પ્રાઇવેટ સૌથી ઓછી દૃશ્યતા (Visibility) પૂરી પાડે છે.
- પ્રાઇવેટ મેથડ અને ચલને ક્લાસની અંદર જ વ્યાખ્યાયિત મેથડ દ્વારા સીધેસીધા એક્સેસ કરી શકાય છે તે અન્ય કોઈ પણ ક્લાસ દ્વારા એક્સેસ કરી શકાતા નથી.
- પ્રાઇવેટ પ્રકારનું મૉડિફાયર ડેટા ઇન્કેપ્સ્યુલેશન (Data Encapsulation) પૂરું પાડે છે. તે દુનિયાની નજરમાંથી ડેટાને છુપાવે છે અને તેને ખોટી રીતની ગણતરીની મર્યાદામાં રાખે છે.
- આકૃતિ માં દર્શાવેલ કોડ લિસ્ટિંગમાં ફેરફાર કરી length અને width ચલને private ઘોષિત કરો, જેથી તે ફક્ત Room( ) ક્લાસમાં જ વિઝિબલ થશે RoomDemo( ) ક્લાસમાં વિઝિબલ નહીં થાય. આથી જ્યારે આપણે area( ) અને display( ) મેથડમાં તેનો ઉપયોગ કરીશું ત્યારે તે કોઈ પણ પ્રકારની error નહીં બતાવે પણ જ્યારે RoomDemo( ) ક્લાસની main( ) મેથડમાં એક્સેસ કરવામાં આવશે ત્યારે તે error દર્શાવશે.
- ફેરફાર કરેલ કોડ આકૃતિ માં દર્શાવેલ છે, જ્યાં error દર્શાવેલ છે.
- બીજા ક્લાસમાંથી private ચલ મેળવવા અન્ય ક્લાસની મેથડનો ઉપયોગ કરી શકાય. કારણ કે, અન્ય ક્લાસની મેથડ વડે તે એક્સેસિબલ (Accessible) છે. તેના દ્વારા તે પરોક્ષ રીતે ઉપલબ્ધ બનાવી શકાય છે.
- આકૃતિ માં દર્શાવેલ કોડ લિસ્ટિંગમાં આપણે બે મેથડ getLength( ) અને getWidth( ઉમેરેલી છે. અહીં કોઈ પણ મૉડિફાયર વાપરેલો ન હોવાથી તેની પૅકેજ (Package) વિઝિબિલિટી છે. આથી તે અન્ય ક્લાસ ‘VisibilityPrivateB’માં ઉપલબ્ધ છે અને આ મેથડ દ્વારા private ચલ length અને widthની કિંમત મેળવી શકાય છે.
પ્રશ્ન 8.
ઇન્હેરિટન્સનો ઉપયોગ અને અલગ અલગ ક્લાસ વચ્ચે સંબંધના પ્રકાર પ્રમાણે કમ્પોઝિશન અથવા એગ્રિગેશનનો ઉપયોગ સમજાવો.
ઉત્તરઃ
કમ્પોઝિશન અને એગ્રિગેશન (Composition and Aggregation)
- કમ્પોઝિશન અને એગ્રિગેશન ક્લાસની રચના છે, જે અન્ય ઑબ્જેક્ટનો સમાવેશ કરે છે. તે અલગ અલગ ક્લાસ વચ્ચે ‘has – a’ પ્રકારનો સંબંધ રચે છે.
- ઉદાહરણ તરીકે, જો આપણે ‘Library’ નામનો ક્લાસ વ્યાખ્યાયિત કરીએ, તો તેને એક reading room (વાંચનખંડ) હોય છે.
- અહીં reading room એ ‘Room’ નામના ક્લાસનો એક ઑબ્જેક્ટ છે. આ રીતે Libraryમાં Room હોય છે.
- જ્યારે કોઈ ક્લાસ અન્ય ક્લાસના ઑબ્જેક્ટનો સમાવેશ કરે, ત્યારે તે કન્ટેઇનર ક્લાસ (Container Class) તરીકે ઓળખાય છે.
પ્રશ્ન 9.
મેથડ ઓવરલોડિંગ અને મેથડ ઓવરરાઇડિંગ વચ્ચેનો તફાવત સમજાવો.
ઉત્તરઃ
પૉલિમોર્ફિઝમ (મેથડ ઓવરલોડિંગ) – (Polymorphism (Method Overloading))
- પૉલિમોર્ફિઝમ શબ્દનો અર્થ ‘અનેક સ્વરૂપ’ કે ‘બહુરૂપતા’ થાય છે; એટલે કે એક જ નામ સાથે જુદી જુદી મેથડ.
- જાવામાં એક જ નામ ધરાવતી પણ અલગ અલગ સિગ્નેચર (Signature) ધરાવતી મેથડ હોઈ શકે છે. આને ‘મેથડ ઓવરલોડિંગ’ (Method Overloading) કહેવામાં આવે છે.
- મેથડની સિગ્નેચર એટલે મેથડનું નામ, પરતકિંમતનો પ્રકાર (Return type) અને પ્રાચલોની યાદીનો સમૂહ (Arguments) છે.
- ઉદાહરણ :
static int max(int x, int y) {…}
static int max(int x, int y, int z) {…}
static double max(double x, double y, double z) {…}
ઉપરના ઉદાહરણમાં જોઈ શકાય છે કે બે પૂર્ણાંક સંખ્યામાંથી મહત્તમ, ત્રણ પૂર્ણાંક સંખ્યામાંથી મહત્તમ, ત્રણ ડબલ પ્રિસિઝન ધરાવતી અપૂર્ણાંક સંખ્યામાંથી મહત્તમ કિંમત શોધવા માટે એકસરખું નામ (Max) ધરાવતી પણ અલગ અલગ સિગ્નેચર ધરાવતી મેથડ દર્શાવેલ છે, જેને મેથડ ઓવરલોડિંગ’ કહેવામાં આવે છે.
આકૃતિ માં Printline( ) મેથડનું ઓવરલોડિંગ દર્શાવતા જાવા પ્રોગ્રામનું કોડ લિસ્ટિંગ દર્શાવેલ છે.
અહીં, Printline( ) : 40 વાર ‘=’ અક્ષર છાપશે.
Printline(int n) : n વાર # અક્ષર છાપશે.
Printline(int n, char ch) : n વાર જણાવેલ અક્ષર ch છાપશે.
Computer Class 12 GSEB Notes Chapter 8 જાવામાં ક્લાસ અને ઑબ્જેક્ટ
પરિચય (Introduction)
- ઑબ્જેક્ટ આધારિત પ્રોગ્રામિંગમાં ક્લાસ (Class) અને ઑબ્જેક્ટ (Object) એ પાયાના એકમો છે.
- ક્લાસ (Class) ઍટ્રિબ્યૂટ અને વિધેય (મેથડ) બંને ધરાવે છે.
- ક્લાસ એ એકસમાન લાક્ષણિકતાઓ ધરાવતા અનેક ઑબ્જેક્ટનું એક માળખું (Template) છે.
- જાવા પ્રોજૅક્ટમાં ફક્ત એક જ ક્લાસ વાપરવો શક્ય છે, પણ મોટા વિનિયોગ માટે સૉફ્ટવેર ડિઝાઇન કરતા સમયે સંપૂર્ણ વિનિયોગને સરળ ઘટકોમાં વિભાજિત કરી, દરેક ઘટક કે ભાગનો આપણે એક ક્લાસ બનાવવો જોઈએ.
‘Room’ નામના ઉદાહરણ દ્વારા ક્લાસ અને ઑબ્જેક્ટની સમજ (Understanding Class and Object With An Example Named ‘Room’)
- ઘર, છાત્રાલય, હૉટેલ અથવા નિશાળખંડની લાક્ષણિકતાઓ એકસમાન હોય છે. દરેક ખંડ તેની પ્રૉપર્ટી
જેમ કે; length, height, number of windows, number of doors અને directionથી અજોડ રીતે ઓળખાય છે. - ઉપરની બધી પ્રૉપર્ટી લઈ શકાય, પરંતુ આપણે Room નામના ક્લાસમાં સરળતા ખાતર length, width, height અને number of windows પ્રૉપર્ટી જ લઈશું.
- કોડ લિસ્ટિંગ 1 માં દર્શાવ્યા મુજબનો જાવા પ્રોગ્રામ કોઈ પણ ટેક્સ્ટ એડિટરમાં લખો.
કોડ લિસ્ટિંગ 1 : ક્લાસ અને ઑબ્જેક્ટ બનાવવા અને તેનો ઉપયોગ કરવો
/* Class Room */
class Room
{
float length, width, height;
byte nWindows;
void setAttr(float l, float w, float h, byte n)
{
length = l; width = w; height = h;
nWindows=n;
} // end setAttr() Method
double area() // area=length*width
{
return(length*width);
} // end area() Method
void display()
{
System.out.println ("\nLength : " + length);
System.out.println ("Width :" +width);
System.out.println ("Height : " + height);
System.out.println ("Number of Windows :"+nWindows);
} // end display() Method
} //end Room Class
/* using Room class to create objects and run application */
class RoomDemo
{
public static void main(String args[])
{
// Create a room object, assign default values to attributes
Room r1; // reference variable with null value by default
r1=new Room();
// Both declare and create in one statement
Room 12=new Room();
// Display two room objects with initial default values
r1.display();
12.display();
// Assign values of attributes of objects
r1.setAttr(18, 12.5f, 10, (byte)2);
r2.setAttr(14, 11, 10, (byte)1);
// Display updated contents
r1.display();
12.display();
// Display area
System.out.println("\n Area of room with length "+ r1.length +"width"+ r1.width+" is "+ r1.area());
System.out.println("\n Area of room with length" + r2.length +"width" + r2.width+" is "+12.area());
} //end main()
} //end RoomDemo
- કોડ લિસ્ટિંગ 1માં દર્શાવેલ જાવા પ્રોગ્રામમાં ‘Room’ નામના ક્લાસમાં 4-ઍટ્રિબ્યુટ (length, width, height અને nWindows) અને 3-મેથડ (setAttr, area અને display) છે.
setAttr મેથડ ઍટ્રિબ્યૂટને કિંમત અસાઇન કરશે, area મેથડ ક્ષેત્રફળની ગણતરી કરશે અને display મેથડ તેના ઍટ્રિબ્યુટ પ્રદર્શિત કરશે. - અહીં પ્રથમ ‘Room’ નામનો ક્લાસ બનાવવા માટે કોડ લખેલ છે. તે પછી ‘Room’ ક્લાસના ઑબ્જેક્ટ બનાવવા માટેનો કોડ લખેલો છે. આ કાર્ય કરવા માટે main ) મેથડ ધરાવતો એક બીજો ક્લાસ ‘RoomDemo’ બનાવેલ છે. સોર્સ ફાઈલમાં આ ક્લાસ કોઈ પણ ક્રમમાં હોઈ શકે.
નોંધ : જાવામાં જ્યારે એક પ્રોગ્રામમાં બે અવા વધારે ક્લાસ હોય, ત્યારે ફક્ત એક જ ક્લાસ main ) મેથડ ધરાવી શકે. - આકૃતિ માં કોડ લિસ્ટિંગ 1માં દર્શાવેલ જાવા પ્રોગ્રામનો SciTE ટેક્સ્ટ એડિટરમાં અમલ દર્શાવેલ છે, જે નીચે મુજબ કાર્ય કરે છેઃ
- સૌપ્રથમ Room ક્લાસના બે ઑબ્જેક્ટ r1 અને r2 બનાવવામાં આવ્યા છે અને તેને પૂર્વનિર્ધારિત કિંમત આપવામાં આવી છે. (અહીં કિંમત શૂન્ય છે.)
- ત્યારબાદ display મેથડ વડે આ બંને ઑબ્જેક્ટની માહિતી પ્રદર્શિત કરવામાં આવી છે.
- ન્યુમરિક લિટરલ પ્રાચલો સાથે setAttr( ) મેથડનો અમલ (Invoke) કરીને બંને ઑબ્જેક્ટ r1 અને 12ના ઍટ્રિબ્યૂટમાં ફેરફાર કરવામાં આવે છે.
- બંને ઑબ્જેક્ટની નવી માહિતી r1.display( ) તથા r2.display( ) મેથડ વડે પ્રદર્શિત કરવામાં આવી છે.
- અંતમાં, બંને Room ઑબ્જેક્ટ r1 અને 12નું ક્ષેત્રફળ પ્રદર્શિત કરવામાં આવ્યું છે, જેના માટે area( ) મેથડનો ઉપયોગ કરેલ છે.
જાવામાં ક્લાસ (Class in Java)
- ક્લાસ એ એકસમાન લાક્ષણિકતાઓ ધરાવતા અનેક ઑબ્જેક્ટનું એક માળખું (Template) છે. ક્લાસ કોઈ ચોક્કસ ઑબ્જેક્ટના જૂથની લાક્ષણિકતાઓને સમાવે છે.
દા. ત., ‘Room’ ક્લાસ એ બધા ખંડની સામાન્ય લાક્ષણિકતાઓ સાથેનું એક ટેમ્પ્લેટ છે.
જાવા ક્લાસ વ્યાખ્યાયિત કરવાની વાક્યરચના (Syntax) :
class <ClassName>
{
<variables>
<methods>
}
સામાન્ય રીતે જાવા ક્લાસ બે ઘટકોનો બનેલો હોય છે : (1) ઍટ્રિબ્યુટ (Attribute) અને (2) બિહેવીયર (Behaviour).
- ઍટ્રિબ્યૂટને ક્લાસમાં ચલથી વ્યાખ્યાયિત કરવામાં આવે છે. બિહેવીયરને ક્લાસમાં મેથડથી વ્યાખ્યાયિત કરવામાં આવે છે. મેથડનો ઉપયોગ ઍટ્રિબ્યૂટને મેળવવા અને તેમાં ફેરફાર કરવા માટે થાય છે.
ઇન્સ્ટન્સ વેરિએબલ એક્સેસ કરવા અને ઇન્સ્ટન્સ મેથડ કૉલ કરવી (Accessing Instance Variables and Calling Instance Methods)
ઇન્સ્ટન્સ વેરિએબલ અને ઇન્સ્ટન્સ મેથડ ઑબ્જેક્ટ દ્વારા મેળવવામાં આવે છે. તેનો નિર્દેશ નીચે દર્શાવેલ વાક્યરચના મુજબ ડોટ પ્રક્રિયક (.) દ્વારા કરી શકાય છે.
વાક્યરચના (Syntax) : <object reference>.<instance variable or method>
ઉદાહરણ :
- r1.length
- r1.display( )
ક્લાસમાં ઘોષિત કરેલા ચલ(વેરિએબલ)નું વર્ગીકરણ (Classification of Variables Declared in a Class)
ક્લાસમાં ઘોષિત કરેલા ચલને ત્રણ પ્રકારમાં વર્ગીકૃત કરી શકાય છે :
(1) લોકલ વેરિએબલ (Local Variable)
(2) ઇન્સ્ટન્સ વેરિએબલ (Instance Variable)
(3) ક્લાસ વેરિએબલ (Class Variable)
(1) લોકલ વેરિએબલ (Local Variable) :
- જે વેરિએબલ મેથડ કે બ્લૉકની અંદર વ્યાખ્યાયિત કરેલા હોય તેને લોકલ વેરિએબલ કહેવામાં આવે છે.
- જ્યારે બ્લૉકની શરૂઆત થાય ત્યારે તેનું નિર્માણ થાય છે અને જ્યારે મેથડ કે બ્લૉકનો અંત આવે ત્યારે તેનો નાશ થાય છે.
- લોકલ વેરિએબલની પૂર્વનિર્ધારિત કિંમતોથી શરૂઆત થતી નથી.
(2) ઇન્સ્ટન્સ વેરિએબલ (Instance Variable) :
- ઇન્સ્ટન્સ વેરિએબલ એ કોઈ ક્લાસમાં પણ મેથડની બહાર વ્યાખ્યાયિત કરેલા ચલ (Variable) છે.
- આ ચલ જ્યારે ઑબ્જેક્ટ નિર્મિત થાય છે, ત્યારે હીપ (Heap) વિસ્તારમાંથી મેમરીની ફાળવણી થાય છે.
- ઇન્સ્ટન્સ વેરિએબલને પૂર્વનિર્ધારિત કિંમતો આરંભમાં આપવામાં આવે છે.
(3) ક્લાસ વેરિએબલ (Class Variable) :
- ક્લાસ વેરિએબલને કોઈ ક્લાસની અંદર, મેથડની બહાર અને static ચાવીરૂપ શબ્દ સાથે વ્યાખ્યાયિત કરવામાં આવે છે.
- આ ચલને ક્લાસદીઠ ફક્ત એક વાર મેમરીની ફાળવણી થાય છે અને તેના બધા ઑબ્જેક્ટ વડે વાપરી શકાય છે.
- ક્લાસ વેરિએબલને પૂર્વનિર્ધારિત કિંમતો આરંભમાં આપવામાં આવે છે.
Class Room
{
float length;
static int totWindows;
void setAttr(float 1)
}
....
....
}
}
અહીં, length → ઇન્સ્ટન્સ વેરિએબલ, totWindows → ક્લાસ વેરિએબલ અને 1 → લોકલ વેરિએબલ છે.
કન્સ્ટ્રક્ટર્સ (Constructors)
- કન્સ્ટ્રક્ટર (Constructor) એક વિશિષ્ટ પ્રકારની મેથડ છે કે જે નવા ઑબ્જેક્ટ નિર્મિત કરતા સમયે ઇન્વોક કરવામાં આવે છે.
- કન્સ્ટ્રક્ટર મુખ્યત્વે પ્રારંભિક કિંમતો (Initial Values) આપવા માટે રચવામાં આવે છે.
- દરેક ક્લાસના ડિફૉલ્ટ કન્સ્ટ્રક્ટર (Default Constructor) હોય છે; કોઈ વાર તેને ચલ વગરના કન્સ્ટ્રક્ટર તરીકે પણ ઓળખવામાં આવે છે. ડિફૉલ્ટ કન્સ્ટ્રક્ટર કોઈ ચલ (Arguments) લેતાં નથી. તે નવા બનાવેલા ઑબ્જેક્ટના ઍટ્રિબ્યૂટને તેના ડેટાપ્રકાર પ્રમાણે પૂર્વનિર્ધારિત કિંમતો આપે છે.
મેથડમાં પ્રાચલ તરીકે ઑબ્જેક્ટ પસાર કરવો (Passing Object as a Parameter in a Method)
- ચલના પ્રાથમિક ડેટાપ્રકાર અને ઉપલબ્ધ સમાવિષ્ટ (Built-in) ડેટાપ્રકારોની જેમ જ ઑબ્જેક્ટ પણ મેથડમાં પ્રાચલ (Parameter) તરીકે પસાર કરી શકાય છે.
- ઉદાહરણ તરીકે, આપણે rectangle ઑબ્જેક્ટ ઇન્વોક કરતી મેથડનું ક્ષેત્રફળ અન્ય લંબચોરસ કરતાં વધુ છે કે નહીં તે નક્કી કરવા ઇચ્છીએ છીએ.
- આ માટે આપણે મેથડ લખીએ, જેમાં અન્ય rectangle ઑબ્જેક્ટ એક ચલ કે પ્રાચલ તરીકે પસાર કરીએ.
- આકૃતિ માં દર્શાવ્યા પ્રમાણે ક્લાસ Rectangleમાં ‘isLarge’ નામની મેથડ ઉમેરીએ અને તેને main( ) મેથડમાં વાપરીએ છીએ.
- આકૃતિ માં દર્શાવ્યા પ્રમાણે main( ) મેથડમાં if વિધાનની અંદરનો મેથડ કૉલ જુઓ :
rectl.isLarge(rect2)
અહીં, rect1 : કૉલિંગ અથવા ઇન્વોકિંગ ઑબ્જેક્ટ છે અને rect2 : પ્રાચલ તરીકે પસાર કરેલો ઑબ્જેક્ટ છે.
ઇન્હેરિટન્સ (Inheritance)
- ઑબ્જેક્ટ આધારિત પ્રોગ્રામિંગમાં ઇન્ડેરિટન્સ આપણને હયાત ક્લાસને વિસ્તૃત કરીને વધારાના સામર્થ્ય સાથેનો નવો ક્લાસ બનાવવાની સગવડ આપે છે.
- ઇન્હેરિટન્સ બે ક્લાસ ‘is – a’ પ્રકારનો સંબંધ ધરાવતું મૉડેલ છે. ઉદાહરણ તરીકે, classroom એ room છે અને student એ person છે.
- અહીં, room અને personને પૅરેન્ટ ક્લાસ (Parent Class) કહેવામાં આવે છે.
નોંધ : પૅરેન્ટ ક્લાસને સુપરક્લાસ (Superclass) અથવા બેઇઝ ક્લાસ (Base Class) પણ કહે છે. - અહીં, classroom અને studentને ચાઇલ્ડ ક્લાસ (Child Class) કહેવામાં આવે છે.
નોંધ : ચાઇલ્ડ ક્લાસને સબક્લાસ (Subclass) અથવા એક્સ્પેન્ડેડ ક્લાસ (Extended Class) પણ કહે છે. - જ્યારે બે ક્લાસ વચ્ચે ‘is – a’ પ્રકારનો સંબંધ હોય છે, ત્યારે આપણે ઇન્હેરિટન્સનો ઉપયોગ કરીએ છીએ.
- ઇન્હેરિટન્સમાં સામાન્ય ગુણધર્મો સુપરક્લાસ(Super- class)માં રાખવામાં આવે છે. જ્યારે સબક્લાસ સુપર- ક્લાસમાંથી બધા ઇન્સ્ટન્સ વેરિએબલ અને મેથડ વારસામાં મેળવે છે. તેમજ તેને પોતાના વધારાના વેરિએબલ અને મેથડ હોઈ શકે છે.
નોંધ : સબક્લાસમાં કન્સ્ટ્રક્ટર વારસામાં મળતા નથી. - ઉદાહરણ તરીકે, roomની જેમ classroomને પણ length, width, height અને number of windows ચલ હોય છે. આ ઉપરાંત તેમાં benchesની સંખ્યા અને દરેક benchના વિદ્યાર્થીઓ સમાવવાની ક્ષમતા પણ હોય છે.
- આ જ રીતે સબક્લાસ સુપરક્લાસની બધી જ મેથડ વારસામાં મેળવે છે અને તેની પોતાની વધારાની મેથડ પણ હોઈ શકે છે. અહીં સબક્લાસ classroom વધારાની મેથડ show( ), display( ), getSeats( ) તેના કન્સ્ટ્રક્ટરની મેથડ છે.
- આકૃતિ માં ક્લાસ ડાયાગ્રામ દર્શાવ્યો છે; જેમાં ‘Classroom’ નામનો ક્લાસ છે, જે તેના ‘Room’ નામના પૅરેન્ટ ક્લાસમાંથી આવેલો (Derived) છે. અહીં, તીર સબક્લાસથી સુપરક્લાસ તરફ નિર્દેશ કરે છે.
- જ્યારે સબક્લાસને ઑબ્જેક્ટ ઇન્સ્ટન્સએટ (Instantiate) થાય છે, ત્યારે ઇન્હેરિટ થયેલા સાથે તેના બધા ઍટ્રિબ્યૂટને મેમરી ફાળવવામાં આવે છે. આકૃતિ માં સુપરક્લાસ Room અને સબક્લાસ Classroomના ઇન્સ્ટન્સ દર્શાવ્યા છે.
- જાવામાં સબક્લાસ બનાવવા માટે ક્લાસની વ્યાખ્યામાં ચાવીરૂપ શબ્દ ‘extends’ વાપરવામાં આવે છે. હયાત
ક્લાસ ‘Room’નો ઉપયોગ કરીને સબક્લાસ ‘Classroom’ બનાવવા માટેના પ્રોગ્રામ કોડ લિસ્ટિંગ 2 તથા કોડ લિસ્ટિંગ 3માં દર્શાવેલ છે.
કોડ લિસ્ટિંગ 2 : ઇન્હેરિટન્સના ઉપયોગનું ઉદાહરણ
class Room
{
float length,width,height;
byte nWindows;
static int totWindows; // class variable
Room() { }; // user-defined no-argument constructor
Room (float l, float w, float h, byte n)
{
length = l; width = w; height = h;
nWindows=n; totWindows+=n;
}
Room(float l, float w)
{
length = l; width = w; height = 10;
nWindows = 1; totWindows++;
}
double area() // area-length*width
{ return(length*width); } //end area() Method
void display()
{
System.out.println("\nLength : " + length + "\nWidth :"+width)
System.out.println ("Height : " + height);
System.out.println ("Windows :"+nWindows);
} // end display() Method
} // end Room Class
કોડ લિસ્ટિંગ 3 : Classroom નામના સબક્લાસનો કોડ
class Classroom extends Room
{
int nBenches, nSeatsBench;
Classroom() { };
Classroom(float l, float w, float h, byte n, int nB, int nSB)
{
super(l,w,h,n);
nBenches = nB; nSeatsBench = nSB;
}
void show()
{
super.display();
System.out.println("Benches : " + nBenches );
System.out.println("Seats per Bench: "+nSeatsBench);
System.out.println("Total Seats in a class : " + getSeats() );
}
void display()
{
System.out.println("\nClassroom with length " + length + "feet, width" +width + "feet\nhas "+nBenches + "Benches, each to accomodate"
+nSeatsBench + "Students\nSo,Total seats in a class is +getSeats());
}
int getSeats()) { return nBenches * nSeatsBench;}
} // end class Classroom
- સુપરક્લાસના કન્સ્ટ્રક્ટર સબક્લાસમાં વારસામાં આવતા ન હોવાથી સુપરક્લાસના કન્સ્ટ્રક્ટરને કૉલ કરવા માટે સબક્લાસના કન્સ્ટ્રક્ટરમાં ચાવીરૂપ શબ્દ ‘super’ વાપરેલો છે.
- જ્યારે સુપરક્લાસ અને સબક્લાસ બંનેમાં એકસમાન સિગ્નેચર(Signature)ની મેથડ હોય, ત્યારે સુપરક્લાસ મેથડની સબક્લાસમાં ઉપેક્ષા કરવામાં આવે છે.
- અહીં સબક્લાસની display( ) મેથડ સુપરક્લાસની display( ) મેથડની ઉપેક્ષા કરે છે. જ્યારે આપણે સુપર- ક્લાસની આવી મેથડનો ઉલ્લેખ કરીએ, ત્યારે આપણે ચાવીરૂપ શબ્દ ‘super’ સાથે ડોટ પ્રક્રિયક અને મેથડનું નામ વાપરવું જોઈએ.
દા. ત., super.display( ); - કોડ લિસ્ટિંગ 4માં Room અને Classroomના ઉપયોગ સાથેનો વિનિયોગ દર્શાવેલ છે.
કોડ લિસ્ટિંગ 4 : Room અને Classroomના ઉપયોગ સાથેનો વિનિયોગ
class Inheritance /* Application using Room, Classroom */
{
public static void main(String args[])
{
Room r1 = new Room(20, 15, 10, (byte)2);
r1.display();
Classroom cr1 = new Classroom (30, 20, 12, (byte)3, 21, 3);
cr1.show);
system.out.println("Area of classroom1 is ' + cr1.area() + '' square feet '');
Classroom cr2 = new Classroom (30,30,10, (byte)4, 20, 4);
cr2. display);
System.out.println("\nTotal number of Windows : "+Room.totWindows);
} // end main()
} // end Inheritance
- અહીં, આપણે સુપરક્લાસ અને સબક્લાસ બંનેના ઑબ્જેક્ટ બનાવેલા છે. તથા બધા જ ઇન્સ્ટન્સ વેરિએબલ અને મેથડ સુપરક્લાસમાંથી સબક્લાસમાં ઇન્હેરિટ થાય છે.
- કોડ લિસ્ટિંગ 2, 3 અને 4ને ભેગા કરીને બનાવેલા કોડનું આઉટપુટ આકૃતિ માં દર્શાવ્યું છે.
સુપરક્લાસના પ્રાઇવેટ મેમ્બર (Private Members of Superclass)
- આગળના ઉદાહરણમાં જો આપણે સુપરક્લાસના ઇન્સ્ટન્સ વેરિએબલની વિઝિબિલિટી બદલીને Private કરીશું, તો આ વેરિએબલ ક્લાસની બહાર સીધા ઉપલબ્ધ નહીં રહે, પરંતુ આ ઍટ્રિબ્યુટ સબક્લાસના પણ છે, છતાં પ્રાઇવેટ ઇન્સ્ટન્સ વેરિએબલ અથવા મેથડ તેના સબક્લાસમાં પણ વિઝિબલ નથી.
- નીચે જણાવ્યા પ્રમાણે કોડ લિસ્ટિંગ 2માં ઇન્સ્ટન્સ વેરિએબલને ઘોષિત કરવાના વિધાનમાં તેને private બનાવો અને આકૃતિ માં દર્શાવ્યા પ્રમાણે તેના આઉટપુટમાં error આવી તેનું નિરીક્ષણ કરો.
private float length, width, height;
private byte nWindows;
- યાદ રાખો કે આ પ્રાઇવેટ મેમ્બરને અન્ય જગ્યાએ ઉપલબ્ધ કરવા માટે પબ્લિક એક્સેસર અને મ્યુટેટર મેથડ ‘getter’ અને ‘setter’મેથડનો ઉપયોગ કરો.
સુપરક્લાસના પ્રૉટેક્ટેડ મેમ્બર (Protected Members of Superclass)
- ઇન્હેરિટેડ સબક્લાસમાં ‘protected’ મેમ્બર ‘private’ મેમ્બર તરીકે ઉપલબ્ધ હોય છે.
- નીચે જણાવ્યા પ્રમાણે ‘Room’ ક્લાસના ઇન્સ્ટન્સ વેરિએબલને બદલીને ‘protected’ કરી બદલાયેલા કોડનો અમલ કરતાં આકૃતિ જેવું જ પરિણામ મળશે.
protected float length, width, height;
protected byte nWindows;
ક્લાસ અને ઑબ્જેક્ટનાં અન્ય ઉદાહરણ (Other Examples of Class and Object)
(1) દરેક વ્યક્તિનું name અને address હોય છે. અહીં name ક્લાસ Nameમાં છે, જેને firstname, middlename lastname 27H ત્રણ ઍટ્રિબ્યુટ છે.
તે જ પ્રમાણે address ક્લાસ Addressમાં છે, જેના ઍટ્રિબ્યુટ housenumber, appartment/society name, area, city, state, country અને pincode છે.
(2) કારને steering, wheels અને engine હોય છે. અહીં steering ક્લાસ Steering માં છે, wheel ક્લાસ Wheelમાં છે અને engine ક્લાસ Engine માં છે. તથા ક્લાસ car ના આ ત્રણેય ઍટ્રિબ્યુટ છે.
- હવે આપણે નીચે જણાવેલ ઍટ્રિબ્યૂટ સાથેનો ક્લાસ ‘Library’ બનાવીએ :
- nBooks : int – પુસ્તકાલયમાં પુસ્તકોની સંખ્યા
- nMagazines : int – પુસ્તકાલયમાં લવાજમ ભરેલાં સામિયકોની સંખ્યા
- nNewspapers : int – પુસ્તકાલયમાં લવાજમ ભરેલાં વર્તમાનપત્રોની સંખ્યા
- readingRoom : Room – ‘Room’ ક્લાસ ટાઇપનો ઍટ્રિબ્યૂટ readingRoom
- કોડ લિસ્ટિંગ 5માં Room અને Library નામના ક્લાસ બનાવવાનો કોડ અને તેનો ‘Container.java’ નામના વિનિયોગમાં ઉપયોગ દર્શાવ્યો છે.
કોડ લિસ્ટિંગ 5 : કમ્પોઝિશન અને એગ્રિગેશનનું ઉદાહરણ
/* Using objects as data members in a container class */
class Room
{
protected float length, width, height;
protected byte nWindows;
static int totWindows; // class variable
Room() { }; // user-defined no-argument constructor
Room (float l, float w, float h, byte n)
{
length = l; width = w; height = h;
nWindows=n; totWindows+=n;
}
Room(float l, float w)
{
length = l; width = w; height = 10;
nWindows = 1; totWindows++;
}
double area() // area-length*width
{ return(length*width); } // end area() Method
void display()
{
System.out.println ("\nLength : " + length + "\nWidth :" +width);
System.out.println ("Height : " + height);
System.out.println ("Windows :"+nWindows);
} // end display() Method
} // end Room Class
class Library
{
int nBooks, nMagazines, nNewspapers;
Room readingRoom;
Library() { };
Library(int nB, int nM, int nN, Room r)
{
nBooks = nB; nMagazines = nM; nNewspapers = nN;
readingRoom = r;
}
void display()
{
System.out.println("\nLibrary Details :\nNumber of Books :"+nBooks); System.out.println("\nNumber of subscribed magazines : " + nMagazines); System.out.println("\nNumber of subscribed newspapers :"+nNewspapers); System.out.println("Reading Room :");
readingRoom.display();
}
} // end class Library
class Container /* Application using Room, Library */
{
public static void main(String args[])
{ Room r1 = new Room(20, 15, 10, (byte)2);
r1.display();
Library lib = new Library(300, 20, 5, r1);
lib.display();
} // end main()
} // end class Container
કોડ લિસ્ટિંગ 5ના મહત્ત્વના મુદ્દા :
(1) ક્લાસ ‘Container’ની main( ) મેથડમાં :
- ક્લાસ ‘Library’નો ઑબ્જેક્ટ lib ચાર ચલ સાથે કન્સ્ટ્રક્ટર વાપરીને બનાવ્યો છે.
- ક્લાસ ‘Library’ની મેથડ display( ઑબ્જેક્ટ libનો ઉપયોગ કરીને ઇન્વોક કરેલ છે.
(2) ક્લાસ ‘Library’માં :
- ઑબ્જેક્ટ readingRoom ક્લાસ ‘Room’નો ઍટ્રિબ્યુટ છે.
- ચાર ચલ સાથેના કન્સ્ટ્રક્ટરમાં ક્લાસ ‘Room’ની છેલ્લી ચલ ‘r’નો ઉપયોગ કરે છે અને અસાઇનમેન્ટ વિધાન ‘readingRoom = r;’ વાપરીને Roomના ઍટ્રિબ્યૂટને કિંમતો અસાઇન કરે છે.
- display( ) મેથડ વ્યાખ્યાયિત કરેલ છે. readingRoom.display( );’ દ્વારા ‘Room’ ક્લાસની display( ) મેથડ ઇન્વોક કરેલ છે.
- અહીં ‘Library’ અને ‘Room’ વચ્ચે ‘is – a’ સંબંધ નથી, પણ ‘has – a’ સંબંધ છે.