జావాలో వస్తువులు

1. వస్తువులు

జావాలోని ప్రతిదీ ఒక వస్తువు.

మరింత ఖచ్చితంగా చెప్పాలంటే, జావాలో వస్తువులు లేని విషయాలు చాలా తక్కువ. ఉదాహరణకు, ఆదిమ రకాలు. కానీ ఇది నియమానికి చాలా అరుదైన మినహాయింపు.

కాబట్టి ఒక వస్తువు ఏమిటి?

ఆబ్జెక్ట్ అనేది డేటాను ప్రాసెస్ చేసే పద్ధతులతో పాటు డేటాను సమూహపరిచే ఎంటిటీ . మేము "డేటా" అని చెప్పినప్పుడు, మనకు వేరియబుల్స్ అని అర్ధం.

ఒక వస్తువు యొక్క వేరియబుల్స్ దాని "డేటా" లేదా "స్టేట్" అని పిలువబడతాయి.

ఒక వస్తువు యొక్క పద్ధతులు దాని "ప్రవర్తన"గా చెప్పబడ్డాయి. ఒక వస్తువు యొక్క స్థితిని (వేరియబుల్స్) ఆ వస్తువు యొక్క పద్ధతులను ఉపయోగించి మాత్రమే మార్చడం ఆచారం. ఆబ్జెక్ట్ యొక్క వేరియబుల్స్‌ను నేరుగా మార్చడం (దాని పద్ధతులను ఉపయోగించకపోవడం) చెడ్డ రూపంగా పరిగణించబడుతుంది.

ప్రతి వస్తువు , అలాగే ప్రతి వేరియబుల్‌కు ఒక రకం ఉంటుంది . వస్తువు సృష్టించబడినప్పుడు ఈ రకం ఒకసారి నిర్ణయించబడుతుంది మరియు భవిష్యత్తులో మార్చబడదు. వస్తువు యొక్క రకం దాని తరగతి.

ప్రతి వస్తువు దాని స్వంత ఉదాహరణ వేరియబుల్స్ (ఫీల్డ్‌లు) కాపీని కలిగి ఉంటుంది. క్లాస్‌లో నాన్-స్టాటిక్ పూర్ణాంక వేరియబుల్ ప్రకటించబడితే, మరియు మీ ప్రోగ్రామ్ ఆ తరగతికి చెందిన 10 ఆబ్జెక్ట్‌లను సృష్టిస్తే, ప్రతి వస్తువు దాని స్వంత పూర్ణాంక వేరియబుల్‌ను కలిగి ఉంటుంది.

ఒక వస్తువుతో పరస్పర చర్య చేయడం

ఒక వస్తువుతో పని చేయడానికి అత్యంత అనుకూలమైన మార్గం వేరియబుల్‌లో దాని సూచనను నిల్వ చేయడం, ఆపై ఆ వేరియబుల్‌పై పద్ధతులను కాల్ చేయడం. ఇది మీకు సుపరిచితమైనదిగా కనిపిస్తుంది:

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();

ఈ కోడ్‌ని అమలు చేసిన తర్వాత ఇది మెమరీలో ఉంటుంది:

కాబట్టి మీ తీగలను ఏదైనా పద్ధతికి పంపడానికి సంకోచించకండి: ఎవరూ వాటిని మార్చలేరు.