Java मध्ये OOP संकल्पना

जावाची सर्वात मोठी ताकद म्हणजे ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP). म्हणूनच ही भाषा इतकी लोकप्रिय झाली आहे आणि कोणत्याही आकाराच्या प्रकल्पांसाठी ती योग्य आहे. ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग म्हणजे काय? ही जादू नाही, परंतु जर तुम्ही त्यात खरोखर प्रवेश केलात तर ते जादुई वाटू शकते. ओओपी हे तुमचे सॉफ्टवेअर कसे तयार करायचे याबद्दल आहे. ही एक संकल्पना आहे, किंवा Java मधील oop संकल्पनांचा एक समूह आहे, जो तुम्हाला सॉफ्टवेअरचा प्रभावीपणे विकास आणि वापर करण्यासाठी Java ऑब्जेक्ट्समध्ये काही विशिष्ट परस्परसंवाद आणि संबंध निर्माण करण्यास अनुमती देतो. शास्त्रीय OOP मध्ये 3 + 1 मुख्य संकल्पना समाविष्ट आहेत. चला क्लासिक्ससह प्रारंभ करूया.

एन्कॅप्सुलेशन

डेटा एन्कॅप्स्युलेशन बाह्य जगापासून अंतर्गत डेटा लपवत आहे आणि केवळ सार्वजनिकरित्या उघड केलेल्या पद्धतींद्वारे त्यात प्रवेश करत आहे. याचा अर्थ काय? कोणता डेटा? कोणापासून लपवायचे? लपवणे म्हणजे वर्गाच्या डेटा सदस्यांवर (फील्ड) थेट प्रवेश प्रतिबंधित करणे.

Java मध्ये ते कसे कार्य करते:

1. फील्ड खाजगी केले जातात
2. वर्गातील प्रत्येक फील्डला दोन विशेष पद्धती मिळतात: एक गेटर आणि सेटर. गेटर पद्धती फील्डचे मूल्य परत करतात. सेटर पद्धतींमुळे तुम्हाला फील्डचे मूल्य अप्रत्यक्ष परंतु परवानगीयोग्य पद्धतीने बदलता येते.

जावा कोडमधील एन्कॅप्सुलेशनचे उदाहरण:

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 फील्ड सार्वजनिक आहे, कोणतेही गेटर्स किंवा सेटर नाहीत… हा वर्ग इतर अनेक वर्गांद्वारे वापरला जातो, आणि काही विकासकाने एकच इंट फील्ड पुरेसे नाही हे ठरवेपर्यंत सर्वकाही ठीक होते . समूहातील काही हॉकी खेळाडू त्यांच्या समवयस्क खेळाडूंपेक्षा जवळपास एक वर्ष मोठे असतात, त्यामुळे त्यांचा जन्म कोणत्या महिन्यात झाला यानुसार त्यांना दोन गटांमध्ये विभागणे अधिक सोयीचे होईल. त्यामुळे ageOfEnrollment फील्ड int अॅरे (int[][]) मध्ये बदलले पाहिजे : पहिली संख्या पूर्ण वर्षांसाठी आहे आणि दुसरी महिन्यांसाठी आहे. आता तुम्हाला विद्यार्थी वर्ग वापरणारे सर्व कोड रिफॅक्टर करणे आवश्यक आहे ! पण तुमची वयाची नोंदणी असल्यासफील्ड खाजगी आहे आणि तुमच्याकडे गेटर्स आणि सेटर आहेत, मग सर्वकाही सोपे आहे. विद्यार्थ्याचे वय सेट करण्याची आवश्यकता बदलल्यास, फक्त setAgeOfEnrollment() सेटर पद्धतीमध्ये तर्क अद्यतनित करा आणि तुमचे वर्ग कोणत्याही अडचणीशिवाय विद्यार्थी वापरणे सुरू ठेवू शकतात! हे उदाहरण काहीसे काल्पनिक आहे, परंतु मला आशा आहे की एन्कॅप्सुलेशन वापरणे ही एक चांगली कल्पना का आहे हे स्पष्ट करते.

वारसा

कोणत्याही व्यावहारिक अनुभवाशिवायही हे तत्त्व समजणे सोपे आहे. स्वतःची पुनरावृत्ती करू नका (DRY) हे वारसा संकल्पनेचे ब्रीदवाक्य असू शकते. इनहेरिटन्स तुम्हाला एक चाइल्ड क्लास तयार करू देतो जो फील्ड आणि पद्धतींचा वारसा घेऊन पालक वर्गाची पुनर्परिभाषित न करता. निश्चितच, तुम्ही बाल वर्गातील पालक वर्गाची फील्ड आणि पद्धती ओव्हरराइड करू शकता, परंतु ते आवश्यक नाही. इतकेच काय, तुम्ही बाल वर्गात नवीन अवस्था आणि वर्तन जोडू शकता. पालक वर्गांना काहीवेळा सुपरक्लास किंवा बेस क्लास असे म्हणतात आणि बाल वर्गांना उपवर्ग म्हणून ओळखले जाते. कोडमधील इनहेरिटन्सच्या तत्त्वाची अंमलबजावणी करण्यासाठी Java चा विस्तारित कीवर्ड वापरला जातो.

Java मध्ये ते कसे कार्य करते:

1. पालक वर्ग तयार करा.
2. विस्तारित कीवर्ड वापरून चाइल्ड क्लास तयार करा .
3. चाइल्ड क्लासच्या कन्स्ट्रक्टरमध्ये, पालकांची फील्ड सेट करण्यासाठी super(parentField1, parentField2, ...) पद्धत वापरा.

काही नियम:

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 फोनसाठी आणि दुसरा iPhones साठी. मग आम्ही काही फील्ड आणि पद्धती जोडू ज्या पालकांकडे नाहीत. आणि आम्ही सुपर() वापरून कन्स्ट्रक्टर्सना कॉल करू जे पॅरेंट क्लासमध्ये असलेले फील्ड इनिशियलाइज करण्यासाठी.

Java मधील वारसाचे उदाहरण

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...");
    }
}

तर, पुनरावृत्ती करण्यासाठी: Java मध्ये, इनहेरिटन्स तुम्हाला चाइल्ड क्लासेससह क्लास वाढवू देते जे फील्ड आणि पॅरेंट क्लासच्या पद्धतींचा वारसा घेतात. कोड पुन्हा वापरता येण्याचा हा एक उत्कृष्ट मार्ग आहे.

बहुरूपता

पॉलीमॉर्फिझम ही वस्तूची विविध रूपे धारण करण्याची किंवा वेगवेगळ्या प्रकारे कार्य करण्याची क्षमता आहे. जावामध्ये, बहुरूपता सामान्यतः तेव्हा घडते जेव्हा पालक वर्गाचा संदर्भ चाइल्ड क्लास ऑब्जेक्टचा संदर्भ देण्यासाठी वापरला जातो.

याचा अर्थ काय आणि ते Java मध्ये कसे कार्य करते:

जावा मध्ये पॉलिमॉर्फिझम म्हणजे काय? सर्वसाधारणपणे, याचा अर्थ तुम्ही समान पद्धतीचे नाव वेगवेगळ्या हेतूंसाठी वापरू शकता. जावामध्ये पॉलिमॉर्फिझमचे दोन प्रकार आहेत: मेथड ओव्हरराइडिंग (डायनॅमिक पॉलिमॉर्फिझम) आणि मेथड ओव्हरलोडिंग (स्टॅटिक पॉलिमॉर्फिझम).

पद्धत अधिलिखित

तुम्ही लहान मुलांच्या वर्गात पालक वर्गाची पद्धत ओव्हरराइड करू शकता, त्यास वेगळ्या प्रकारे कार्य करण्यास भाग पाडू शकता. प्ले() पद्धतीने संगीतकार पालक वर्ग तयार करू .

जावा कोडमधील पॉलिमॉर्फिझमचे उदाहरण

   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...");
    }
}

व्हायोलिन वादक एकल वादक किंवा ऑर्केस्ट्राचा सदस्य असू शकतो. आमच्या 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...

पद्धत ओव्हरलोडिंग

मेथड ओव्हरलोडिंग म्हणजे एकाच वर्गात एकाच नावाने विविध पद्धती वापरणे. संख्या, क्रम किंवा त्यांच्या पॅरामीटर्सच्या प्रकारानुसार ते भिन्न असले पाहिजेत. समजा की एक पियानोवादक ध्वनिक पियानो आणि इलेक्ट्रिक पियानो वाजवू शकतो. इलेक्ट्रिक वाजवण्यासाठी संगीतकाराला वीज लागते. चला दोन भिन्न 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.

Java ला माहित आहे की कोणती पद्धत त्याच्या पॅरामीटर्स आणि ऑब्जेक्ट प्रकारावर आधारित आहे. ते बहुरूपता आहे.

अमूर्त

जेव्हा आपण वर्ग परिभाषित करतो, तेव्हा आपण एखाद्या गोष्टीचे मॉडेल तयार करण्याचा प्रयत्न करत असतो. उदाहरणार्थ, समजा आपण मायरेसर नावाचा व्हिडिओ गेम वेगवेगळ्या रेस कारसह लिहित आहोत. खेळाडू त्यापैकी एक निवडू शकतो आणि नंतर तो अपडेट करू शकतो किंवा दुसरा खरेदी करू शकतो. तर… कार म्हणजे काय? कार ही एक अतिशय क्लिष्ट गोष्ट आहे, परंतु जर आपण रेसिंग व्हिडिओ गेम (ड्रायव्हिंग सिम्युलेटरच्या विरूद्ध) तयार करण्याचा प्रयत्न करत आहोत, तर आपल्याला त्यात असलेल्या हजारो गीअर्स आणि गॅस्केटचे वर्णन करण्याची आवश्यकता नाही. आम्हाला त्याचे मॉडेल, उच्च गती, कुशलता वैशिष्ट्ये, किंमत, रंग ... आणि कदाचित ते पुरेसे आहे. आमच्या गेमसाठी ते कारचे मॉडेल आहे. नंतर MyRacer 2 मध्ये, समजा आम्ही टायर जोडण्याचे ठरवले जे रस्त्यावर हाताळणीवर परिणाम करतात. येथे मॉडेल वेगळे आहे, कारण आम्ही अधिक तपशील जोडले. चला' s डेटा अ‍ॅब्स्ट्रॅक्शनला एखाद्या वस्तूची केवळ महत्त्वाची (किंवा आवश्यक) वैशिष्ट्ये ओळखण्याची आणि कोणत्याही अप्रासंगिक तपशीलांकडे दुर्लक्ष करण्याची प्रक्रिया म्हणून परिभाषित करते. अमूर्ततेचे वेगवेगळे स्तर आहेत. उदाहरणार्थ, जर तुम्ही बसमध्ये प्रवासी असाल, तर तुमची बस कशी दिसते आणि ती कुठे जात आहे हे तुम्हाला माहीत असणे आवश्यक आहे, परंतु ती कशी चालवायची हे तुम्हाला माहित असणे आवश्यक नाही. जर तुम्ही बस ड्रायव्हर असाल, तर तुम्हाला नवीन बस कशी तयार करायची हे माहित असण्याची गरज नाही - तुम्हाला फक्त ती कशी चालवायची हे माहित असणे आवश्यक आहे. परंतु जर तुम्ही बस उत्पादक असाल, तर तुम्हाला अमूर्ततेच्या खालच्या स्तरावर जाणे आवश्यक आहे, कारण बस डिझाइनचे तपशील तुमच्यासाठी खूप महत्वाचे आहेत. मला आशा आहे की मला काय म्हणायचे आहे ते तुम्हाला समजले असेल. तुमची बस कशी दिसते आणि ती कुठे जात आहे हे तुम्हाला माहित असणे आवश्यक आहे, परंतु तुम्हाला ती कशी चालवायची हे माहित असणे आवश्यक नाही. जर तुम्ही बस ड्रायव्हर असाल, तर तुम्हाला नवीन बस कशी तयार करायची हे माहित असण्याची गरज नाही - तुम्हाला फक्त ती कशी चालवायची हे माहित असणे आवश्यक आहे. परंतु जर तुम्ही बस उत्पादक असाल, तर तुम्हाला अमूर्ततेच्या खालच्या स्तरावर जाणे आवश्यक आहे, कारण बस डिझाइनचे तपशील तुमच्यासाठी खूप महत्वाचे आहेत. मला आशा आहे की मला काय म्हणायचे आहे ते तुम्हाला समजले असेल. तुमची बस कशी दिसते आणि ती कुठे जात आहे हे तुम्हाला माहित असणे आवश्यक आहे, परंतु तुम्हाला ती कशी चालवायची हे माहित असणे आवश्यक नाही. जर तुम्ही बस ड्रायव्हर असाल, तर तुम्हाला नवीन बस कशी तयार करायची हे माहित असण्याची गरज नाही - तुम्हाला फक्त ती कशी चालवायची हे माहित असणे आवश्यक आहे. परंतु जर तुम्ही बस उत्पादक असाल, तर तुम्हाला अमूर्ततेच्या खालच्या स्तरावर जाणे आवश्यक आहे, कारण बस डिझाइनचे तपशील तुमच्यासाठी खूप महत्वाचे आहेत. मला आशा आहे की मला काय म्हणायचे आहे ते तुम्हाला समजले असेल.

Java मध्ये ते कसे कार्य करते:

चला Java मध्ये अमूर्ततेचे चार स्तर तयार करूया, किंवा त्याऐवजी OOP मध्ये — सर्वात कमी (सर्वात विशिष्ट) ते सर्वोच्च (सर्वात अमूर्त) पर्यंत.

1. अमूर्ततेची सर्वात खालची पातळी ही विशिष्ट वस्तू आहे. विशिष्ट वर्गाशी संबंधित वैशिष्ट्यांचा संच असलेली ही एक संस्था आहे. त्यात विशिष्ट फील्ड मूल्ये आहेत

2. ऑब्जेक्ट्स तयार करण्यासाठी टेम्पलेट एक वर्ग आहे. हे समान गुणधर्म आणि अंतर्गत रचना असलेल्या वस्तूंच्या संचाचे वर्णन आहे.

3. अमूर्त वर्ग हा वर्गांच्या संचाच्या वैशिष्ट्यांचे अमूर्त वर्णन आहे (ते इतर वर्गांद्वारे वारशासाठी टेम्पलेट म्हणून कार्य करते). यात अमूर्ततेची उच्च पातळी आहे, म्हणून थेट अमूर्त वर्गातून वस्तू तयार करणे अशक्य आहे. वस्तू तयार करण्यासाठी केवळ अमूर्त वर्गाच्या मुलांचे वर्ग वापरले जाऊ शकतात. अमूर्त वर्गात अंमलबजावणीसह पद्धतींचा समावेश असू शकतो, परंतु ही आवश्यकता नाही.

4. इंटरफेस हे जावा प्रोग्रामिंग भाषेतील रचना आहे ज्यामध्ये केवळ अमूर्त सार्वजनिक पद्धती आणि स्थिर स्थिर फील्ड (अंतिम स्थिर) असतात. दुसऱ्या शब्दांत, ऑब्जेक्ट्स व्युत्पन्न करण्यासाठी अमूर्त वर्ग किंवा इंटरफेसचा वापर केला जाऊ शकत नाही.

BTW, Java 8 किंवा नंतरच्या मध्ये, इंटरफेसमध्ये केवळ अमूर्त पद्धती आणि स्थिरांक नसतात, तर डीफॉल्ट आणि स्थिर पद्धती देखील असू शकतात. Java मध्ये, इंटरफेस वर्तन परिभाषित करतो, तर अमूर्त वर्ग पदानुक्रम तयार करण्यासाठी वापरला जातो. एक इंटरफेस अनेक वर्गांद्वारे लागू केला जाऊ शकतो.

Java कोडमधील इंटरफेसचे उदाहरण

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...");
}

}

सुरुवातीच्या विद्यार्थ्यांसाठी, ज्यामध्ये Java मधील ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंगच्या सर्व मुख्य संकल्पना समाविष्ट आहेत. 4 मुख्य OOP तत्त्वांव्यतिरिक्त, Java मध्ये असोसिएशन, एकत्रीकरण आणि रचना देखील आहे. तुम्ही त्यांना "अतिरिक्त OOP तत्त्वे" म्हणू शकता. ते त्यांच्या स्वतंत्र लेखास पात्र आहेत.