OOP ची तत्त्वे

जावा ही ऑब्जेक्ट ओरिएंटेड भाषा आहे. याचा अर्थ असा की तुम्हाला जावा प्रोग्राम्स ऑब्जेक्ट-ओरिएंटेड पॅराडाइम वापरून लिहावे लागतील. आणि हा नमुना तुमच्या प्रोग्राममध्ये ऑब्जेक्ट्स आणि क्लासेसचा वापर करतो. वर्ग आणि वस्तू काय आहेत आणि मूलभूत OOP तत्त्वे (अमूर्तता, वारसा, बहुरूपता आणि एन्कॅप्सुलेशन) व्यवहारात कशी लागू करायची हे समजून घेण्यासाठी उदाहरणे वापरून पाहू.

वस्तू म्हणजे काय?

आपण ज्या जगात राहतो ते वस्तूंनी बनलेले आहे. आजूबाजूला पाहिल्यास, आपण घरे, झाडे, कार, फर्निचर, डिशेस आणि संगणकांनी वेढलेले आहोत हे आपण पाहू शकतो. या सर्व गोष्टी वस्तू आहेत आणि त्या प्रत्येकामध्ये विशिष्ट वैशिष्ट्ये, आचरण आणि उद्देशांचा एक संच आहे. आम्हाला वस्तूंची सवय आहे आणि आम्ही त्यांचा नेहमीच विशिष्ट हेतूंसाठी वापरतो. उदाहरणार्थ, जर आम्हाला कामावर जायचे असेल तर आम्ही कार वापरतो. आम्हाला खायचे असेल तर आम्ही डिश वापरतो. आणि जर आम्हाला आराम करायचा असेल तर आम्हाला एक आरामदायक सोफा मिळेल. दैनंदिन जीवनातील समस्या सोडवण्यासाठी मानवाला वस्तूंच्या दृष्टीने विचार करण्याची सवय आहे. प्रोग्रॅमिंगमध्ये ऑब्जेक्ट्स वापरण्याचे हे एक कारण आहे. या पद्धतीला ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग म्हणतात. एक उदाहरण देऊ. कल्पना करा की तुम्ही एक नवीन फोन विकसित केला आहे आणि तुम्ही मोठ्या प्रमाणावर उत्पादन सुरू करू इच्छित आहात. फोनचा विकासक म्हणून, तो कशासाठी आहे हे तुम्हाला माहीत आहे, ते कसे कार्य करते आणि त्याचे भाग काय आहेत (बॉडी, मायक्रोफोन, स्पीकर, वायर, बटणे इ.). इतकेच काय, हे भाग कसे जोडायचे हे फक्त तुम्हालाच माहीत आहे. परंतु तुम्‍ही वैयक्तिकरित्या फोन बनवण्‍याची योजना करत नाही — हे करण्‍यासाठी तुमच्‍याकडे कामगारांची संपूर्ण टीम आहे. फोनचे भाग कसे जोडायचे हे वारंवार समजावून सांगण्याची गरज दूर करण्यासाठी आणि सर्व फोन सारखेच बनवले आहेत याची खात्री करण्यासाठी, तुम्ही त्यांचे उत्पादन सुरू करण्यापूर्वी, तुम्हाला फोन कसा व्यवस्थित केला जातो याचे वर्णन करणारे रेखाचित्र तयार करणे आवश्यक आहे. OOP मध्ये, आम्ही अशा वर्णन, रेखाचित्र, आकृती किंवा टेम्पलेटला वर्ग म्हणतो. प्रोग्राम चालू असताना ते ऑब्जेक्ट्स तयार करण्याचा आधार बनवते. वर्ग हे विशिष्ट प्रकारच्या वस्तूंचे वर्णन आहे — जसे की फील्ड, पद्धती आणि कन्स्ट्रक्टर यांचा समावेश असलेला सामान्य टेम्पलेट. ऑब्जेक्ट हे वर्गाचे उदाहरण आहे.

अमूर्त

आता आपण वास्तविक जगातल्या ऑब्जेक्टवरून प्रोग्राममधील ऑब्जेक्टवर कसे जाऊ शकतो याचा विचार करूया. आम्ही एक उदाहरण म्हणून फोन वापरू. दळणवळणाच्या या साधनाचा इतिहास 100 वर्षांहून अधिक आहे. आधुनिक टेलिफोन हे त्याच्या 19व्या शतकातील पूर्ववर्ती पेक्षा अधिक जटिल उपकरण आहे. फोन वापरताना, आम्ही त्याची संस्था आणि त्यामध्ये होणाऱ्या प्रक्रियांचा विचार करत नाही. आम्ही फोनच्या डेव्हलपरद्वारे प्रदान केलेली कार्ये वापरतो: फोन नंबर प्रविष्ट करण्यासाठी आणि कॉल करण्यासाठी बटणे किंवा टच स्क्रीन. पहिल्या फोन इंटरफेसपैकी एक क्रॅंक होता ज्याला कॉल करण्यासाठी फिरवण्याची आवश्यकता होती. अर्थात हे फारसे सोयीचे नव्हते. पण त्याचे कार्य निर्दोषपणे पार पाडले. आपण सर्वात आधुनिक आणि अगदी पहिल्या फोनची तुलना केल्यास, 19व्या शतकाच्या उत्तरार्धात आणि आधुनिक स्मार्टफोनसाठी सर्वात महत्त्वाची फंक्शन्स तुम्ही लगेच ओळखू शकता. ते कॉल करण्याची क्षमता आणि कॉल प्राप्त करण्याची क्षमता आहेत. खरं तर, हेच फोनला फोन बनवते, आणि काहीतरी नाही. आता फक्त OOP चे तत्व लागू करा: ऑब्जेक्टची सर्वात महत्वाची वैशिष्ट्ये आणि माहिती ओळखा. या तत्त्वाला अमूर्तता म्हणतात. OOP मध्ये, अ‍ॅब्स्ट्रॅक्शनला प्रोग्राममधील ऑब्जेक्ट्स म्हणून वास्तविक-जगातील कार्याचे घटक दर्शविण्याची पद्धत म्हणून देखील परिभाषित केले जाऊ शकते. अ‍ॅब्स्ट्रॅक्शन नेहमी एखाद्या वस्तूच्या विशिष्ट गुणधर्मांच्या सामान्यीकरणाशी संबंधित असते, म्हणून मुख्य गोष्ट म्हणजे हातातील कार्याच्या संदर्भात अर्थपूर्ण माहिती क्षुल्लक माहितीपासून वेगळे करणे. याव्यतिरिक्त, अमूर्ततेचे अनेक स्तर असू शकतात. चला' आमच्या फोनवर अमूर्ततेचे तत्त्व लागू करण्याचा प्रयत्न करा. सुरुवात करण्यासाठी, आम्ही फोनचे सर्वात सामान्य प्रकार ओळखू — अगदी पहिल्या फोनपासून ते सध्याच्या काळातील फोनपर्यंत. उदाहरणार्थ, आकृती 1 मधील आकृतीच्या स्वरूपात आम्ही त्यांचे प्रतिनिधित्व करू शकतो. अमूर्तता वापरून, आम्ही आता या ऑब्जेक्ट पदानुक्रमातील सामान्य माहिती ओळखू शकतो: सामान्य अमूर्त ऑब्जेक्ट (टेलिफोन), टेलिफोनची सामान्य वैशिष्ट्ये (उदा. त्याच्या निर्मितीचे वर्ष), आणि सामान्य इंटरफेस (सर्व टेलिफोन प्राप्त करू शकतात आणि कॉल करू शकतात). Java मध्ये ते कसे दिसते ते येथे आहे:

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 ची इतर मूलभूत तत्त्वे लागू करून नवीन प्रकारचे फोन तयार करू शकतो, जे आम्ही खाली एक्सप्लोर करू.

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

अमूर्ततेसह, आम्ही सर्व वस्तूंसाठी सामान्य काय आहे हे ओळखतो. परंतु प्रत्येक प्रकारचा फोन अद्वितीय आहे, कसा तरी इतरांपेक्षा वेगळा आहे. एका कार्यक्रमात, आपण सीमा कशा काढू आणि हे व्यक्तिमत्व कसे ओळखू? कोणीही चुकून किंवा जाणूनबुजून आमचा फोन खंडित करू शकत नाही किंवा एका मॉडेलला दुसर्‍यामध्ये रूपांतरित करण्याचा प्रयत्न करू नये म्हणून आम्ही ते कसे बनवू? वास्तविक जगात, उत्तर स्पष्ट आहे: आपल्याला फोन केसमध्ये सर्व भाग ठेवणे आवश्यक आहे. शेवटी, जर तुम्ही तसे केले नाही तर — त्याऐवजी फोनचे सर्व अंतर्गत भाग सोडून बाहेरील तारा कनेक्ट करा — काही जिज्ञासू प्रयोगकर्त्यांना आमचा फोन नक्कीच "सुधारणा" करायचा असेल. अशा टिंकरिंगला प्रतिबंध करण्यासाठी, एन्कॅप्सुलेशनचा सिद्धांत ऑब्जेक्टच्या डिझाइन आणि ऑपरेशनमध्ये वापरला जातो. हे तत्त्व सांगते की ऑब्जेक्टचे गुणधर्म आणि वर्तन एकाच वर्गात एकत्रित केले जातात, ऑब्जेक्ट' s अंतर्गत अंमलबजावणी वापरकर्त्यापासून लपविली जाते आणि ऑब्जेक्टसह कार्य करण्यासाठी सार्वजनिक इंटरफेस प्रदान केला जातो. प्रोग्रामरचे कार्य हे निर्धारित करणे आहे की ऑब्जेक्टचे कोणते गुणधर्म आणि पद्धती सार्वजनिक प्रवेशासाठी उपलब्ध आहेत आणि कोणते अंतर्गत अंमलबजावणी तपशील आहेत जे प्रवेश करण्यायोग्य नसावेत.

एन्कॅप्सुलेशन आणि ऍक्सेस कंट्रोल

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

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

 }

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

वारसा

फोनच्या आकृतीवर आणखी एक नजर टाकूया. तुम्ही पाहू शकता की हे एक पदानुक्रम आहे ज्यामध्ये मॉडेलची सर्व वैशिष्ट्ये त्याच्या शाखेच्या वर स्थित आहेत आणि ती स्वतःची काही जोडते. उदाहरणार्थ, स्मार्टफोन संप्रेषणासाठी सेल्युलर नेटवर्क वापरतो (त्यात सेल फोनचे गुणधर्म आहेत), वायरलेस आणि पोर्टेबल आहे (त्यात कॉर्डलेस फोनचे गुणधर्म आहेत) आणि कॉल प्राप्त आणि करू शकतात (फोनचे गुणधर्म आहेत). आपल्याकडे जे आहे ते ऑब्जेक्ट गुणधर्मांचे वारसा आहे. प्रोग्रामिंगमध्ये, वारसा म्हणजे नवीन वर्ग परिभाषित करण्यासाठी विद्यमान वर्ग वापरणे. स्मार्टफोन क्लास तयार करण्यासाठी वारसा वापरण्याच्या उदाहरणाचा विचार करूया. सर्व कॉर्डलेस फोन रिचार्ज करण्यायोग्य बॅटरीद्वारे समर्थित असतात, ज्यांचे बॅटरी आयुष्य निश्चित असते. त्यानुसार, आम्ही ही मालमत्ता कॉर्डलेस फोन क्लासमध्ये जोडतो:

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भाष्य वापरले जाते. हे कंपाइलरला अधिलिखित आणि अधिलिखित पद्धतींच्या स्वाक्षऱ्या तपासण्यास सांगते. शेवटी, तुमचे Java प्रोग्राम OOP च्या तत्त्वांशी सुसंगत असल्याची खात्री करण्यासाठी, या टिपांचे अनुसरण करा:

• ऑब्जेक्टची मुख्य वैशिष्ट्ये ओळखणे;
• सामान्य गुणधर्म आणि वर्तन ओळखा आणि वर्ग तयार करताना वारसा वापरा;
• वस्तूंचे वर्णन करण्यासाठी अमूर्त प्रकार वापरा;
• वर्गाच्या अंतर्गत अंमलबजावणीशी संबंधित पद्धती आणि फील्ड नेहमी लपवण्याचा प्रयत्न करा.