జావాలో మెథడ్ పారామితులు

1. వాదనలను ఆమోదించడం

మరియు ఇప్పుడు వినోదం ప్రారంభమవుతుంది. System.out.println()మేము ఆర్గ్యుమెంట్‌లను పద్ధతులకు పంపగలము వంటి పద్ధతుల నుండి మీకు ఇప్పటికే తెలిసి ఉండవచ్చు . ఒకసారి మేము పద్ధతి లోపల ఉంటే, మేము వాటిని పారామితులుగా సూచిస్తాము. వాస్తవానికి, పద్దతులు సృష్టించడం మరియు ఉపయోగించడం ద్వారా మనం పొందే ప్రయోజనాలను పారామితులు బాగా పెంచుతాయి.

మేము పారామితులతో పద్ధతిని ఎలా ప్రకటిస్తాము? ఇది నిజానికి చాలా సులభం:

public static void name(parameters)
{
  method body
}

name పద్ధతి యొక్క ప్రత్యేక పేరు ఎక్కడ ఉంది మరియు method body పద్ధతిని రూపొందించే ఆదేశాలను సూచిస్తుంది. మరియు parameters కామాలతో వేరు చేయబడిన పద్ధతి పారామితుల కోసం ప్లేస్‌హోల్డర్. ఈ టెంప్లేట్‌ను మరింత వివరంగా వివరిద్దాం:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

ఉదాహరణలు:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

పద్ధతిలో పారామీటర్‌లు ఉండకూడదనుకుంటే, కుండలీకరణాలను ఖాళీగా ఉంచుతాము.

పారామితులు ఒక పద్ధతిలో ప్రత్యేక వేరియబుల్స్. వారి సహాయంతో, మీరు పిలిచినప్పుడు పద్ధతికి వివిధ విలువలను పాస్ చేయవచ్చు.

ఉదాహరణకు, ఇచ్చిన అనేక సార్లు టెక్స్ట్ స్ట్రింగ్‌ను ప్రదర్శించే పద్ధతిని వ్రాద్దాం.

స్క్రీన్‌పై స్ట్రింగ్‌ను అనేకసార్లు ప్రదర్శించడానికి కోడ్‌ను ఎలా వ్రాయాలో మీకు ఇప్పటికే తెలుసు. అయితే మీరు ఏ స్ట్రింగ్‌ని ప్రింట్ చేయాలి? మరియు ఎన్ని సార్లు? దీని కోసం మనకు పారామితులు అవసరం.

దీన్ని చేసే కోడ్ ఇలా ఉంటుంది:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

ఒక పద్ధతిని పిలిచిన ప్రతిసారీ, దాని పారామితులు ఆమోదించబడిన విలువలను కేటాయించబడతాయి మరియు ఆ తర్వాత మాత్రమే మేము పద్ధతి లోపల ఆదేశాలను అమలు చేయడం ప్రారంభిస్తాము.

2. వాదనలు

పారామితులతో ఒక పద్ధతిని పిలవడానికి నేను మీ దృష్టిని కొంచెం ఎక్కువగా ఆకర్షించాలనుకుంటున్నాను.

పద్ధతికి పంపబడిన విలువలను సాధారణంగా పద్ధతికి పంపినప్పుడు వాటిని వాదనలు అంటారు.

మరొక ఉదాహరణ చూద్దాం:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

పద్ధతిని printLines మొదటిసారి పిలిచినప్పుడు, దాని పారామితులు క్రింది విలువలు కేటాయించబడ్డాయి:
String text = "Hi", int count = 10.

పద్ధతిని printLinesరెండవసారి పిలిచినప్పుడు, దాని పారామితులకు వేర్వేరు విలువలు కేటాయించబడ్డాయి:
String text = "Bye", int count = 20.

ఒక పద్ధతిని పిలిచినప్పుడు నిర్దిష్ట విలువలు కేటాయించబడే వేరియబుల్స్ కంటే పారామితులు ఎక్కువ మరియు తక్కువ కాదు. విలువలు "Hi", "Bye", 10మరియు 20వాటినే వాదనలు అంటారు."

3. ఒక పద్ధతికి కాల్ చేస్తున్నప్పుడు వైరుధ్యమైన వేరియబుల్ పేర్లు

వేరియబుల్స్‌ను మెథడ్ ఆర్గ్యుమెంట్‌లుగా ఉపయోగించవచ్చు. ఇది సరళమైనది మరియు అర్థమయ్యేలా ఉంది, కానీ ఇది కొన్ని ఇబ్బందులను కలిగిస్తుంది. అదే ఉదాహరణకి తిరిగి వెళ్దాం, కానీ ఈసారి మేము ఆర్గ్యుమెంట్‌లను ప్రత్యేక వేరియబుల్స్‌లోకి తరలిస్తాము:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

ఇప్పటివరకు, చాలా బాగుంది: మనకు strవేరియబుల్ ఉంది. textపద్ధతిని పిలిచినప్పుడు దాని విలువ పరామితికి కేటాయించబడుతుంది . మాకు ఒక nవేరియబుల్ ఉంది. countపద్ధతిని పిలిచినప్పుడు దాని విలువ పరామితికి కేటాయించబడుతుంది ." ఇప్పటివరకు, ప్రతిదీ స్పష్టంగా ఉంది.

ఇప్పుడు మన వేరియబుల్స్‌ని ఈ పద్ధతిలో పేరు మార్చుకుందాం main:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

రెండు విషయాలపై శ్రద్ధ వహించండి

మొదటిది: మనకు వేర్వేరు పద్ధతులలో ఒకే పేరుతో వేరియబుల్స్ ఉన్నాయి. ఇవి వేర్వేరు వేరియబుల్స్ (మేము ఉద్దేశపూర్వకంగా వేర్వేరు రంగులను ఉపయోగించి వాటిని చిత్రీకరిస్తాము). ప్రతిదీ మునుపటి ఉదాహరణలో వలె పని చేస్తుంది, ఇక్కడ పద్ధతిలోని వేరియబుల్స్ mainపేరు పెట్టబడ్డాయి strమరియు n.

రెండవది: పద్ధతిని పిలిచినప్పుడు మాయాజాలం ఏమీ జరగదు. పారామితులకు ఆర్గ్యుమెంట్ విలువలు మాత్రమే కేటాయించబడతాయి. అవి సంఖ్యలు, స్ట్రింగ్‌లు, వేరియబుల్‌లు లేదా వ్యక్తీకరణలు అనే దానితో సంబంధం లేకుండా.

మేము ప్రధాన పద్ధతిలో వేరియబుల్స్ పేరు మార్చిన తర్వాత, ఏమీ మారలేదు. అవి ఇంతకుముందు వేర్వేరు పద్ధతులలో వేర్వేరు వేరియబుల్స్ , కాబట్టి అవి అలాగే ఉంటాయి. text మరియు వేరియబుల్స్ మధ్య మ్యాజిక్ కనెక్షన్ లేదు text .

4. పద్ధతులకు సూచనలను పాస్ చేయడం

మీరు మునుపటి పాఠం నుండి ప్రతిదీ అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను, ఎందుకంటే ఇప్పుడు మేము పాసింగ్ ఆర్గ్యుమెంట్‌లను పద్ధతులకు మళ్లీ చూడబోతున్నాము, మేము మాత్రమే లోతుగా డైవ్ చేస్తాము.

మీకు ఇప్పటికే తెలిసినట్లుగా, కొన్ని జావా వేరియబుల్స్ విలువలను నిల్వ చేయవు, బదులుగా ఒక సూచన, అంటే విలువలు ఉన్న మెమరీ బ్లాక్ యొక్క చిరునామా. ఈ విధంగా స్ట్రింగ్ వేరియబుల్స్ మరియు అర్రే వేరియబుల్స్ పని చేస్తాయి.

మీరు శ్రేణి వేరియబుల్‌కు మరొక అర్రే వేరియబుల్‌ను కేటాయించినప్పుడు, ఏమి జరుగుతుంది? అది నిజమే. రెండు వేరియబుల్స్ మెమరీలో ఒకే స్థలాన్ని సూచించడం ప్రారంభిస్తాయి:

మరియు ఈ వేరియబుల్స్‌లో ఒకటి మెథడ్ పారామీటర్ అయితే ఏమి జరుగుతుంది?

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

సరిగ్గా అదే జరుగుతుంది: data పరామితి వేరియబుల్ వలె మెమరీ యొక్క అదే ప్రాంతానికి సూచనను కలిగి ఉంటుంది months. పద్ధతిని పిలిచినప్పుడు, ఒక సాధారణ కేటాయింపు జరుగుతుంది: .data = months

మరియు రెండు వేరియబుల్స్ పూర్ణాంకాన్ని నిల్వ చేసే మెమరీ యొక్క ఒకే ప్రాంతాన్ని సూచిస్తాయి కాబట్టి, ఈ printArraySum పద్ధతి శ్రేణి నుండి విలువలను చదవడమే కాకుండా వాటిని మార్చగలదు!

ఉదాహరణకు, అదే విలువతో ద్విమితీయ శ్రేణిని నింపే మా స్వంత పద్ధతిని మనం వ్రాయవచ్చు. ఇది ఇలా కనిపించవచ్చు:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

5. అదే పేరుతో పద్ధతులు

ఇప్పుడు మరోసారి పద్ధతి పేర్లకు తిరిగి వెళ్దాం.

జావా ప్రమాణాలకు ఒకే తరగతిలోని అన్ని పద్ధతులు ప్రత్యేక పేర్లను కలిగి ఉండాలి. మరో మాటలో చెప్పాలంటే, ఒకే తరగతిలో ఒకేలా పేరున్న రెండు పద్ధతులను ప్రకటించడం అసాధ్యం.

సారూప్యత కోసం పద్ధతులను పోల్చినప్పుడు, పేర్లను మాత్రమే కాకుండా, పారామితుల రకాలు కూడా పరిగణనలోకి తీసుకోబడతాయి ! పారామితుల పేర్లు పరిగణనలోకి తీసుకోబడలేదని గమనించండి . ఉదాహరణలు:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

ఎందుకు కొన్ని పద్ధతులు ఒకేలా పరిగణించబడతాయి , మరికొన్ని భిన్నంగా ఉంటాయి ? మరియు ఒక పద్ధతి యొక్క ప్రత్యేకతను నిర్ణయించేటప్పుడు పారామీటర్ పేర్లు ఎందుకు పరిగణనలోకి తీసుకోబడవు?

ప్రత్యేకత ఎందుకు అవసరం? విషయం ఏమిటంటే, కంపైలర్ ప్రోగ్రామ్‌ను కంపైల్ చేసినప్పుడు, మీరు ఏ స్థలంలో కాల్ చేయాలనుకుంటున్నారో ఖచ్చితంగా తెలుసుకోవాలి.

ఉదాహరణకు, మీరు వ్రాస్తే , కంపైలర్ స్మార్ట్ మరియు మీరు పరామితితో ఇక్కడ పద్ధతిని కాల్ చేయాలనుకుంటున్నారని సులభంగా నిర్ధారించవచ్చు .System.out.println("Hi")println()String

కానీ మీరు వ్రాస్తే , కంపైలర్ పరామితితో పద్ధతికి కాల్‌ని చూస్తుంది .System.out.println(1.0)println()double

ఒక పద్ధతిని పిలిచినప్పుడు, కంపైలర్ ఆర్గ్యుమెంట్‌ల రకాలు పారామితుల రకాలతో సరిపోలుతుందని నిర్ధారిస్తుంది. ఇది వాదనల పేరును ఏ మాత్రం పట్టించుకోదు. జావాలో, కంపైలర్ ఏ పద్ధతిని కాల్ చేయాలో నిర్ణయించడంలో పారామీటర్ పేర్లు సహాయపడవు. మరియు ఒక పద్ధతి యొక్క ప్రత్యేకతను నిర్ణయించేటప్పుడు అవి ఎందుకు పరిగణనలోకి తీసుకోబడవు.

పద్ధతి పేరు మరియు దాని పారామితుల రకాలను పద్ధతి సంతకం అంటారు . ఉదాహరణకి,sum(int, int)

ప్రతి తరగతి తప్పనిసరిగా ప్రత్యేక పేర్లతో ఉన్న పద్ధతుల కంటే ప్రత్యేక సంతకాలతో కూడిన పద్ధతులను కలిగి ఉండాలి.