ஜாவாவில் உள்ள பொருள்கள்

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. மாறக்கூடிய vs மாறாத பொருள்கள்

ஒரு சமயம், ஜாவாவில் மாறிலிகளைப் படித்து, மிகவும் ஆறுதலாக இல்லாத ஒரு முடிவுக்கு வந்தோம். மாறிகள் மாறாமல் பாதுகாக்க மாறிலிகள் உங்களை அனுமதிக்கின்றன, ஆனால் அவை குறிப்பிடும் பொருள்களில் மாற்றங்களைத் தடுக்க முடியாது.

இந்த சிக்கலை தீர்க்க, ஜாவா நிலையான பொருட்களை கொண்டு வந்தது. அல்லது, அவை அடிக்கடி அழைக்கப்படும், மாறாத பொருள்கள்.

மூலம், நீங்கள் ஏற்கனவே அத்தகைய வகுப்பை அறிந்திருக்கிறீர்கள், அதன் பொருள்களை மாற்ற முடியாது: String. ஒரு Stringபொருள் உருவாக்கப்பட்ட பிறகு அது எப்போதும் மாறாமல் இருக்கும். ஜாவாவின் படைப்பாளிகள் இதை எப்படி அடைந்தார்கள்?

முதலில், வகுப்பின் அனைத்து மாறிகளும் Stringமறைக்கப்பட்டுள்ளன, அதாவது அறிவிக்கப்பட்டது private.

இரண்டாவதாக, நீங்கள் Stringவகுப்பை மரபுரிமையாகப் பெற முடியாது: அதன் வகுப்பு அறிவிப்பு finalமாற்றியமைப்பையும் உள்ளடக்கியது.

மூன்றாவதாக, மற்றும் மிகவும் சுவாரஸ்யமாக, வகுப்பின் அனைத்து முறைகளும் String, கோட்பாட்டில், இருக்கும் பொருளை மாற்ற வேண்டும் என்று நீங்கள் எதிர்பார்க்கிறீர்கள், உண்மையில் அதை மாற்ற வேண்டாம், மாறாக புதிய ஒன்றைத் திருப்பித் தரவும்.

எடுத்துக்காட்டாக, இந்த toUpperCase()முறை சரத்தில் உள்ள அனைத்து எழுத்துக்களையும் பெரிய எழுத்தாக மாற்றுகிறது. ஆனால் முறை அழைக்கப்படும் பொருளை மாற்றுவதற்குப் பதிலாக, அது Stringபெரிய எழுத்துக்களைக் கொண்ட ஒரு புதிய பொருளை வழங்குகிறது:

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

இந்த குறியீட்டை இயக்கிய பிறகு இது நினைவகத்தில் இருக்கும்:

எனவே எந்த முறையிலும் உங்கள் சரங்களை அனுப்ப தயங்காதீர்கள்: யாரும் அவற்றை மாற்ற மாட்டார்கள்.