పద్ధతి ప్రకటన

హాయ్! ఫీల్డ్‌లు మరియు పద్ధతులతో మీ స్వంత తరగతులను సృష్టించడం గురించి మీకు ఇప్పటికే తెలుసు. ఇప్పుడు మేము పద్ధతులపై నివసిస్తాము. వాస్తవానికి, మేము దీన్ని మా పాఠాలలో ఒకటి కంటే ఎక్కువసార్లు చేసాము, కానీ మేము ప్రధానంగా సాధారణ విషయాలను కవర్ చేసాము. ఈ రోజు, మేము పద్ధతులను విడదీయబోతున్నాము మరియు అవి దేనితో తయారు చేయబడ్డాయి, వాటిని సృష్టించడానికి వివిధ మార్గాలు మరియు వాటన్నింటినీ ఎలా నిర్వహించాలో అధ్యయనం చేస్తాము. :) వెళ్దాం!

పద్ధతి ప్రకటన

పద్ధతిని నిర్వచించే అన్ని కోడ్‌లను పద్ధతి డిక్లరేషన్ అంటారు . పద్ధతి ప్రకటన యొక్క సాధారణ రూపాన్ని ఈ క్రింది విధంగా వివరించవచ్చు:

access modifier, return type, method name (parameter list) {
    // method body
}

ఉదాహరణలుగా, తరగతి యొక్క వివిధ పద్ధతుల ప్రకటనలను పరిశీలించండి Dog.

public class Dog {

   String name;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {
       Dog max = new Dog("Max");
       max.woof();

   }

   public void woof() {
       System.out.println("A dog named " + name + " says \"Woof, woof!\"");
   }

   public void run(int distanceInFeet) {
       System.out.println("A dog named " + name + " ran " + distanceInFeet + " feet!");
   }

   public String getName() {
       return name;
   }
}

1. యాక్సెస్ మాడిఫైయర్

యాక్సెస్ మాడిఫైయర్ ఎల్లప్పుడూ ముందుగా సూచించబడుతుంది. తరగతి యొక్క అన్ని పద్ధతులు పబ్లిక్Dog మాడిఫైయర్‌తో గుర్తించబడ్డాయి . దీని అర్థం మనం వారిని ఏ ఇతర తరగతి నుండి అయినా పిలవవచ్చు:

public class Main {

   public static void main(String[] args) {

       Dog butch = new Dog("Butch");
       butch.run(100);
   }

}

మీరు చూడగలిగినట్లుగా, Dogతరగతి యొక్క పద్ధతులు తరగతిలో సులభంగా యాక్సెస్ చేయబడతాయి Main. పబ్లిక్ మాడిఫైయర్ వల్ల ఇది సాధ్యమైంది . జావాలో, ఇతర మాడిఫైయర్‌లు ఉన్నాయి. అవన్నీ ఇతర తరగతులలో పద్ధతులను ఉపయోగించడానికి అనుమతించవు. మేము వాటి గురించి ఇతర పాఠాలలో మాట్లాడుతాము. గుర్తుంచుకోవలసిన ప్రధాన విషయం ఏమిటంటే, మాడిఫైయర్ బాధ్యత వహించేది: ఇతర తరగతులలో ఒక పద్ధతి అందుబాటులో ఉందా :)

2. స్టాటిక్ కీవర్డ్

పద్ధతుల్లో ఒకటి Dog, , స్టాటిక్main() కీవర్డ్‌తో గుర్తించబడింది . ఇది పద్ధతి ప్రకటనలో భాగం, మరియు దాని అర్థం మాకు ఇప్పటికే తెలుసు. పాఠం ప్రారంభంలో ఇచ్చిన మెథడ్ డిక్లరేషన్ టెంప్లేట్‌లో మేము దానిని పేర్కొనలేదు, ఎందుకంటే ఇది ఐచ్ఛికం. అది పేర్కొనబడితే, అది తప్పనిసరిగా యాక్సెస్ మాడిఫైయర్ తర్వాత రావాలి. ఇటీవలి పాఠాలలో మనం స్టాటిక్ (క్లాస్) వేరియబుల్స్ గురించి మాట్లాడినట్లు గుర్తుందా? పద్ధతులకు వర్తింపజేసినప్పుడు, ఈ కీవర్డ్ దాదాపు అదే అర్థాన్ని కలిగి ఉంటుంది. ఒక పద్ధతి స్థిరంగా ఉంటే , అది తరగతి యొక్క నిర్దిష్ట వస్తువుకు సూచన లేకుండా ఉపయోగించబడుతుంది. మరియు నిజానికి, స్టాటిక్ పద్ధతిని అమలు చేయడానికి మీకు వస్తువు అవసరం లేదుDogmain()Dogతరగతి. ఇది ఒకటి లేకుండా బాగా నడుస్తుంది. ఈ పద్ధతి స్థిరంగా లేకుంటే, దాన్ని అమలు చేయడానికి మనం మొదట ఒక వస్తువును సృష్టించాలి.

3. రిటర్న్ విలువ

మా పద్ధతి ఏదైనా తిరిగి ఇవ్వాలంటే, మేము రిటర్న్ విలువ యొక్క రకాన్ని నిర్దేశిస్తాము. పొందేవారి ఉదాహరణ నుండి ఇది స్పష్టంగా కనిపిస్తుంది getName():

public String getName() {
   return name;
}

ఇది ఒక Stringవస్తువును తిరిగి ఇస్తుంది. ఒక పద్ధతి ఏదైనా తిరిగి ఇవ్వకపోతే, పద్ధతిలో వలె కీవర్డ్ శూన్యత ఉపయోగించబడుతుంది woof():

public void woof() {
   System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}

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

మేము ఒక పద్ధతిని పిలవడానికి అనేక విభిన్న మార్గాలను కోరుకునే సందర్భాలు ఉన్నాయి. మన స్వంత కృత్రిమ మేధస్సును ఎందుకు సృష్టించకూడదు? అమెజాన్‌లో అలెక్సా ఉంది, యాపిల్‌లో సిరి ఉంది, కాబట్టి మనకు ఎందుకు ఉండకూడదు? :) ఐరన్ మ్యాన్ చిత్రంలో, టోనీ స్టార్క్ తన స్వంత అద్భుతమైన కృత్రిమ మేధస్సును సృష్టించాడు, జార్విస్. ఆ అద్భుతమైన పాత్రకు నివాళులర్పిద్దాం మరియు అతని గౌరవార్థం మన AIకి పేరు పెడదాం. :) మనం చేయవలసిన మొదటి పని ఏమిటంటే, గదిలోకి ప్రవేశించే వ్యక్తులకు జార్విస్‌కి హలో చెప్పడం నేర్పడం (అంత అద్భుతమైన తెలివితేటలు అసభ్యకరంగా మారితే అది విచిత్రంగా ఉంటుంది).

public class Jarvis {

   public void sayHi(String name) {
       System.out.println("Good evening, " + name + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
   }
}

కన్సోల్ అవుట్‌పుట్: శుభ సాయంత్రం, టోనీ స్టార్క్. మీరు ఎలా ఉన్నారు? చాలా బాగుంది! జార్విస్ ఇప్పుడు అతిథులను స్వాగతించగలుగుతున్నారు. వాస్తవానికి, ఇది అతని మాస్టర్ టోనీ స్టార్క్ కంటే తరచుగా ఉంటుంది. కానీ ఒక్కడే రాకపోతే ఎలా! కానీ మా sayHi()పద్ధతి ఒక వాదనను మాత్రమే అంగీకరిస్తుంది. మరియు అది గదిలోకి ప్రవేశించిన ఒకరిని మాత్రమే పలకరించగలదు మరియు మరొకరిని విస్మరిస్తుంది. చాలా మర్యాదగా లేదు, అంగీకరించారా? :/ ఈ సందర్భంలో, మేము ఒకే పేరుతో 2 పద్ధతులను వ్రాయడం ద్వారా సమస్యను పరిష్కరించగలము, కానీ విభిన్న పారామితులతో:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

}

దీనిని మెథడ్ ఓవర్‌లోడింగ్ అంటారు . ఓవర్‌లోడింగ్ పద్ధతి మా ప్రోగ్రామ్‌ను మరింత సరళంగా మరియు వివిధ రకాల పని విధానాలకు అనుగుణంగా అనుమతిస్తుంది. ఇది ఎలా పని చేస్తుందో సమీక్షిద్దాం:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

కన్సోల్ అవుట్‌పుట్: శుభ సాయంత్రం, టోనీ స్టార్క్. మీరు ఎలా ఉన్నారు? శుభ సాయంత్రం, టోనీ స్టార్క్ మరియు కెప్టెన్ అమెరికా. మీరు ఎలా ఉన్నారు? అద్భుతమైన, రెండు వెర్షన్లు పని చేశాయి. :) కానీ మేము సమస్యను పరిష్కరించలేదు! ముగ్గురు అతిథులు ఉంటే? మేము, వాస్తవానికి, sayHi()పద్ధతిని మళ్లీ ఓవర్‌లోడ్ చేయగలము, తద్వారా ఇది మూడు అతిథి పేర్లను అంగీకరిస్తుంది. కానీ 4 లేదా 5 ఉండవచ్చు. అనంతం వరకు. sayHi()పద్ధతిని మిలియన్ సార్లు ఓవర్‌లోడ్ చేయకుండా, ఎన్ని పేర్లనైనా నిర్వహించడానికి జార్విస్‌కు నేర్పించడానికి మెరుగైన మార్గం లేదా ? :/ అయితే ఉంది! లేకపోతే, జావా ప్రపంచంలోనే అత్యంత ప్రజాదరణ పొందిన ప్రోగ్రామింగ్ భాష అని మీరు అనుకుంటున్నారా? ;)

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       System.out.println();
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

( స్ట్రింగ్... పేర్లు ) పారామీటర్‌గా ఉపయోగించినప్పుడు, స్ట్రింగ్‌ల సేకరణ పద్ధతికి పంపబడుతుందని సూచిస్తుంది. ఎన్ని ఉంటాయో మేము ముందుగా పేర్కొనవలసిన అవసరం లేదు, కాబట్టి ఇప్పుడు మా పద్ధతి మరింత సరళమైనది:

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
   }
}

కన్సోల్ అవుట్‌పుట్: శుభ సాయంత్రం, టోనీ స్టార్క్. మీరు ఎలా ఉన్నారు? శుభ సాయంత్రం, కెప్టెన్ అమెరికా. మీరు ఎలా ఉన్నారు? శుభ సాయంత్రం, బ్లాక్ విడో. మీరు ఎలా ఉన్నారు? శుభ సాయంత్రం, హల్క్. మీరు ఎలా ఉన్నారు? పద్ధతి లోపల, మేము అన్ని ఆర్గ్యుమెంట్‌లను పునరావృతం చేస్తాము మరియు పేర్లతో ఫార్మాట్ చేయబడిన పదబంధాలను ప్రదర్శిస్తాము. ఇక్కడ మేము సరళీకృత for-eachలూప్‌ను ఉపయోగిస్తాము (ఇది మీరు ఇంతకు ముందు చూసినది). ఇది ఇక్కడ ఖచ్చితంగా ఉంది, ఎందుకంటే ( స్ట్రింగ్... పేర్లు ) సంజ్ఞామానం వాస్తవానికి కంపైలర్ ఆమోదించిన అన్ని ఆర్గ్యుమెంట్‌లను శ్రేణిలో ఉంచుతుంది. ఫలితంగా, మేము వేరియబుల్ పేర్లతో పని చేయవచ్చుమేము లూప్‌లో మళ్ళించడం ద్వారా సహా, శ్రేణితో పని చేస్తాము. అదనంగా, ఇది ఎన్ని పాస్ చేసిన స్ట్రింగ్‌లతో అయినా పని చేస్తుంది! ఇద్దరు, పది, వెయ్యి కూడా - ఈ పద్ధతి ఎంత మంది అతిథులతోనైనా సరిగ్గా పని చేస్తుంది. అన్ని అవకాశాల కోసం పద్ధతిని ఓవర్‌లోడ్ చేయడం కంటే చాలా సౌకర్యవంతంగా ఉంటుంది, మీరు అనుకోలేదా? :) ఇక్కడ పద్ధతి ఓవర్‌లోడింగ్‌కు మరొక ఉదాహరణ ఉంది. జార్విస్‌కు ఒక పద్ధతి ఇద్దాం printInfoFromDatabase(). ఇది డేటాబేస్ నుండి ఒక వ్యక్తి గురించిన సమాచారాన్ని ప్రదర్శిస్తుంది. ఒక వ్యక్తి సూపర్ హీరో లేదా సూపర్‌విలన్ అని డేటాబేస్ సూచిస్తే, మేము ఆ సమాచారాన్ని ప్రదర్శిస్తాము:

public class Jarvis {

   public void printInfoFromDatabase (String bio) {

       System.out.println(bio);
   }

   public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {

       System.out.println(bio);
       if (!isEvil) {
           System.out.println("Also known as the superhero " + nickname);
       } else {
           System.out.println("Also known as the supervillain " + nickname);
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.printInfoFromDatabase("Laura Palmer. Date of birth: July 22, 1972. Twin Peaks, Washington");
       System.out.println();
       jarvis.printInfoFromDatabase("Max Eisenhardt. Height: 15.6 ft. Weight: 189 lbs. ", true, "Magneto");
   }
}

అవుట్‌పుట్: లారా పాల్మెర్. పుట్టిన తేదీ: జూలై 22, 1972. ట్విన్ పీక్స్, వాషింగ్టన్ మాక్స్ ఐసెన్‌హార్డ్ట్. ఎత్తు: 15.6 అడుగులు. బరువు: 189 పౌండ్లు. సూపర్‌విలన్ మాగ్నెటో అని కూడా పిలుస్తారు కాబట్టి, మన పద్ధతి యొక్క ప్రవర్తన మనం దానికి పంపే డేటాపై ఆధారపడి ఉంటుంది. ఇక్కడ మరొక ముఖ్యమైన విషయం ఉంది: వాదనల క్రమం ముఖ్యమైనది! మా పద్ధతి ఒక స్ట్రింగ్ మరియు సంఖ్యను తీసుకుంటుందని చెప్పండి:

public class Person {

   public static void sayYourAge(String greeting, int age) {
       System.out.println(greeting + " " + age);
   }

   public static void main(String[] args) {

       sayYourAge("My age is ", 33);
       sayYourAge(33, "My age is "); // Error!
   }
}

Personక్లాస్ యొక్క పద్ధతి ఒక స్ట్రింగ్ మరియు ఒక సంఖ్యను ఇన్‌పుట్‌గా తీసుకుంటే sayYourAge(), ఈ ఆర్గ్యుమెంట్‌లు తప్పనిసరిగా పద్ధతికి పంపబడాలి! మేము వాటిని వేరే క్రమంలో పాస్ చేస్తే, కంపైలర్ లోపాన్ని సృష్టిస్తుంది మరియు వ్యక్తి తన వయస్సును చెప్పలేరు. మార్గం ద్వారా, మేము గత పాఠంలో కవర్ చేసిన కన్స్ట్రక్టర్లు కూడా పద్ధతులు! మీరు వాటిని కూడా ఓవర్‌లోడ్ చేయవచ్చు (అంటే వివిధ సెట్ల పారామితులతో అనేక కన్‌స్ట్రక్టర్‌లను సృష్టించండి) మరియు ఆమోదించిన ఆర్గ్యుమెంట్‌ల క్రమం వారికి కూడా ప్రాథమికంగా ముఖ్యమైనది. అవి నిజమైన పద్ధతులు! :)

సారూప్య పారామితులతో పద్ధతులను ఎలా ప్రారంభించాలి

మీకు తెలిసినట్లుగా, nullజావాలో కీలకపదం. ఇది nullవస్తువు లేదా డేటా రకం కాదని అర్థం చేసుకోవడం చాలా ముఖ్యం . వ్యక్తి పేరు మరియు వయస్సును ప్రకటించే Personతరగతి మరియు పద్ధతిని కలిగి ఉన్నారని ఊహించండి . introduce()ఇంకా, వయస్సును టెక్స్ట్ లేదా సంఖ్యగా పాస్ చేయవచ్చు.

public class Person {

   public void introduce(String name, String age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person alex = new Person();
       alex.introduce ("Alex", "twenty-one");

       Person mary = new Person();
       mary.introduce("Mary", 32);
   }
}

ఓవర్‌లోడింగ్ గురించి మాకు ఇప్పటికే సుపరిచితం, కాబట్టి రెండు పద్దతులు కూడా తమ ప్రవర్తనకు అనుగుణంగా ఉంటాయని మాకు తెలుసు: నా పేరు అలెక్స్. నా వయసు ఇరవై ఒకటి నా పేరు మేరీ. నా వయస్సు 32null కానీ మనం స్ట్రింగ్ లేదా నంబర్‌కు బదులుగా రెండవ పారామీటర్‌గా పాస్ అయితే ఏమి జరుగుతుంది ?

public static void main(String[] args) {

   Person victor = new Person();
   victor.introduce("Victor", null);// Ambiguous method call!
}

మేము సంకలన దోషాన్ని పొందుతాము! దీనికి కారణం ఏమిటి మరియు "అస్పష్టత" అంటే ఏమిటి? నిజానికి, ఇదంతా చాలా సులభం. సమస్య ఏమిటంటే, మనకు పద్ధతి యొక్క రెండు వెర్షన్లు ఉన్నాయి: ఒకటి Stringరెండవ ఆర్గ్యుమెంట్‌గా మరియు మరొకటి Integerరెండవ ఆర్గ్యుమెంట్‌గా ఉంది. కానీ ఒక Stringమరియు ఒక Integerరెండూ కావచ్చు null! అవి రెఫరెన్స్ రకాలు కాబట్టి, nullరెండింటికీ డిఫాల్ట్ విలువ. అందుకే ఈ పరిస్థితిలో కంపైలర్ ఏ పద్ధతి యొక్క సంస్కరణను కాల్ చేయాలో గుర్తించలేరు. ఈ సమస్యకు పరిష్కారం చాలా సులభం. Nullనిర్దిష్ట సూచన రకానికి స్పష్టంగా మార్చవచ్చు. అందువల్ల, మీరు ఒక పద్ధతిని కాల్ చేసినప్పుడు, మీరు రెండవ ఆర్గ్యుమెంట్ కోసం మీకు కావలసిన డేటా రకాన్ని కుండలీకరణాల్లో సూచించవచ్చు! కంపైలర్ మీ "సూచన"ని అర్థం చేసుకుంటుంది మరియు సరైన పద్ధతిని పిలుస్తుంది:

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("Method with a string and a number!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", (String) null);
   }
}

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

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, int age) {
       System.out.println("Method with a string and a number!!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", null);
   }
}

ఎందుకు అని మీరు ఊహించగలరా? మీరు ఎందుకు ఊహించినట్లయితే, బాగా చేసారు! :) ఎందుకంటే ఆదిమానవులు ఉండకూడదు null. ఇప్పుడు కంపైలర్‌కు ఒకే ఎంపిక ఉంది, అంటే introduce()రెండు స్ట్రింగ్‌లతో పద్ధతిని కాల్ చేయడం. ఈ పద్ధతిని పిలిచిన ప్రతిసారీ అమలు చేసే పద్ధతి యొక్క సంస్కరణ ఇది.