CodeGym /جاوا بلاگ /Random-SD /جاوا ۾ OOP تصورات
John Squirrels
سطح
San Francisco

جاوا ۾ OOP تصورات

گروپ ۾ شايع ٿيل
جاوا جي سڀ کان وڏي طاقتن مان هڪ آهي اعتراض تي مبني پروگرامنگ (OOP). اهو ئي سبب آهي جو هي ٻولي تمام مقبول ٿي چڪي آهي ۽ ڪنهن به سائيز جي منصوبن لاء مناسب آهي. اعتراض تي مبني پروگرامنگ ڇا آهي؟ اهو جادو نه آهي، پر اهو جادو لڳي سگهي ٿو جيڪڏهن توهان واقعي ان ۾ حاصل ڪيو. OOP توهان جي سافٽ ويئر کي ڪيئن ٺاهيو آهي. اهو هڪ تصور آهي، يا بلڪه جاوا ۾ اوپ تصورن جو هڪ گروپ، جيڪو توهان کي جاوا شين جي وچ ۾ ڪجهه مخصوص رابطي ۽ رشتي پيدا ڪرڻ جي اجازت ڏئي ٿو ته جيئن سافٽ ويئر کي مؤثر طريقي سان ترقي ۽ استعمال ڪري سگهجي. جاوا ۾ OOP تصورات - 1ڪلاسيڪل OOP ۾ 3 + 1 مکيه تصور شامل آهن. اچو ته Classics سان شروع ڪريون.

اعتراض

جاوا شيون ۽ حقيقي دنيا جون شيون ٻه خاصيتون آهن: رياست ۽ رويي.

مثال طور، هڪ انساني شئي آهي رياست (نالو، جنس، سمهڻ يا نه...) ۽ رويي (مطالعو جاوا، هلڻ، ڳالهائڻ...). ڪو به جاوا اعتراض پنهنجي رياست کي فيلڊ ۾ محفوظ ڪري ٿو ۽ طريقن جي ذريعي ان جي رويي کي ظاهر ڪري ٿو.

انڪپسوليشن

ڊيٽا انڪپسوليشن اندروني ڊيٽا کي ٻاهرين دنيا کان لڪائي رهيو آهي، ۽ ان تائين رسائي صرف عوامي طور تي ظاهر ڪيل طريقن سان. هن جو مطلب ڇا آهي؟ ڪهڙي ڊيٽا؟ ڪنهن کان لڪائي؟ لڪائڻ جو مطلب ڪلاس جي ڊيٽا ميمبرن (فيلڊز) تائين سڌي رسائي کي محدود ڪرڻ.

جاوا ۾ اهو ڪيئن ڪم ڪري ٿو:

  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) وراثت جي تصور لاءِ مقصد ٿي سگهي ٿو. وراثت توهان کي هڪ ٻار ڪلاس ٺاهڻ جي اجازت ڏئي ٿي جيڪا والدين طبقي جي شعبن ۽ طريقن کي ورثي ۾ ڏئي ٿو بغير انهن کي ٻيهر بيان ڪرڻ جي. يقينا، توهان ٻار جي طبقي ۾ والدين طبقي جي شعبن ۽ طريقن کي ختم ڪري سگهو ٿا، پر اهو ضروري ناهي. وڌيڪ ڇا آهي، توهان ٻار جي طبقي ۾ نئين رياستن ۽ رويي کي شامل ڪري سگهو ٿا. والدين طبقن کي ڪڏهن ڪڏهن سپر ڪلاس يا بنيادي ڪلاس سڏيو ويندو آهي، ۽ ٻارن جي طبقن کي ذيلي ڪلاس طور سڃاتو وڃي ٿو. Java's extensions keyword استعمال ڪيو ويندو آهي ڪوڊ ۾ وراثت جي اصول کي لاڳو ڪرڻ لاءِ.

جاوا ۾ اهو ڪيئن ڪم ڪري ٿو:

  1. والدين ڪلاس ٺاهيو.
  2. Extensions keyword استعمال ڪندي ٻارن جو ڪلاس ٺاهيو .
  3. چائلڊ ڪلاس جي ڪنسٽرڪٽر ۾، استعمال ڪريو super(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...");
    }
}
يقينا، اتي مختلف قسم جا فون آهن، تنهنڪري اچو ته ٻه ٻار ڪلاس ٺاهيون: هڪ Android فون لاء ۽ ٻيو آئي فونز لاء. پوء اسان ڪجھ فيلڊ ۽ طريقا شامل ڪنداسين جيڪي والدين وٽ نه آھن. ۽ اسان استعمال ڪنداسين 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...");
    }
}
تنهن ڪري، ورجائڻ لاءِ: جاوا ۾، وراثت توهان کي ٻارن جي طبقن سان گڏ هڪ طبقي کي وڌائڻ جي اجازت ڏئي ٿي جيڪا والدين طبقي جي شعبن ۽ طريقن کي ورثي ۾ آڻيندي. اهو هڪ بهترين طريقو آهي حاصل ڪرڻ جو ڪوڊ ٻيهر استعمال ڪرڻ.

پوليمورفيزم

پوليمورفيزم هڪ شئي جي مورف ڪرڻ جي صلاحيت آهي، مختلف صورتون وٺڻ يا بلڪه مختلف طريقن سان عمل ڪرڻ. جاوا ۾، پوليمورفيزم عام طور تي ٿيندي آهي جڏهن والدين طبقي جو حوالو استعمال ڪيو ويندو آهي ٻار طبقي جي اعتراض ڏانهن اشارو ڪرڻ لاء.

ان جو مطلب ڇا آهي ۽ اهو جاوا ۾ ڪيئن ڪم ڪري ٿو:

جاوا ۾ پوليمورفيزم ڇا آهي؟ عام طور تي، ان جو مطلب آهي ته توهان ساڳئي طريقي جو نالو مختلف مقصدن لاء استعمال ڪري سگهو ٿا. جاوا ۾ پوليمورفيزم جا ٻه قسم آهن: طريقو اوور رائڊنگ (متحرڪ پوليمورفيزم) ۽ طريقو اوور لوڊنگ (جامد پوليمورفيزم).

طريقه ڪار

توهان هڪ ٻار طبقي ۾ والدين طبقي جي طريقي کي ختم ڪري سگهو ٿا، ان کي مختلف طريقي سان ڪم ڪرڻ لاء مجبور ڪيو. اچو ته هڪ ميوزڪ جي والدين ڪلاس ٺاهي هڪ play() طريقي سان.

جاوا ڪوڊ ۾ پوليمورفيزم جو مثال

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...");
    }
}
مختلف موسيقار مختلف آلات استعمال ڪن ٿا. اچو ته ٻه ٻار ڪلاس ٺاهيون: پيانسٽ ۽ وائلنسٽ . پوليمورفيزم جي مهرباني، هر هڪ راند () طريقي جي پنهنجي ورزن تي عمل ڪندو . جڏهن اوور رائڊ ڪيو وڃي، توهان @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...");
    }
}
وائلن پليئر هڪ سولوسٽ يا آرڪسٽرا جو ميمبر ٿي سگهي ٿو. اچو ته ان کي غور ۾ رکون جڏهن اسان جي راند () طريقي کي ختم ڪيو وڃي.
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...");

    }
}
اچو ته هڪ Demo ڪلاس ٺاهيون، جنهن ۾ اسين ٽي شيون ٺاهينداسين، هر هڪ اڳئين ٺهيل ڪلاس جو هڪ مثال. ڏسنداسين ته ڪهڙا نتيجا نڪرندا.
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...");
    }
}
ھاڻي اچو ته Demo ڪلاس ۾ اسان جي 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...

اوور لوڊ ڪرڻ جو طريقو

طريقو اوور لوڊ ڪرڻ جو مطلب آهي مختلف طريقن کي استعمال ڪندي هڪ ئي ڪلاس ۾ ساڳئي نالي سان. انهن جو تعداد، ترتيب، يا انهن جي پيٽرولن جي قسمن جي لحاظ کان مختلف هجڻ گهرجي. فرض ڪريو ته هڪ پيانوسٽ هڪ صوتي پيانو ۽ هڪ برقي پيانو ادا ڪري سگهي ٿو. برقي کيڏڻ لاءِ، موسيقار کي بجلي جي ضرورت آهي. اچو ته ٻه مختلف play() طريقا ٺاهيون. پھريون ھڪڙو پيٽرولر کان سواءِ، صوتي پيانو لاءِ، ۽ ٻيو ھڪڙو پيٽرولر سان جيڪو اشارو ڪري ٿو ته بجلي موجود آھي يا نه.
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. هڪ انٽرفيس جاوا پروگرامنگ ٻولي جي تعمير جو هڪ تعمير آهي جنهن ۾ صرف خلاصي عوامي طريقا ۽ جامد مسلسل فيلڊ (فائنل جامد) شامل آهن. ٻين لفظن ۾، نه ئي تجريدي طبقن ۽ نه ئي انٽرفيس استعمال ڪري سگھجن ٿيون شيون پيدا ڪرڻ لاءِ.

BTW، جاوا 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