CodeGym /جاوا بلاگ /Random-UR /جاوا میں OOP تصورات
John Squirrels
سطح
San Francisco

جاوا میں OOP تصورات

گروپ میں شائع ہوا۔
جاوا کی سب سے بڑی طاقتوں میں سے ایک آبجیکٹ اورینٹڈ پروگرامنگ (OOP) ہے۔ یہی وجہ ہے کہ یہ زبان اتنی مقبول ہوئی ہے اور کسی بھی سائز کے منصوبوں کے لیے موزوں ہے۔ آبجیکٹ پر مبنی پروگرامنگ کیا ہے؟ یہ جادو نہیں ہے، لیکن اگر آپ واقعی اس میں شامل ہو جائیں تو یہ جادوئی لگ سکتا ہے۔ OOP اس بارے میں ہے کہ آپ کا سافٹ ویئر کیسے بنایا جائے۔ یہ ایک تصور ہے، یا جاوا میں اوپ تصورات کا ایک گروپ ہے، جو آپ کو جاوا اشیاء کے درمیان کچھ مخصوص تعاملات اور تعلقات پیدا کرنے کی اجازت دیتا ہے تاکہ سافٹ ویئر کو مؤثر طریقے سے تیار اور استعمال کیا جا سکے۔ جاوا میں OOP تصورات - 1کلاسیکی OOP میں 3 + 1 اہم تصورات شامل ہیں۔ چلو کلاسیکی کے ساتھ شروع کرتے ہیں.

یہ چیز، مفعول

جاوا آبجیکٹ کے ساتھ ساتھ حقیقی دنیا کی اشیاء میں دو خصوصیات ہیں: حالت اور برتاؤ۔

مثال کے طور پر، ایک انسانی چیز کی حالت ہوتی ہے (نام، جنس، سونا یا نہیں...) اور برتاؤ (جاوا کا مطالعہ، چہل قدمی، بات چیت...)۔ کوئی بھی جاوا آبجیکٹ اپنی حالت کو کھیتوں میں محفوظ کرتا ہے اور طریقوں کے ذریعے اپنے رویے کو بے نقاب کرتا ہے۔

انکیپسولیشن

ڈیٹا انکیپسولیشن بیرونی دنیا سے اندرونی ڈیٹا کو چھپا رہی ہے، اور اس تک رسائی صرف عوامی طور پر بے نقاب طریقوں سے کر رہی ہے۔ اس کا کیا مطلب ہے؟ کیا ڈیٹا؟ کس سے چھپائے؟ چھپانے کا مطلب ہے کسی کلاس کے ڈیٹا ممبرز (فیلڈز) تک براہ راست رسائی کو محدود کرنا۔

یہ جاوا میں کیسے کام کرتا ہے:

  1. کھیتوں کو نجی بنایا جاتا ہے۔
  2. کلاس میں ہر فیلڈ کو دو خاص طریقے ملتے ہیں: ایک گیٹر اور سیٹٹر۔ گیٹر کے طریقے فیلڈ کی قدر واپس کرتے ہیں۔ سیٹر کے طریقے آپ کو فیلڈ کی قدر کو بالواسطہ لیکن جائز طریقے سے تبدیل کرنے دیتے ہیں۔

جاوا کوڈ میں encapsulation کی مثال:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this:  firstStudent.name = "John";
}
}

آپ کو encapsulation کیوں استعمال کرنا چاہئے؟

بنیادی وجہ آپ کے کوڈ کو تبدیل کرنا آسان بنانا ہے۔ تصور کریں کہ آپ کے پاس ہاکی اسکول کے لیے درخواست ہے اور ایک ہاکی اسٹوڈنٹ کلاس ہے جس میں دو فیلڈز ہیں جو اسکول میں داخل ہونے کے وقت طالب علم کا نام اور عمر محفوظ کرتی ہے۔ کچھ اس طرح:
public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}
ageOfEnrollment فیلڈ عوامی ہے، کوئی حاصل کرنے والا یا سیٹ کرنے والا نہیں… اس کلاس کو بہت سی دوسری کلاسیں استعمال کرتی ہیں، اور سب کچھ ٹھیک تھا جب تک کہ کچھ ڈویلپر نے فیصلہ نہ کیا کہ ایک int فیلڈ کافی نہیں ہے ۔ ایک گروپ میں کچھ ہاکی کھلاڑی اپنے ساتھیوں سے تقریباً ایک سال بڑے ہوتے ہیں، اس لیے ان کی پیدائش کے مہینے کے لحاظ سے انہیں دو گروپوں میں تقسیم کرنا زیادہ آسان ہوگا۔ لہذا ageOfEnrollment فیلڈ کو int array (int[][]) میں تبدیل کیا جانا چاہئے : پہلا نمبر پورے سالوں کے لئے ہے اور دوسرا مہینوں کے لئے ہے۔ اب آپ کو تمام کوڈ ری ایکٹر کرنے کی ضرورت ہے جو اسٹوڈنٹ کلاس استعمال کرتا ہے! لیکن اگر آپ کا ایج آف اینرولمنٹ فیلڈ نجی ہے اور آپ کے پاس حاصل کرنے والے اور سیٹرز ہیں، تو سب کچھ آسان ہے۔ اگر طالب علم کی عمر متعین کرنے کی ضرورت بدل جاتی ہے، تو صرف setAgeOfEnrollment() سیٹر کے طریقہ کار میں منطق کو اپ ڈیٹ کریں اور آپ کی کلاسیں بغیر کسی پریشانی کے طالب علم کا استعمال جاری رکھ سکتی ہیں ! یہ مثال کسی حد تک متضاد ہے، لیکن مجھے امید ہے کہ یہ وضاحت کرے گا کہ encapsulation کا استعمال کیوں ایک اچھا خیال ہے۔

وراثت

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

یہ جاوا میں کیسے کام کرتا ہے:

  1. پیرنٹ کلاس بنائیں۔
  2. توسیعی کلیدی لفظ کا استعمال کرتے ہوئے چائلڈ کلاس بنائیں ۔
  3. چائلڈ کلاس کے کنسٹرکٹر میں، والدین کے شعبوں کو سیٹ کرنے کے لیے سپر (parentField1، parentField2، ...) طریقہ استعمال کریں۔

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

جب بھی آپ کوئی نیا آبجیکٹ بناتے ہیں، آپ اس کے کنسٹرکٹر کو کال کرتے ہیں۔ مندرجہ بالا مثال میں، آپ اس لائن میں یہ کرتے ہیں:

Student firstStudent = new Student();

آپ اسٹوڈنٹ کلاس کے ڈیفالٹ کنسٹرکٹر کو کال کرنے کے لیے نیا کلیدی لفظ استعمال کرتے ہیں : tudent() ۔

کچھ اصول:

  1. ایک کلاس میں صرف ایک ہی والدین ہو سکتے ہیں۔
  2. والدین کی ایک کلاس میں بچوں کی کئی کلاسیں ہو سکتی ہیں۔
  3. چائلڈ کلاس کی اپنی چائلڈ کلاس ہو سکتی ہے۔

جاوا کوڈ میں وراثت کی مثال

آئیے ایک فون کلاس بنائیں۔
public class Phone {
    int price;
    double weight;

// Constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("Ordering phone...");
    }
}
بلاشبہ، فونز کی مختلف قسمیں ہیں، تو آئیے بچوں کی دو کلاسیں بنائیں: ایک اینڈرائیڈ فونز کے لیے اور دوسری آئی فونز کے لیے۔ پھر ہم کچھ فیلڈز اور طریقے شامل کریں گے جو والدین کے پاس نہیں ہیں۔ اور ہم super() استعمال کریں گے کنسٹرکٹرز کو کال کرنے کے لیے ان فیلڈز کو شروع کرنے کے لیے جو پیرنٹ کلاس کے پاس ہیں۔

جاوا میں وراثت کی مثال

public class Android extends Phone {

// Some new fields
String androidVersion;
int screenSize;

    String secretDeviceCode;

// Constructor
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super(price, weight); // Android inherits Phone’s fields

        //this - reference to the current object
        //super - reference to the parent object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

	// New Android-specific method, does not exist in the Phone class
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {

    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super(price, weight);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override // This is about polymorphism, see below
void orderPhone(){
        System.out.println("Ordering my new iPhone and deleting the old one...");
    }
}
لہذا، دہرانے کے لیے: جاوا میں، وراثت آپ کو چائلڈ کلاسز کے ساتھ ایک کلاس بڑھانے دیتی ہے جو پیرنٹ کلاس کے فیلڈز اور طریقوں کو وراثت میں دیتی ہے۔ کوڈ کو دوبارہ استعمال کرنے کے لیے یہ ایک بہترین طریقہ ہے۔

پولیمورفزم

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

اس کا کیا مطلب ہے اور یہ جاوا میں کیسے کام کرتا ہے:

جاوا میں پولیمورفزم کیا ہے؟ عام طور پر، اس کا مطلب ہے کہ آپ ایک ہی طریقہ کا نام مختلف مقاصد کے لیے استعمال کر سکتے ہیں۔ جاوا میں پولیمورفزم کی دو قسمیں ہیں: طریقہ اوور رائڈنگ (متحرک پولیمورفزم) اور طریقہ اوورلوڈنگ (جامد پولیمورفزم)۔

طریقہ اوور رائیڈنگ

آپ بچوں کی کلاس میں والدین کی کلاس کے طریقہ کار کو اوور رائیڈ کر سکتے ہیں، اسے مختلف طریقے سے کام کرنے پر مجبور کر سکتے ہیں۔ آئیے پلے() طریقہ کے ساتھ میوزک کی پیرنٹ کلاس بنائیں۔

جاوا کوڈ میں پولیمورفزم کی مثال

public class Musician {
    String name;
    int age;

    // Default constructor
    public Musician() {
    }

    // Parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}
مختلف موسیقار مختلف آلات استعمال کرتے ہیں۔ آئیے بچوں کی دو کلاسیں بنائیں: پیانوسٹ اور وائلنسٹ ۔ پولیمورفزم کی بدولت، ہر ایک play() طریقہ کے اپنے ورژن پر عمل کرے گا ۔ اوور رائیڈ کرتے وقت، آپ @Override تشریح استعمال کر سکتے ہیں، لیکن یہ ضروری نہیں ہے۔
public class Pianist extends Musician {

    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing the piano...");
    }
}
وائلن بجانے والا سولوسٹ یا آرکسٹرا کا ممبر ہوسکتا ہے۔ آئیے اپنے play() طریقہ کو زیر کرتے وقت اس کو مدنظر رکھیں۔
public class Violinist extends Musician {
    boolean isSoloist;

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist)
        System.out.println("I am playing the violin solo...");
else
System.out.println("I am playing the violin in an orchestra...");

    }
}
آئیے ایک ڈیمو کلاس بناتے ہیں، جس میں ہم تین آبجیکٹ بنائیں گے، پہلے سے بنائی گئی ہر ایک کلاس کی ایک مثال۔ ہم دیکھیں گے کہ ہمیں کیا نتائج ملتے ہیں۔
public class Demo {
  public static void main(String[] args) {
  Musician musician = new Musician();
  Violinist violinist = new Violinist("John", 32, true);
  Pianist pianist = new Pianist("Glen", 30, "Acoustic");

  System.out.println("Musician said:");
  musician.play();
  System.out.println("Violinist said:");
  violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}
ہمیں جو ملتا ہے وہ یہ ہے:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo…
Pianist said:
I am playing the piano...
ہر وائلنسٹ اور پیانوسٹ ایک موسیقار ہے، لیکن ہر موسیقار وائلنسٹ یا پیانوسٹ نہیں ہے. اس کا مطلب ہے کہ اگر آپ کو نیا بنانے کی ضرورت نہیں ہے تو آپ موسیقار کے پلے کا طریقہ استعمال کر سکتے ہیں۔ یا آپ سپر کلیدی لفظ کا استعمال کرتے ہوئے بچے سے والدین کے طریقہ کار کو کال کرسکتے ہیں ۔ آئیے اسے پیانوادک کے کوڈ میں کرتے ہیں:
public class Pianist extends Musician {

    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
}
اب ڈیمو کلاس میں اپنے main() طریقہ کو کال کریں ۔ یہاں نتیجہ ہے:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...

طریقہ اوورلوڈنگ

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

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            System.out.println("I am playing the piano...");
        }
        else System.out.println("I can't play this without electricity.");
    }
}
ویسے، آپ دوسرے پلے (بولین) طریقہ کے اندر پہلے پلے() طریقہ کو اس طرح استعمال کر سکتے ہیں:
void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            play();
        }
        else System.out.println("I can't play this without electricity.");
    }
آئیے اپنی اوور لوڈنگ کو ظاہر کرنے کے لیے اپنی ڈیمو کلاس میں کچھ سطریں شامل کریں:
public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23, true);
        Pianist pianist = new Pianist("Glen", 30, "Acoustic");

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("The pianist will now try the electric piano:");
        pianist.play(true);
        System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
        pianist.play(false);
    }
}
یہاں نتیجہ ہے:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.
جاوا جانتا ہے کہ اس کے پیرامیٹرز اور آبجیکٹ کی قسم کی بنیاد پر کون سا طریقہ استعمال کیا جانا چاہیے۔ یہ پولیمورفزم ہے۔

تجری

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

یہ جاوا میں کیسے کام کرتا ہے:

آئیے جاوا میں تجرید کی چار سطحیں بنائیں، یا OOP میں — سب سے کم (سب سے زیادہ مخصوص) سے لے کر بلند ترین (سب سے زیادہ تجریدی) تک۔
  1. تجرید کی سب سے کم سطح ایک مخصوص چیز ہے۔ یہ ایک ایسی ہستی ہے جس کی خصوصیات کا ایک مجموعہ ہے جو ایک مخصوص طبقے سے تعلق رکھتا ہے۔ اس کی مخصوص فیلڈ ویلیوز ہیں۔

  2. اشیاء بنانے کے لیے ایک ٹیمپلیٹ ایک کلاس ہے۔ یہ ایک جیسی خصوصیات اور اندرونی ساخت کے ساتھ اشیاء کے سیٹ کی تفصیل ہے۔

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

  4. ایک انٹرفیس جاوا پروگرامنگ لینگویج کی تعمیر کی ایک تعمیر ہے جس میں صرف خلاصہ عوامی طریقے اور جامد مستقل فیلڈز (حتمی جامد) ہوتے ہیں۔ دوسرے الفاظ میں، اشیاء کو پیدا کرنے کے لیے نہ تو تجریدی کلاسز اور نہ ہی انٹرفیس استعمال کیے جا سکتے ہیں۔

بی ٹی ڈبلیو، جاوا 8 یا بعد میں، انٹرفیس میں نہ صرف تجریدی طریقے اور مستقل، بلکہ پہلے سے طے شدہ اور جامد طریقے بھی ہوسکتے ہیں۔ جاوا میں، ایک انٹرفیس ایک رویے کی وضاحت کرتا ہے، جبکہ ایک تجریدی کلاس کو درجہ بندی بنانے کے لیے استعمال کیا جاتا ہے۔ ایک انٹرفیس کو متعدد کلاسوں کے ذریعہ لاگو کیا جاسکتا ہے۔

جاوا کوڈ میں انٹرفیس کی مثال

interface Human {
	public void struggle();
	public void protect();
}

interface Vulcan {
	int angleOfPointyEars;
	public void turnOffEmotions(boolean isOn);
	public void telepathy();
}
آپ ایک سے زیادہ انٹرفیس کو لاگو کرسکتے ہیں۔
The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
	public void protect() {
System.out.println("You are under my protection!);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
	public void telepathy() {
System.out.println("Connecting to your brain...");
}

}
ابتدائی طلباء کے لیے، جو جاوا میں آبجیکٹ پر مبنی پروگرامنگ کے تمام بنیادی تصورات کا احاطہ کرتا ہے۔ 4 اہم OOP اصولوں کے علاوہ، جاوا میں ایسوسی ایشن، ایگریگیشن اور کمپوزیشن بھی ہے۔ آپ انہیں "اضافی OOP اصول" کہہ سکتے ہیں۔ وہ اپنے الگ مضمون کے مستحق ہیں۔
تبصرے
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION