"హాయ్ అమిగో! మీరు మీ స్వంత పద్ధతులను ఉపయోగించి టాస్క్‌లను పరిష్కరించడంలో ఆనందించారని మరియు పద్ధతులను రూపొందించడం ఎంత సౌకర్యవంతంగా ఉంటుందో మీరు గ్రహించారని నేను ఆశిస్తున్నాను. ఇప్పుడు అన్నింటికంటే ఆసక్తికరమైన అంశం గురించి మాట్లాడుకుందాం."

"మీరు నా ఆసక్తిని రేకెత్తించారు, డిగో... కొత్త టాపిక్?"

"మీకు ప్రతి అంశం కొత్తది, నా యంగ్ రోబోట్! మరియు ఇది మినహాయింపు కాదు. మరోసారి ఇది పద్ధతుల గురించి. మీరు బహుశా ఇప్పటికే గమనించి ఉండవచ్చు, అలాంటి పద్ధతుల నుండి మనం వాదనలను పద్ధతులకు పంపవచ్చు. ఒకసారి మేము పద్ధతిలో 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)
{
}
 పద్ధతి printపరామితితో ప్రకటించబడింది:
String str		 
public static void print(String str, int count)
{
}
 పద్ధతి printరెండు పారామితులతో ప్రకటించబడింది:
String str
int count		 
public static void write(int x, int y)
{
}
 పద్ధతి writeరెండు పారామితులతో ప్రకటించబడింది:
int x
int y

"ఆహ్... ఇప్పుడు స్పష్టంగా ఉంది. మరియు పద్ధతికి పారామీటర్లు ఉండకూడదనుకుంటే, కుండలీకరణాలను ఖాళీగా ఉంచుతాము."

"సరిగ్గా. ప్రాథమికంగా, పారామితులు ఒక పద్ధతిలో ప్రత్యేక వేరియబుల్స్. వాటి సహాయంతో, మీరు దానిని పిలిచినప్పుడు పద్ధతికి వివిధ విలువలను పంపవచ్చు. మరియు మీరు విలువలను పాస్ చేయనవసరం లేకపోతే, మీరు కుండలీకరణాలను ఖాళీగా ఉంచుతారు.

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

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

"మీరు ప్రదర్శించాల్సిన స్ట్రింగ్‌ను ఎలా పేర్కొంటారు? మరియు ప్రదర్శించబడే పంక్తుల సంఖ్యను మీరు ఎలా పేర్కొంటారు? మీరు ఊహించగలరా?"

Java university

"విషయాలు స్పష్టంగా మారడం ప్రారంభించాయి ... బహుశా పద్ధతి పారామితుల సహాయంతో?"

"సరిగ్గా. టెక్స్ట్ లైన్ కోసం స్ట్రింగ్ పారామీటర్ మరియు ప్రదర్శించబడే పంక్తుల సంఖ్య కోసం సంఖ్యా పరామితి. దీన్ని చేసే కోడ్ ఇలా ఉంటుంది:

కోడ్ వివరణ 
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, int count

పద్ధతి స్ట్రింగ్ text countసమయాలను ప్రదర్శిస్తుంది మేము వివిధ పారామితులతో పద్ధతిని



పిలుస్తాముprintLines

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

వాదనలు

"పారామీటర్‌లను కలిగి ఉన్న కాలింగ్ పద్ధతులపై మీరు ప్రత్యేక శ్రద్ధ వహించాలని నేను కోరుకుంటున్నాను. పద్ధతికి పంపబడిన విలువలను సాధారణంగా పద్ధతికి పంపినప్పుడు వాటిని వాదనలు అంటారు.

మన ఉదాహరణను మరొకసారి పరిశీలిద్దాం:

కోడ్ వివరణ 
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, int count

పద్ధతి స్ట్రింగ్ text countసమయాలను ప్రదర్శిస్తుంది మేము ఈ క్రింది వాదనలతో పద్ధతిని


పిలుస్తాము :printLines
text = "Hi"; count = 10;
text = "Bye"; count = 20;

" printLinesమొదటిసారి పద్ధతిని పిలిచినప్పుడు, దాని పారామితులకు ఈ క్రింది విలువలు కేటాయించబడ్డాయి:

String text = "Hi", int count = 10.

" printLinesపద్ధతిని రెండవసారి పిలిచినప్పుడు, దాని పారామితులకు వేర్వేరు విలువలు కేటాయించబడ్డాయి:

String text = "Bye", int count = 20.

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

"నేను తేడాను గుర్తుంచుకోవడానికి ప్రయత్నిస్తాను మరియు ఈ భావనలను గందరగోళానికి గురిచేయకూడదు."

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

"మీరు ఒక పద్ధతిని పిలిచినప్పుడు, మీరు వేరియబుల్స్‌ను ఆర్గ్యుమెంట్‌లుగా ఉపయోగించవచ్చు.

"అదే, అర్ధమే!"

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

కోడ్ వివరణ 
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";
     String n = 10;
     printLines(str, n);
   }
}
printLinesమేము ఈ క్రింది పారామితులతో పద్ధతిని ప్రకటించాము :
String text, int count

పద్ధతి స్ట్రింగ్ text countసమయాలను ప్రదర్శిస్తుంది మేము ఈ క్రింది వాదనలతో పద్ధతిని



పిలుస్తాము :printLines
text = str;
count = n;

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

"మంచిది, బాగుంది. ఇప్పుడు మన వేరియబుల్స్‌ని పద్ధతిలో పేరు మార్చుకుందాం 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";
     String count = 10;
     printLines(text, count);
   }
}
printLinesమేము ఈ క్రింది పారామితులతో పద్ధతిని ప్రకటించాము :
String text, int count

పద్ధతి స్ట్రింగ్ text countసమయాలను ప్రదర్శిస్తుంది మేము ఈ క్రింది వాదనలతో పద్ధతిని



పిలుస్తాము :printLines
text = text;
count = count;

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

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

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

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

"ఇప్పుడు నాకు తెలుసు."

పద్ధతులకు సూచనలను పంపడం

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

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

"ఒక డెవలపర్ ఒక అర్రే వేరియబుల్‌కి మరొక అర్రే వేరియబుల్‌ను కేటాయించినప్పుడు, ఏమి జరుగుతుంది?"

"అప్పుడు వారు అదే చిరునామాను సూచిస్తారా?"

"సరైనది. రెండు వేరియబుల్స్ మెమరీలో ఒకే స్థలాన్ని సూచించడం ప్రారంభిస్తాయి:

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

కోడ్ వివరణ 
class Solution
{
   public static void sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

ఈ sumపద్ధతి ఆమోదించబడిన శ్రేణిలోని సంఖ్యల మొత్తాన్ని గణిస్తుంది మరియు దానిని స్క్రీన్‌పై ప్రదర్శిస్తుంది

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

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

"నేను అర్థం చేసుకున్నాను, కానీ నాకు మరిన్ని ఉదాహరణలు కావాలి!"

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

కోడ్ వివరణ 
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);
   }
}

ఈ fill పద్ధతి ఆమోదించబడిన ద్విమితీయ శ్రేణిలోని ప్రతి సెల్‌పై పునరావృతమవుతుంది మరియు valueవాటికి కేటాయించబడుతుంది.






మేము రెండు డైమెన్షనల్ శ్రేణిని సృష్టిస్తాము.
మేము మొత్తం శ్రేణిని సంఖ్యతో నింపుతాము 8.

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

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

"పేర్ల గురించి ఇంకా ఏమి చెప్పగలరో నేను ఊహించలేను!"

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

"కాబట్టి, ఒకే తరగతిలో ఒకేలా పేరున్న రెండు పద్ధతులను ప్రకటించడం అసాధ్యం?"

"ఇప్పుడు - చాలా శ్రద్ధ వహించండి! ఒక తరగతిలోని పద్ధతులు వాస్తవానికి ఒకే పేర్లను కలిగి ఉంటాయి! కానీ ఈ సందర్భంలో, అవి వేర్వేరు పారామితులను కలిగి ఉండాలి. మరో మాటలో చెప్పాలంటే, పద్ధతులు సారూప్యత కోసం పోల్చబడతాయి, పేర్లు మాత్రమే పరిగణనలోకి తీసుకోబడవు, కానీ కూడా పారామీటర్ల రకాలు _ _

కోడ్ వివరణ 
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()StringSystem.out.println(1.0)println()double

ఆహ్, ఇది పొందడం ప్రారంభించినట్లు కనిపిస్తోంది!

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

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

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

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

"బాగా చేసారు, అమిగో! మీరు ఈ పాఠాన్ని సంపూర్ణంగా సంగ్రహించారు. ఏదైనా అస్పష్టంగా ఉంటే, భయపడవద్దు. ఈ అంశం రెండు పనుల తర్వాత స్పష్టమవుతుంది."