OOP માં એબ્સ્ટ્રેક્શન: જટિલતા છુપાવવી
તમે થોડી સરળ ક્રિયાઓ દ્વારા કાર ચલાવો છો. તમે એક્સિલરેટર દબાવો છો. તમે સ્ટીયરિંગ ફેરવો છો. તમે બ્રેક મારો છો.
તમારે એ જાણવાની જરૂર નથી કે એન્જિનમાં બળતણ કેવી રીતે પ્રવેશે છે. તમારે પિસ્ટન કેવી રીતે કાર્ય કરે છે અથવા ગિયર કેવી રીતે બદલાય છે તે સમજવાની જરૂર નથી. કાર તે વિગતો તમારાથી છુપાવે છે. તમે એક જટિલ મશીનને નિયંત્રિત કરવા માટે એક સરળ ઇન્ટરફેસ (interface) નો ઉપયોગ કરો છો.
સોફ્ટવેર પણ આ જ રીતે કામ કરે છે.
ઈમેલ મોકલવા વિશે વિચારો. તમે ફક્ત એક કમાન્ડ કોલ કરો છો: emailService.send().
પડદા પાછળ, ઘણી બધી વસ્તુઓ થાય છે:
- સિસ્ટમ એડ્રેસને વેલિડેટ (validate) કરે છે.
- તે SMTP કનેક્શન બનાવે છે.
- તે પ્રોવાઈડર સાથે ઓથેન્ટિકેશન (authenticate) કરે છે.
- તે મેસેજ તૈયાર કરે છે.
- જો પહેલો પ્રયાસ નિષ્ફળ જાય, તો તે ફરીથી પ્રયાસ (retries) કરે છે.
તમારે આ સ્ટેપ્સ જોવાની જરૂર નથી. તમારે ફક્ત એટલી જ ચિંતા હોય છે કે ઈમેલ મોકલાયો જોઈએ.
જો તમે એબ્સ્ટ્રેક્શનનો ઉપયોગ ન કર્યો હોત, તો તમારો કોડ આવો દેખાત:
connect()authenticate()buildMessage()sendMessage()disconnect()
દર વખતે આ કરવું સમસ્યાઓ ઊભી કરે છે. તમારા કોડનો દરેક ભાગ બહુ બધી વિગતો જાણે છે. જો તમે તમારા ઈમેલ પ્રોવાઈડર બદલો છો, તો તમારે મેઈલ મોકલતી કોડની દરેક લાઇન અપડેટ કરવી પડશે. તમારું સિસ્ટમ બદલવું મુશ્કેલ બની જાય છે.
એબ્સ્ટ્રેક્શન આ સમસ્યાનું સમાધાન કરે છે. તે ઓબ્જેક્ટ શું કરે છે તે બતાવે છે પરંતુ તે કેવી રીતે કામ કરે છે તે છુપાવે છે.
તમે એક સરળ ઇન્ટરફેસ પ્રદાન કરો છો. કોલ કરનાર વ્યક્તિ (caller) કાર્ય પર ધ્યાન કેન્દ્રિત રાખી શકે છે. તેની અમલીકરણ (implementation) વિગતો છુપાયેલી રહે છે. આ તમારા કોડને ડિકપલ્ડ (decoupled) અને જાળવવામાં સરળ રાખે છે.
લોકો અવારનવાર એબ્સ્ટ્રેક્શનને એન્કેપ્સ્યુલેશન (Encapsulation) સાથે ભૂલ કરી નાખે છે.
એન્કેપ્સ્યુલેશન પૂછે છે: આ ડેટા કોણ બદલી શકે છે? તે આંતરિક સ્ટેટ (internal state) નું રક્ષણ કરે છે. એબ્સ્ટ્રેક્શન પૂછે છે: વપરાશકર્તાએ કઈ વિગતો જોવાની જરૂર છે? તે જટિલતા છુપાવે છે.
તેઓ વધુ સારા સિસ્ટમ બનાવવા માટે સાથે મળીને કામ કરે છે.
હવે, આપણે ઇનહેરિટન્સ (Inheritance) વિશે જોઈશું. આપણે એક પ્રશ્નનો જવાબ આપીશું: જો ઓબ્જેક્ટ્સ વર્તણૂક (behavior) શેર કરતા હોય, તો શું તમારે એક જ કોડ બે વાર લખવાની જરૂર છે?