OOP کے اصول

جاوا ایک آبجیکٹ پر مبنی زبان ہے۔ اس کا مطلب ہے کہ آپ کو آبجیکٹ اورینٹڈ پیراڈیم کا استعمال کرتے ہوئے جاوا پروگرام لکھنے کی ضرورت ہے۔ اور یہ تمثیل آپ کے پروگراموں میں اشیاء اور کلاسوں کا استعمال کرتی ہے۔ آئیے یہ سمجھنے کے لیے مثالیں استعمال کرنے کی کوشش کریں کہ کلاسز اور اشیاء کیا ہیں، اور عملی طور پر OOP کے بنیادی اصولوں (تجزیہ، وراثت، پولیمورفزم اور انکیپسولیشن) کو کیسے لاگو کیا جائے۔

ایک اعتراض کیا ہے؟

ہم جس دنیا میں رہتے ہیں وہ اشیاء سے بنی ہے۔ ارد گرد نظر دوڑائیں، ہم دیکھ سکتے ہیں کہ ہم گھروں، درختوں، کاروں، فرنیچر، برتنوں اور کمپیوٹرز سے گھرے ہوئے ہیں۔ یہ تمام چیزیں اشیاء ہیں، اور ان میں سے ہر ایک کی مخصوص خصوصیات، طرز عمل اور مقاصد ہیں۔ ہم اشیاء کے عادی ہیں، اور ہم انہیں ہمیشہ خاص مقاصد کے لیے استعمال کرتے ہیں۔ مثال کے طور پر، اگر ہمیں کام پر جانے کی ضرورت ہے، تو ہم کار استعمال کرتے ہیں۔ اگر ہم کھانا چاہتے ہیں تو ہم برتن استعمال کرتے ہیں۔ اور اگر ہم آرام کرنا چاہتے ہیں تو ہمیں ایک آرام دہ صوفہ ملتا ہے۔ انسان روزمرہ کی زندگی میں مسائل کو حل کرنے کے لیے اشیاء کے حوالے سے سوچنے کے عادی ہیں۔ یہ ایک وجہ ہے کہ پروگرامنگ میں اشیاء کا استعمال کیا جاتا ہے۔ اس نقطہ نظر کو آبجیکٹ اورینٹڈ پروگرامنگ کہا جاتا ہے۔ آئیے ایک مثال دیتے ہیں۔ تصور کریں کہ آپ نے ایک نیا فون تیار کیا ہے اور بڑے پیمانے پر پیداوار شروع کرنا چاہتے ہیں۔ فون کے ڈویلپر کے طور پر، آپ جانتے ہیں کہ یہ کس کے لیے ہے، یہ کیسے کام کرتا ہے، اور اس کے حصے کیا ہیں (باڈی، مائیکروفون، اسپیکر، تاریں، بٹن وغیرہ)۔ مزید کیا ہے، صرف آپ جانتے ہیں کہ ان حصوں کو کیسے جوڑنا ہے۔ لیکن آپ ذاتی طور پر فون بنانے کا ارادہ نہیں رکھتے ہیں - آپ کے پاس ایسا کرنے کے لیے کارکنوں کی پوری ٹیم ہے۔ فون کے پرزہ جات کو جوڑنے کا طریقہ بار بار بتانے کی ضرورت کو ختم کرنے کے لیے، اور اس بات کو یقینی بنانے کے لیے کہ تمام فونز ایک ہی طریقے سے بنائے گئے ہیں، اس سے پہلے کہ آپ ان کی تیاری شروع کریں، آپ کو ایک ڈرائنگ بنانے کی ضرورت ہے جس میں بتایا گیا ہو کہ فون کو کس طرح منظم کیا جاتا ہے۔ OOP میں، ہم ایسی تفصیل، ڈرائنگ، خاکہ یا ٹیمپلیٹ کو کلاس کہتے ہیں۔ جب پروگرام چل رہا ہو تو یہ اشیاء بنانے کی بنیاد بناتا ہے۔ کلاس مخصوص قسم کی اشیاء کی تفصیل ہوتی ہے — جیسے ایک عام ٹیمپلیٹ جس میں فیلڈز، طریقے اور کنسٹرکٹر ہوتے ہیں۔ ایک شے کلاس کی ایک مثال ہے۔ یہ کلاس میں پائی جانے والی تفصیل کی بنیاد پر بنایا گیا ہے۔

تجری

آئیے اب سوچتے ہیں کہ ہم حقیقی دنیا میں کسی شے سے کسی پروگرام میں کسی شے کی طرف کیسے جا سکتے ہیں۔ ہم فون کو بطور مثال استعمال کریں گے۔ مواصلات کے اس ذرائع کی ایک تاریخ ہے جو 100 سال سے زیادہ پر محیط ہے۔ جدید ٹیلی فون اپنے 19ویں صدی کے پیشرو سے کہیں زیادہ پیچیدہ ڈیوائس ہے۔ فون استعمال کرتے وقت، ہم اس کی تنظیم اور اس کے اندر ہونے والے عمل کے بارے میں نہیں سوچتے۔ ہم فون کے ڈویلپرز کے فراہم کردہ فنکشنز کا استعمال کرتے ہیں: فون نمبر درج کرنے اور کال کرنے کے لیے بٹن یا ٹچ اسکرین۔ پہلے فون انٹرفیس میں سے ایک کرینک تھا جسے کال کرنے کے لیے گھمانے کی ضرورت تھی۔ یقینا، یہ بہت آسان نہیں تھا. لیکن اس نے اپنا کام بے عیب طریقے سے پورا کیا۔ اگر آپ جدید ترین اور پہلے فونز کا موازنہ کرتے ہیں، تو آپ فوری طور پر 19ویں صدی کے آخر کے آلے اور جدید سمارٹ فون کے لیے سب سے اہم افعال کی شناخت کر سکتے ہیں۔ وہ کال کرنے کی صلاحیت اور کال وصول کرنے کی صلاحیت ہیں۔ درحقیقت، یہی چیز فون کو فون بناتی ہے، نہ کہ کچھ اور۔ اب صرف OOP کا ایک اصول لاگو کیا ہے: کسی چیز کی سب سے اہم خصوصیات اور معلومات کی شناخت کریں۔ اس اصول کو تجرید کہتے ہیں۔ OOP میں، تجرید کو ایک پروگرام میں اشیاء کے طور پر حقیقی دنیا کے کام کے عناصر کی نمائندگی کرنے کے ایک طریقہ کے طور پر بھی بیان کیا جا سکتا ہے۔ تجرید کا تعلق ہمیشہ کسی شے کی مخصوص خصوصیات کے عام ہونے سے ہوتا ہے، اس لیے اہم بات یہ ہے کہ ہاتھ میں موجود کام کے تناظر میں بامعنی معلومات کو غیر اہم سے الگ کیا جائے۔ مزید برآں، تجرید کی کئی سطحیں ہو سکتی ہیں۔ آئیے اپنے فون پر تجرید کے اصول کو لاگو کرنے کی کوشش کریں۔ شروع کرنے کے لیے، ہم سب سے عام قسم کے فونز کی شناخت کریں گے — پہلے فون سے لے کر موجودہ دور کے فونز تک۔ مثال کے طور پر، ہم شکل 1 میں خاکہ کی شکل میں ان کی نمائندگی کر سکتے ہیں۔ تجرید کا استعمال کرتے ہوئے، اب ہم اس آبجیکٹ کے درجہ بندی میں عمومی معلومات کی شناخت کر سکتے ہیں: عمومی خلاصہ آبجیکٹ (ٹیلیفون)، ٹیلی فون کی عام خصوصیات (مثلاً اس کا سال۔ تخلیق)، اور مشترکہ انٹرفیس (تمام ٹیلی فون وصول اور کال کر سکتے ہیں)۔ یہ جاوا میں کیسا لگتا ہے یہ ہے:

public abstract class AbstractPhone {
    private int year;

    public AbstractPhone(int year) {
        this.year = year;
    }
    public abstract void call(int outgoingNumber);
    public abstract void ring(int incomingNumber);
}

ایک پروگرام میں، ہم اس تجریدی کلاس کا استعمال کرتے ہوئے اور OOP کے دیگر بنیادی اصولوں کو لاگو کرتے ہوئے فون کی نئی قسمیں بنا سکتے ہیں، جنہیں ہم ذیل میں دریافت کریں گے۔

انکیپسولیشن

تجرید کے ساتھ، ہم شناخت کرتے ہیں کہ تمام اشیاء کے لیے کیا مشترک ہے۔ لیکن ہر قسم کا فون منفرد ہوتا ہے، کسی نہ کسی طرح دوسروں سے مختلف ہوتا ہے۔ ایک پروگرام میں، ہم کس طرح حدیں کھینچتے ہیں اور اس انفرادیت کو کیسے پہچانتے ہیں؟ ہم اسے کیسے بناتے ہیں تاکہ کوئی بھی غلطی سے یا جان بوجھ کر ہمارے فون کو نہ توڑ سکے یا ایک ماڈل کو دوسرے میں تبدیل کرنے کی کوشش نہ کر سکے۔ حقیقی دنیا میں، جواب واضح ہے: آپ کو تمام حصوں کو فون کیس میں ڈالنے کی ضرورت ہے۔ بہر حال، اگر آپ ایسا نہیں کرتے ہیں — بجائے اس کے کہ فون کے تمام اندرونی حصوں کو چھوڑ دیں اور تاروں کو باہر سے جوڑیں — کچھ متجسس تجربہ کار یقیناً ہمارے فون کو "بہتر" کرنا چاہیں گے۔ اس طرح کی ٹنکرنگ کو روکنے کے لیے، کسی چیز کے ڈیزائن اور آپریشن میں encapsulation کا اصول استعمال کیا جاتا ہے۔ یہ اصول بتاتا ہے کہ کسی شے کے اوصاف اور رویے کو ایک کلاس میں ملایا جاتا ہے، آبجیکٹ کا اندرونی نفاذ صارف سے پوشیدہ ہوتا ہے، اور آبجیکٹ کے ساتھ کام کرنے کے لیے ایک عوامی انٹرفیس فراہم کیا جاتا ہے۔ پروگرامر کا کام یہ طے کرنا ہے کہ کسی چیز کی کون سی خصوصیات اور طریقے عوامی رسائی کے لیے دستیاب ہونے چاہئیں، اور کون سے داخلی نفاذ کی تفصیلات ہیں جو ناقابل رسائی ہونی چاہئیں۔

انکیپسولیشن اور رسائی کنٹرول

فرض کریں کہ فون کے بارے میں معلومات (اس کی پیداوار کا سال یا مینوفیکچرر کا لوگو) جب اسے بنایا جاتا ہے تو اس کی پشت پر کندہ ہوتا ہے۔ معلومات (اس کی حالت) اس مخصوص ماڈل کے لیے مخصوص ہے۔ ہم کہہ سکتے ہیں کہ مینوفیکچرر نے اس بات کو یقینی بنایا کہ یہ معلومات ناقابل تغیر ہے - اس بات کا امکان نہیں ہے کہ کوئی بھی کندہ کاری کو ہٹانے کے بارے میں سوچے گا۔ جاوا کی دنیا میں، ایک کلاس فیلڈز کا استعمال کرتے ہوئے مستقبل کی اشیاء کی حالت بیان کرتی ہے، اور طریقوں کا استعمال کرتے ہوئے ان کے رویے کو بیان کیا جاتا ہے۔ کسی چیز کی حالت اور رویے تک رسائی کو فیلڈز اور طریقوں پر لاگو ترمیم کاروں کے ذریعے کنٹرول کیا جاتا ہے: نجی، محفوظ، عوامی اور ڈیفالٹ۔ مثال کے طور پر، ہم نے فیصلہ کیا ہے کہ پیداوار کا سال، کارخانہ دار کا نام، اور طریقوں میں سے ایک کلاس کی داخلی نفاذ کی تفصیلات ہیں اور پروگرام میں موجود دیگر اشیاء کے ذریعے اسے تبدیل نہیں کیا جا سکتا۔ کوڈ میں، کلاس کو اس طرح بیان کیا جا سکتا ہے:

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    // findSwitch
    // openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("Calling");
}

public void ring() {
    System.out.println("Ring-ring");
}

 }

پرائیویٹ موڈیفائر کلاس کے فیلڈز اور طریقوں کو صرف اس کلاس کے اندر ہی رسائی کی اجازت دیتا ہے۔ اس کا مطلب یہ ہے کہ باہر سے نجی شعبوں تک رسائی ناممکن ہے، کیونکہ نجی طریقوں کو نہیں کہا جا سکتا۔ اوپن کنکشن کے طریقہ کار تک رسائی کو محدود کرنے سے ہمیں طریقہ کار کے داخلی عمل کو آزادانہ طور پر تبدیل کرنے کی صلاحیت بھی حاصل ہو جاتی ہے، کیونکہ اس طریقہ کی ضمانت دی جاتی ہے کہ وہ دیگر اشیاء کے کام میں رکاوٹ نہیں ڈالے گا۔ اپنے اعتراض کے ساتھ کام کرنے کے لیے، ہم عوامی ترمیم کار کا استعمال کرتے ہوئے دستیاب کال اور رِنگ کے طریقے چھوڑ دیتے ہیں۔ اشیاء کے ساتھ کام کرنے کے لیے عوامی طریقے فراہم کرنا بھی encapsulation کا حصہ ہے، کیونکہ اگر رسائی کو مکمل طور پر مسترد کر دیا گیا تو یہ بیکار ہو جائے گا۔

وراثت

آئیے فونز کے خاکے پر ایک اور نظر ڈالتے ہیں۔ آپ دیکھ سکتے ہیں کہ یہ ایک درجہ بندی ہے جس میں ایک ماڈل میں ماڈلز کی تمام خصوصیات ہوتی ہیں جو اس کی برانچ کے ساتھ اونچی جگہ پر واقع ہوتی ہیں، اور اس میں سے کچھ خود بھی شامل کرتی ہے۔ مثال کے طور پر، ایک سمارٹ فون مواصلت کے لیے سیلولر نیٹ ورک کا استعمال کرتا ہے (اس میں سیل فون کی خصوصیات ہیں)، وائرلیس اور پورٹیبل ہے (اس میں کورڈ لیس فون کی خصوصیات ہیں)، اور کالز وصول اور کر سکتے ہیں (اس میں فون کی خصوصیات ہیں)۔ ہمارے یہاں جو چیز ہے وہ آبجیکٹ کی خصوصیات کی وراثت ہے۔ پروگرامنگ میں، وراثت کا مطلب ہے کہ نئی کلاسوں کی وضاحت کے لیے موجودہ کلاسوں کا استعمال کرنا۔ آئیے اسمارٹ فون کی کلاس بنانے کے لیے وراثت کے استعمال کی ایک مثال پر غور کریں۔ تمام کورڈ لیس فون ریچارج ایبل بیٹریوں سے چلتے ہیں، جن کی بیٹری کی ایک خاص زندگی ہوتی ہے۔ اس کے مطابق، ہم اس پراپرٹی کو کورڈ لیس فون کلاس میں شامل کرتے ہیں:

public abstract class CordlessPhone extends AbstractPhone {

    private int hour;

    public CordlessPhone (int year, int hour) {
        super(year);
        this.hour = hour;
    }
    }

سیل فونز کو کورڈ لیس فون کی خصوصیات وراثت میں ملتی ہیں، اور ہم اس کلاس میں کال اور رِنگ کے طریقے نافذ کرتے ہیں:

public class CellPhone extends CordlessPhone {
    public CellPhone(int year, int hour) {
        super(year, hour);
    }

    @Override
    public void call(int outgoingNumber) {
        System.out.println("Calling " + outgoingNumber);
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming call from " + incomingNumber);
    }
}

اور آخر میں، ہمارے پاس اسمارٹ فون کی کلاس ہے، جو کلاسک سیل فونز کے برعکس، ایک مکمل آپریٹنگ سسٹم رکھتا ہے۔ آپ نئے پروگراموں کو شامل کرکے اپنے اسمارٹ فون کی فعالیت کو بڑھا سکتے ہیں جو اس کے آپریٹنگ سسٹم پر چل سکتے ہیں۔ کوڈ میں، کلاس کو اس طرح بیان کیا جا سکتا ہے:

public class Smartphone extends CellPhone {
    
    private String operationSystem;

    public Smartphone(int year, int hour, String operationSystem) {
        super(year, hour);
        this.operationSystem = operationSystem;
    }
public void install(String program) {
    System.out.println("Installing " + program + " for " + operationSystem);
}

}

جیسا کہ آپ دیکھ سکتے ہیں، ہم نے اسمارٹ فون کلاس کو بیان کرنے کے لیے کافی حد تک نیا کوڈ بنایا ، لیکن ہمیں نئی ​​فعالیت کے ساتھ ایک نئی کلاس ملی۔ OOP کا یہ اصول مطلوبہ جاوا کوڈ کی مقدار کو نمایاں طور پر کم کرنا ممکن بناتا ہے، اس طرح پروگرامر کے لیے زندگی آسان ہو جاتی ہے۔

پولیمورفزم

مختلف قسم کے فونز کی ظاہری شکل اور ڈیزائن میں فرق کے باوجود، ہم کچھ عام رویے کی نشاندہی کر سکتے ہیں: وہ سبھی کالز وصول کر سکتے ہیں اور کر سکتے ہیں اور سبھی کے پاس کنٹرول کا کافی واضح اور آسان سیٹ ہے۔ پروگرامنگ کے لحاظ سے، تجرید کا اصول (جس سے ہم پہلے ہی واقف ہیں) ہمیں یہ کہنے دیتا ہے کہ فون کی اشیاء کا ایک مشترکہ انٹرفیس ہوتا ہے۔ یہی وجہ ہے کہ لوگ آسانی سے فون کے مختلف ماڈلز کا استعمال کر سکتے ہیں جن میں ایک جیسے کنٹرول ہوتے ہیں (مکینیکل بٹن یا ٹچ اسکرین)، ڈیوائس کی تکنیکی تفصیلات میں جانے کے بغیر۔ اس طرح، آپ مسلسل سیل فون استعمال کرتے ہیں اور آپ آسانی سے اپنے دوست کی لینڈ لائن سے کال کر سکتے ہیں۔ OOP کا اصول جو کہتا ہے کہ ایک پروگرام ایک مشترکہ انٹرفیس کے ساتھ آبجیکٹ کی اندرونی ساخت کے بارے میں کسی معلومات کے بغیر استعمال کر سکتا ہے اسے پولیمورفزم کہتے ہیں۔ آئیے تصور کریں کہ ہمیں ایک ایسے صارف کی وضاحت کرنے کے لیے اپنے پروگرام کی ضرورت ہے جو کسی دوسرے صارف کو کال کرنے کے لیے کوئی بھی فون استعمال کر سکے۔ یہاں ہم اسے کیسے کر سکتے ہیں:

public class User {
    private String name;

    public User(String name) {
        this.name = name;
            }

    public void callAnotherUser(int number, AbstractPhone phone){
// And here's polymorphism: using the AbstractPhone type in the code!
        phone.call(number);
    }
}
 }

اب ہم فون کی کئی اقسام بیان کریں گے۔ پہلے فونز میں سے ایک:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Crank the handle");
        System.out.println("What number would you like to connect to?");
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

ایک عام لینڈ لائن فون:

public class Phone extends AbstractPhone {

    public Phone(int year) {
        super(year);
    }

    @Override
    public void call(int outgoingNumber) {
        System.out.println("Calling " + outgoingNumber);
    }

    @Override
    public void ring(int incomingNumber) {
        System.out.println("The phone is ringing");
    }
}

اور آخر میں، ایک ٹھنڈا ویڈیو فون:

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outgoingNumber) {
        System.out.println("Connecting video call to " + outgoingNumber);
    }
    @Override
    public void ring(int incomingNumber) {
        System.out.println("Incoming video call from " + incomingNumber);
    }
  }

ہم main() طریقہ میں اشیاء بنائیں گے اور callAnotherUser() طریقہ کی جانچ کریں گے:

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Jason");
user.callAnotherUser(224466, firstPhone);
// Crank the handle
// What number would you like to connect to?
user.callAnotherUser(224466, phone);
// Calling 224466
user.callAnotherUser(224466, videoPhone);
// Connecting video call to 224466

صارف آبجیکٹ پر ایک ہی طریقہ کو کال کرنے سے مختلف نتائج برآمد ہوتے ہیں۔ کال کے طریقہ کار کے ایک مخصوص نفاذ کو متحرک طور پر callAnotherUser() طریقہ کے اندر منتخب کیا جاتا ہے جس کی بنیاد پر پروگرام کے چلنے کے وقت پاس کردہ مخصوص قسم کی چیز کی بنیاد پر کیا جاتا ہے۔ یہ پولیمورفزم کا بنیادی فائدہ ہے - رن ٹائم پر عمل درآمد کا انتخاب کرنے کی صلاحیت۔ اوپر دی گئی فون کلاسز کی مثالوں میں، ہم نے میتھڈ اوور رائیڈنگ کا استعمال کیا - ایک ایسی چال جہاں ہم میتھڈ دستخط کو تبدیل کیے بغیر بیس کلاس میں بیان کردہ طریقہ کے نفاذ کو تبدیل کرتے ہیں۔ یہ بنیادی طور پر طریقہ کی جگہ لے لیتا ہے: ذیلی طبقے میں بیان کردہ نیا طریقہ اس وقت کہلاتا ہے جب پروگرام کو عمل میں لایا جاتا ہے۔ عام طور پر، جب ہم کسی طریقہ کو اوور رائیڈ کرتے ہیں، تو @Override تشریح استعمال کی جاتی ہے۔ یہ مرتب کرنے والے سے کہتا ہے کہ اوور رائیڈ اور اوور رائیڈنگ طریقوں کے دستخط چیک کرے۔ آخر میں، یہ یقینی بنانے کے لیے کہ آپ کے جاوا پروگرام OOP کے اصولوں کے مطابق ہیں، ان تجاویز پر عمل کریں:

• کسی چیز کی اہم خصوصیات کی نشاندہی کرنا؛
• عام خصوصیات اور رویے کی شناخت کریں اور کلاسز بناتے وقت وراثت کا استعمال کریں؛
• اشیاء کو بیان کرنے کے لیے تجریدی اقسام کا استعمال کریں؛
• کلاس کے اندرونی نفاذ سے متعلق طریقوں اور فیلڈز کو ہمیشہ چھپانے کی کوشش کریں۔