जावा में वस्तुएं

1. वस्तुएँ

जावा में सब कुछ एक वस्तु है।

अधिक सटीक रूप से, जावा में बहुत कम चीजें हैं जो ऑब्जेक्ट नहीं हैं। उदाहरण के लिए, आदिम प्रकार। लेकिन यह नियम का एक दुर्लभ अपवाद है।

तो वस्तु क्या है?

एक वस्तु एक इकाई है जो डेटा को उन विधियों के साथ समूहित करती है जो डेटा को संसाधित करती हैं । जब हम "डेटा" कहते हैं, तो हमारा मतलब निश्चित रूप से चर होता है।

किसी वस्तु के चरों को उसका "डेटा" या "स्थिति" कहा जाता है।

किसी वस्तु के तरीकों को उसका "व्यवहार" कहा जाता है। किसी वस्तु की स्थिति (चर) को केवल उस वस्तु के तरीकों का उपयोग करके बदलना प्रथागत है। किसी वस्तु के चर को सीधे बदलना (इसके तरीकों का उपयोग नहीं करना) खराब रूप माना जाता है।

प्रत्येक वस्तु के साथ-साथ प्रत्येक चर का एक प्रकार होता है । यह प्रकार एक बार निर्धारित किया जाता है जब वस्तु बनाई जाती है और भविष्य में इसे बदला नहीं जा सकता। किसी वस्तु का प्रकार उसकी कक्षा है।

प्रत्येक वस्तु के उदाहरण चर (फ़ील्ड) की अपनी प्रति होती है। यदि एक गैर-स्थैतिक int एक वर्ग में एक चर घोषित किया जाता है, और आपका प्रोग्राम उस वर्ग की 10 वस्तुओं को बनाता है, तो प्रत्येक वस्तु का अपना int एक चर होगा।

किसी वस्तु के साथ परस्पर क्रिया करना

किसी ऑब्जेक्ट के साथ काम करने का सबसे सुविधाजनक तरीका एक वेरिएबल में उसके संदर्भ को स्टोर करना है, और उसके बाद उस वेरिएबल पर विधियों को कॉल करना है। यह आपको जाना-पहचाना लगेगा:

variable.method()

जहाँ variableएक चर है जो किसी वस्तु के संदर्भ को संग्रहीत करता है, और methodउस वर्ग की एक विधि है।

यदि आप किसी वस्तु के क्षेत्र (चर) को संदर्भित करना चाहते हैं, तो आपको डॉट ऑपरेटर का उपयोग करने की भी आवश्यकता है :

variable.field

एक चर कहाँ variableहै जो किसी वस्तु के संदर्भ को संग्रहीत करता है, और fieldएक आवृत्ति चर (फ़ील्ड) है।

2. newसंचालिका

एक निश्चित वर्ग का ऑब्जेक्ट बनाने के लिए, आपको newऑपरेटर का उपयोग करने की आवश्यकता होती है। सामान्य तौर पर, ऑब्जेक्ट बनाने के लिए यह कैसा दिखता है:

Class variable = new Class(arguments);

Classवेरिएबल के वर्ग का नाम variableऔर साथ ही बनाई जाने वाली वस्तु के वर्ग का नाम कहां है। और variable एक चर है जो निर्मित वस्तु के संदर्भ को संग्रहीत करता है। और argumentsकंस्ट्रक्टर को पास किए गए तर्कों की कॉमा-सीमांकित सूची के लिए प्लेसहोल्डर है।

पारित किए जा सकने वाले तर्कों की विशिष्ट सूची प्रोग्रामर द्वारा तय की जाती है जो कक्षा लिखते हैं।

आपने पहले ऑब्जेक्ट बनाए हैं और यहां तक ​​कि इस विशेष निर्माण का उपयोग भी किया है। आप नहीं भूले हैं, मुझे उम्मीद है?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console- यह एक consoleवेरिएबल बनाता है जिसका प्रकार है Scanner। - यह एक नई वस्तु बनाता है। और असाइनमेंट ऑपरेटर नव निर्मित वस्तु के संदर्भ के बराबर चर सेट करता है।new Scanner(System.in)Scannerconsole

दूसरी पंक्ति में, हम वेरिएबल का उपयोग करके ऑब्जेक्ट nextInt()पर मेथड को कॉल करते हैं, जो ऑब्जेक्ट के संदर्भ को संग्रहीत करता है ।ScannerconsoleScanner

वस्तु निर्माण के उदाहरण:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

बनाई गई वस्तुओं को वर्ग की वस्तुएं या वर्ग के उदाहरण कहा जाता है , जबकि वर्ग को वस्तु का वर्ग कहा जाता है । उदाहरण के लिए, चर वर्ग sके एक उदाहरण के संदर्भ को संग्रहीत करता है ।String

3. कक्षाओं का परिचय

मुझे लगता है कि आप पहले ही देख चुके हैं कि अन्य प्रोग्रामरों द्वारा लिखी गई कक्षाओं का उपयोग करना कितना सुविधाजनक है। लेकिन अपनी खुद की कक्षाएं लिखने के बारे में क्या?

आपको कैसे पता चलेगा कि आपको अपनी कक्षा की आवश्यकता कब और कहाँ है और इसे कैसे बनाना है?

प्रोग्रामर आमतौर पर अपनी कक्षाएं तब बनाते हैं जब वे कार्यक्रम में एक नई इकाई लाना चाहते हैं। क्या यह भ्रमित करने वाला है? फिर मैं समझाने की कोशिश करूँगा, लेकिन मैं बहुत दूर से शुरू करने जा रहा हूँ।

डेटा का समूह

थोड़ा सरल करते हुए, हम कह सकते हैं कि जावा में एक ऑब्जेक्ट मेमोरी का एक ब्लॉक है जिसमें एक वर्ग (इंस्टेंस फ़ील्ड्स) में घोषित चर शामिल हैं। या, दूसरे शब्दों में, चर एक समूह में संयुक्त होते हैं।

मान लीजिए कि आपके प्रोग्राम को 100बिंदुओं के निर्देशांक को स्टोर करने की आवश्यकता है और उन्हें स्क्रीन पर प्रदर्शित करने के लिए एक विधि की आवश्यकता है। यह सरणियों का उपयोग करके किया जा सकता है। उदाहरण के लिए, इस तरह:

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

यह बहुत अधिक सुविधाजनक होगा यदि हमारे पास एक बिंदु के बारे में सभी जानकारी संग्रहीत करने के लिए एक ही प्रकार हो: x, y, color। यदि ऐसा प्रकार जावा में मौजूद नहीं है, तो आप इसे स्वयं बना सकते हैं।

Pointऐसा करने के लिए, हम एक वर्ग के लिए कोड लिखेंगे :

public class Point
{
   public int x;
   public int y;
   public int color;
}

अब उपरोक्त कोड को फिर से लिखा जा सकता है:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

अब कक्षा में एक विधि जोड़ते हैं Pointजो वस्तु के बारे में जानकारी प्रदर्शित करेगी:

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

अब Solutionकक्षा इस तरह दिखती है:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

हमने कुशलता से बिंदु के निर्देशांक और रंग की जानकारी को Pointकक्षा के अंदर छिपा दिया, साथ ही उस विधि के साथ जो बिंदु की स्थिति को प्रदर्शित करती है।

कक्षाएं कार्यक्रम की जटिलता को प्रबंधित करने का एक तरीका हैं। एक बड़ा कार्यक्रम कम जटिल हो जाता है जब इसे कई छोटी कक्षाओं में विभाजित किया जाता है।

4. परिवर्तनीय बनाम अपरिवर्तनीय वस्तुएं

एक बार, हमने जावा में स्थिरांक का अध्ययन किया और एक निष्कर्ष पर पहुंचे जो बहुत ही आरामदायक नहीं है। स्थिरांक आपको चरों को बदलने से बचाने की अनुमति देते हैं, लेकिन वे उन वस्तुओं में परिवर्तन को नहीं रोक सकते जिन्हें वे संदर्भित करते हैं।

इस समस्या को हल करने के लिए, जावा निरंतर वस्तुओं के साथ आया। या, जैसा कि उन्हें अधिक बार कहा जाता है, अपरिवर्तनीय वस्तुएं।

वैसे, आप पहले से ही ऐसे वर्ग को जानते हैं, जिनकी वस्तुओं को बदला नहीं जा सकता: String. एक Stringवस्तु बनने के बाद हमेशा अपरिवर्तित रहती है। और जावा के रचनाकारों ने इसे कैसे प्राप्त किया?

सबसे पहले, कक्षा के सभी चर Stringछिपे हुए हैं, अर्थात घोषित किए गए हैं private।

दूसरा, आप Stringवर्ग को इनहेरिट नहीं कर सकते: इसके वर्ग घोषणा में finalसंशोधक शामिल है।

तीसरा, और सबसे दिलचस्प बात यह है कि वर्ग के सभी तरीके String, जो, सिद्धांत रूप में, आप मौजूदा वस्तु को बदलने की उम्मीद करेंगे, वास्तव में इसे नहीं बदलते हैं, बल्कि एक नया लौटाते हैं।

उदाहरण के लिए, toUpperCase()विधि सभी अक्षरों को स्ट्रिंग अपरकेस में बनाती है। लेकिन उस वस्तु को बदलने के बजाय जिस पर विधि कहलाती है, वह Stringबड़े अक्षरों वाली एक नई वस्तु लौटाती है:

String text = "This is a very important message";
String message = text.toUpperCase();

इस कोड को निष्पादित करने के बाद स्मृति में यही होगा:

तो बेझिझक अपने तार को किसी भी तरीके से पास करें: कोई भी उन्हें बदलेगा नहीं।