OOP ਵਿੱਚ Abstraction: ਗੁੰਝਲਦਾਰਤਾ ਨੂੰ ਛੁਪਾਉਣਾ
ਤੁਸੀਂ ਕੁਝ ਸਧਾਰਨ ਕਾਰਵਾਈਆਂ ਰਾਹੀਂ ਕਾਰ ਚਲਾਉਂਦੇ ਹੋ। ਤੁਸੀਂ ਗੈਸ ਪੈਡਲ ਦਬਾਉਂਦੇ ਹੋ। ਤੁਸੀਂ ਸਟੀਅਰਿੰਗ ਘੁਮਾਉਂਦੇ ਹੋ। ਤੁਸੀਂ ਬ੍ਰੇਕ ਲਗਾਉਂਦੇ ਹੋ।
ਤੁਹਾਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਇੰਜਣ ਵਿੱਚ ਬਾਲਣ ਕਿਵੇਂ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਪਿਸਟਨ ਕਿਵੇਂ ਚਲਦੇ ਹਨ ਜਾਂ ਗੇਅਰ ਕਿਵੇਂ ਬਦਲਦੇ ਹਨ। ਕਾਰ ਉਹਨਾਂ ਵੇਰਵਿਆਂ ਨੂੰ ਤੁਹਾਡੇ ਤੋਂ ਛੁਪਾ ਕੇ ਰੱਖਦੀ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਗੁੰਝਲਦਾਰ ਮਸ਼ੀਨ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਇੰਟਰਫੇਸ (interface) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ।
ਸਾਫਟਵੇਅਰ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਇੱਕ ਈਮੇਲ ਭੇਜਣ ਬਾਰੇ ਸੋਚੋ। ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਕਮਾਂਡ ਕਾਲ ਕਰਦੇ ਹੋ: emailService.send()।
ਪਰਦੇ ਦੇ ਪਿੱਛੇ, ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਹੁੰਦੀਆਂ ਹਨ:
- ਸਿਸਟਮ ਐਡਰੈੱਸ ਦੀ ਪੁਸ਼ਟੀ (validate) ਕਰਦਾ ਹੈ।
- ਇਹ ਇੱਕ SMTP ਕਨੈਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ।
- ਇਹ ਪ੍ਰੋਵਾਈਡਰ ਨਾਲ ਪ੍ਰਮਾਣਿਕਤਾ (authenticate) ਕਰਦਾ ਹੈ।
- ਇਹ ਸੁਨੇਹਾ ਤਿਆਰ ਕਰਦਾ ਹੈ।
- ਜੇਕਰ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਅਸਫਲ ਰਹਿੰਦੀ ਹੈ, ਤਾਂ ਇਹ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ਾਂ (retries) ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।
ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਕਦਮਾਂ ਨੂੰ ਦੇਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇਸ ਗੱਲ ਦੀ ਚਿੰਤਾ ਹੁੰਦੀ ਹੈ ਕਿ ਈਮੇਲ ਚਲੀ ਜਾਵੇ।
ਜੇਕਰ ਤੁਸੀਂ abstraction ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ, ਤਾਂ ਤੁਹਾਡਾ ਕੋਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:
connect()authenticate()buildMessage()sendMessage()disconnect()
ਹਰ ਵਾਰ ਅਜਿਹਾ ਕਰਨ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। ਤੁਹਾਡੇ ਕੋਡ ਦਾ ਹਰ ਹਿੱਸਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੇ ਈਮੇਲ ਪ੍ਰੋਵਾਈਡਰ ਨੂੰ ਬਦਲਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਕੋਡ ਦੀ ਹਰ ਇੱਕ ਲਾਈਨ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ ਪਵੇਗਾ ਜੋ ਮੇਲ ਭੇਜਦੀ ਹੈ। ਤੁਹਾਡੇ ਸਿਸਟਮ ਨੂੰ ਬਦਲਣਾ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦਾ ਹੈ।
Abstraction ਇਸਦਾ ਹੱਲ ਕਰਦਾ ਹੈ। ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਆਬਜੈਕਟ (object) ਕੀ ਕਰਦਾ ਹੈ ਪਰ ਇਹ ਛੁਪਾ ਦਿੰਦਾ ਹੈ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਤੁਸੀਂ ਇੱਕ ਸਧਾਰਨ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋ। ਕਾਲਰ (caller) ਆਪਣੇ ਕੰਮ 'ਤੇ ਕੇਂਦਰਿਤ ਰਹਿੰਦਾ ਹੈ। ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ (implementation) ਛੁਪੀ ਰਹਿੰਦੀ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ decoupled ਰੱਖਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬਣਾਈ ਰੱਖਣਾ (maintain) ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।
ਲੋਕ ਅਕਸਰ Abstraction ਨੂੰ Encapsulation ਨਾਲ ਗਲਤ ਸਮਝ ਲੈਂਦੇ ਹਨ।
Encapsulation ਪੁੱਛਦਾ ਹੈ: ਇਹ ਡੇਟਾ ਕੌਣ ਬਦਲ ਸਕਦਾ ਹੈ? ਇਹ ਅੰਦਰੂਨੀ ਸਥਿਤੀ (internal state) ਦੀ ਰੱਖਿਆ ਕਰਦਾ ਹੈ। Abstraction ਪੁੱਛਦਾ ਹੈ: ਉਪਭੋਗਤਾ ਨੂੰ ਕਿਹੜੇ ਵੇਰਵੇ ਦੇਖਣ ਦੀ ਲੋੜ ਹੈ? ਇਹ ਗੁੰਝਲਦਾਰਤਾ ਨੂੰ ਛੁਪਾਉਂਦਾ ਹੈ।
ਉਹ ਬਿਹਤਰ ਸਿਸਟਮ ਬਣਾਉਣ ਲਈ ਮਿਲ ਕੇ ਕੰਮ ਕਰਦੇ ਹਨ।
ਅੱਗੇ, ਅਸੀਂ Inheritance ਬਾਰੇ ਦੇਖਾਂਗੇ। ਅਸੀਂ ਇੱਕ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਵਾਂਗੇ: ਜੇਕਰ ਆਬਜੈਕਟ ਵਿਵਹਾਰ (behavior) ਸਾਂਝਾ ਕਰਦੇ ਹਨ, ਤਾਂ ਕੀ ਤੁਹਾਨੂੰ ਇੱਕੋ ਕੋਡ ਦੋ ਵਾਰ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ?