OOP માં abstraction શું છે?

Question

IT Interview Practice · Accepted Answer

**Abstraction** એટલે એક object શું કરે છે તે *દર્શાવવું* જ્યારે તે તે કેવી રીતે કરે છે તે *છુપાવવું*. તમે એક સરળ, સ્થિર ઇન્ટરફેસ સાથે ક્રિયાપ્રતિક્રિયા કરો છો અને તેની પાછળના જટિલ અમલીકરણને અવગણો છો.

## શું વિરુદ્ધ કેવી રીતે

```python
from abc import ABC, abstractmethod

class PaymentGateway(ABC):          # the abstraction: "what"
    @abstractmethod
    def charge(self, amount): ...    # callers only need this contract

class StripeGateway(PaymentGateway): # one "how"
    def charge(self, amount):
        # talk to Stripe's API, handle tokens, retries...
        return f"charged {amount} via Stripe"

class PayPalGateway(PaymentGateway): # another "how"
    def charge(self, amount):
        return f"charged {amount} via PayPal"

def checkout(gateway: PaymentGateway, amount):
    return gateway.charge(amount)    # depends only on the abstraction
```

`checkout` ક્યારેય જાણતું નથી કે તે Stripe છે કે PayPal — તે ચાર્જ કરવાના *વિચાર* પર આધાર રાખે છે, વિગતો પર નહીં.

## Abstraction વિરુદ્ધ encapsulation

તેઓ સંબંધિત પણ અલગ છે: **encapsulation** તેને સુરક્ષિત કરવા માટે સ્થિતિ છુપાવે છે; **abstraction** ઇન્ટરફેસને સરળ બનાવવા માટે જટિલતા છુપાવે છે. Encapsulation *સુરક્ષા* વિશે છે; abstraction *શું બતાવવું તે* વિશે છે.

## ખતરો

Leaky abstractions (જ્યાં અમલીકરણની વિગતો બહાર આવે છે) અને અકાળે abstractions (તમે સમસ્યા સમજો તે પહેલાં બનાવવામાં આવ્યા હતા) બંને નુકસાન પહોંચાડે છે. જે સાચવી બદલાય તે abstractions બનાવો.

## તે શા માટે મહત્વપૂર્ણ છે

Abstraction એ જટિલતાને નિયંત્રણમાં લેવાનો માર્ગ છે: કૉલરો સમગ્ર સબસિસ્ટમ ને બદલે એક નાના ઇન્ટરફેસ વિશે વિચાર કરે છે.

તે અમલીકરણો સ્વિચ કરવાનું સક્ષમ કરે છે — નવો ચુકવણી પ્રદાતા ઉમેરવો એક વર્ગને સ્પર્શ કરે છે, દરેક કૉલરને નહીં — જે લવચક, પરીક્ષણીય ડિઝાઇનનો આધાર છે.

શું વિરુદ્ધ કેવી રીતે

Abstraction વિરુદ્ધ encapsulation

ખતરો

તે શા માટે મહત્વપૂર્ણ છે

સંબંધિત પ્રશ્નો