OOP માં Abstraction: જટિલતાને છુપાવવી
તમે પેડલ દબાવીને અને વ્હીલ ફેરવીને કાર ચલાવો છો. તમારે ફ્યુઅલ ઇન્જેક્શન અથવા પિસ્ટન મૂવમેન્ટ સમજવાની જરૂર નથી. કાર આ વિગતો તમારાથી છુપાવે છે. તમે ફક્ત એક સરળ ઇન્ટરફેસનો ઉપયોગ કરો છો.
સોફ્ટવેર પણ આ જ રીતે કામ કરે છે.
ઈમેલ મોકલવા વિશે વિચારો. તમારો કોડ કદાચ આવો દેખાતો હશે:
emailService.send(email);
તે સરળ લાગે છે. પડદા પાછળ, સિસ્ટમ ઘણા કાર્યો કરે છે:
- એડ્રેસ વેલિડેટ કરે છે.
- SMTP સર્વર સાથે કનેક્ટ થાય છે.
- યુઝરને ઓથેન્ટિકેટ કરે છે.
- મેસેજ બનાવે છે.
- રિટ્રાય હેન્ડલ કરે છે.
- એરર લોગ કરે છે.
તમારે આ સ્ટેપ્સ જોવાની જરૂર નથી. તમારે ફક્ત એટલી જ ચિંતા હોય છે કે ઈમેલ મોકલાય.
જો તમે દરેક સ્ટેપને ખુલ્લું મૂકો છો, તો તમે સમસ્યાઓ ઊભી કરો છો. કલ્પના કરો કે જો દરેક ડેવલપરે મેન્યુઅલી આ કોલ કરવા પડે:
connect()authenticate()buildMessage()sendMessage()disconnect()
આ તમારા કોડને નાજુક (fragile) બનાવે છે. જો તમે તમારા ઈમેલ પ્રોવાઈડરને બદલો છો, તો તમારે તમારા એપમાં દરેક જગ્યાએ અપડેટ કરવું પડશે. તમારો કોડ ઇમ્પ્લીમેન્ટેશન સાથે ટાઈટલી કપલ્ડ (tightly coupled) બની જાય છે.
Abstraction આ સમસ્યાનું સમાધાન કરે છે.
Abstraction એ દર્શાવે છે કે ઓબ્જેક્ટ શું કરે છે. તે તે કેવી રીતે કરે છે તે છુપાવે છે. તમે યુઝરને ફક્ત તે જ બતાવો છો જે તેમને જરૂરી છે.
યુઝર એક સ્થિર (stable) ઇન્ટરફેસ સાથે ઇન્ટરેક્ટ કરે છે. તેમને તમારા ઓથેન્ટિકેશન લોજિક અથવા તમારી રિટ્રાય સ્ટ્રેટેજી વિશે કોઈ ચિંતા નથી હોતી. તે વિગતો છુપાયેલી રહે છે.
ઘણા લોકો Abstraction અને Encapsulation વચ્ચે મૂંઝવણ અનુભવે છે. અહીં તફાવત છે:
Encapsulation પૂછે છે: આ ઓબ્જેક્ટની સ્ટેટ કોણ બદલી શકે છે? તે ડેટાનું રક્ષણ કરે છે.
Abstraction પૂછે છે: યુઝરે કઈ વિગતો જોવી જોઈએ? તે જટિલતાને છુપાવે છે.
તેઓ વધુ સારા સિસ્ટમ બનાવવા માટે સાથે મળીને કામ કરે છે.
હવે પછી, આપણે Inheritance વિશે ચર્ચા કરીશું. એક જ કોડ બે વાર લખ્યા વગર શેર કરેલ બિહેવિયર (shared behavior) ને કેવી રીતે હેન્ડલ કરવું તે આપણે જોઈશું.