జావాలో పద్ధతులు  



జావా

ఒక పద్ధతి ఏమిటి  

జావాలోని పద్ధతులు లేదా ఫంక్షన్ ఎగ్జిక్యూషన్ స్టేట్మెంట్స్ మరియు ఆపరేషన్లను కలిగి ఉన్న కోడ్ యొక్క బ్లాక్. ఇది మీ కోడ్ ఏమి చేయగలదో ప్రధానంగా వివరిస్తుంది. ఇది ఒక సంఖ్య యొక్క వర్గమూలాన్ని కనుగొనే sqrt (వర్గమూలం) వంటి గణిత విధిని పోలి ఉంటుంది. అదేవిధంగా జావాలో, నిర్దిష్ట కోడ్ ప్రవర్తనను వివరించే విధులు లేదా పద్ధతులను కలిగి ఉండవచ్చు. మేము ఎల్లప్పుడూ ఒక తరగతిలోనే పద్ధతులను వ్రాయాలి.

జావాలో పద్ధతుల యొక్క ప్రయోజనం  

  • రౌస్ సామర్థ్యం: నిర్దిష్ట ఫంక్షన్‌కు కాల్ చేయడం ద్వారా కోడ్‌ను తిరిగి ఉపయోగించుకోవడానికి పద్ధతులు మాకు అనుమతిస్తాయి. ఇది పునరావృత కోడ్ రాయకుండా నిరోధిస్తుంది మరియు పునర్వినియోగతను పెంచుతుంది.
  • చదవదగిన: మేము సంబంధిత చర్యలను ఒక పద్ధతిలో సమూహపరిచినందున ఇది కోడ్‌ను మరింత చదవగలిగేలా మరియు అర్థమయ్యేలా చేస్తుంది.
  • పోషించు: కోడ్‌ను సులభంగా నిర్వహించడానికి పద్ధతులు మాకు సహాయపడతాయి మరియు మార్పులు అవసరమైనప్పుడు దాన్ని సులభంగా రీఫ్యాక్టర్ చేయడానికి అనుమతిస్తాయి.

జావాలో పద్ధతుల రకాలు  

జావా రెండు రకాల తరగతి పద్ధతులకు మద్దతు ఇస్తుంది:

జావా పద్ధతులు

ప్రామాణిక లైబ్రరీ పద్ధతులు

ఇవి జావా లైబ్రరీలో ఉన్న ముందే నిర్వచించిన పద్ధతులు. మేము ఈ పద్ధతులను ఎటువంటి మార్పులు లేకుండా ఉపయోగించవచ్చు. ఉదాహరణకు, మనకు ఉంది ముద్రణ() యొక్క పద్ధతి వ్యవస్థ ఒక ప్రకటనను ముద్రించడానికి మాకు అనుమతించే తరగతి. దిగువ ఉదాహరణలో మీరు చూడగలిగినట్లుగా స్టేట్మెంట్ను ప్రింట్ చేయడానికి మేము ఈ పద్ధతిని నేరుగా ప్రారంభించవచ్చు.

public class StandardMethod {

  public static void main(String[] args) {
    System.out.println("This is a standard library method");

  }

}
This is a standard library method

వినియోగదారు నిర్వచించిన పద్ధతులు

మేము మా స్వంత ఫంక్షన్ లేదా పద్ధతిని సృష్టించినప్పుడు, మేము దానిని వినియోగదారు నిర్వచించిన పద్ధతి అని పిలుస్తాము. మేము ఒక ఫంక్షన్‌లో ఇలాంటి చర్యలను కలిసి సమూహపరచవచ్చు. ఉదాహరణకి, జోడించు () సంఖ్యలను జోడించే పద్ధతి. అందువల్ల ఒక పని లేదా కార్యాచరణను నిర్వచించడానికి పద్ధతులు ఉపయోగించబడతాయి.

ఇది కూడ చూడు
జావా సమ్మతి యుటిలిటీస్

తరువాత, జావాలో వినియోగదారు నిర్వచించిన పద్ధతులను ఎలా సృష్టించాలో మరియు ఎలా ప్రారంభించాలో చూద్దాం.

ఒక పద్ధతిని సృష్టించండి  

మేము ఎల్లప్పుడూ తరగతి లోపల ఒక పద్ధతిని సృష్టించాలి. ఒక పద్ధతి ఒక పద్ధతిని కలిగి ఉంటుంది పేరు తరువాత కుండలీకరణాలు().

క్రింద ఒక పద్ధతిని సృష్టించడానికి వాక్యనిర్మాణం ఉంది.

access_type return_type method_name(arguments) {
//method body
}

యాక్సెస్_టైప్: ఇది నిర్దేశిస్తుంది యాక్సెస్ మాడిఫైయర్ పబ్లిక్, ప్రైవేట్, రక్షిత వంటివి.

రిటర్న్_టైప్: పద్ధతి ఏదైనా విలువను తిరిగి ఇస్తుందో తెలుపుతుంది. ఇది శూన్యంగా ఉండవచ్చు (రిటర్న్ రకం లేదు) లేదా స్ట్రింగ్ లేదా పూర్ణాంకం వంటి రకాన్ని పేర్కొనండి

పద్ధతి_పేరు: పద్ధతి ప్రవర్తనకు సరిపోయే ఏదైనా చెల్లుబాటు అయ్యే పేరు

వాదనలు: ఆపరేషన్ చేయడానికి పద్ధతికి ఏదైనా పారామితులు లేదా వాదనలు అవసరమైతే. ఇది ఐచ్ఛికం.

పద్ధతి శరీరం: పద్ధతి యొక్క కార్యాచరణ

వినియోగదారు నిర్వచించిన పద్ధతిని సృష్టించడానికి క్రింద ఒక ఉదాహరణ. ఇక్కడ మేము ఒక పద్ధతిని సృష్టించాము జోడించడానికి ఇది ఉంది శూన్యమైన తిరిగి రకం మరియు ప్రజా యాక్సెస్ రకం. పద్ధతి బాడీ లోపల, మాకు ప్రింట్ స్టేట్మెంట్ ఉంది.

public class MethodExample {
  
  public void add() {
    System.out.println("Addition method");
  }

}

ఒక పద్ధతి యొక్క పేరు పెట్టడం  

  • పద్ధతి పేరు ఎల్లప్పుడూ చిన్న అక్షరాలతో మొదలవుతుంది
  • ఇది ఎల్లప్పుడూ క్రియగా ఉండాలి. ఉదా: జోడించు ()
  • పేరులో రెండు పదాలకు మించి ఉంటే, అది ఒక క్రియతో ప్రారంభించి, విశేషణం లేదా నామవాచకం ఉండాలి. ఉదా: getName ()
  • ఒక పద్ధతి పేరుకు బహుళ పదాలు ఉంటే, మొదటి పదం కాకుండా ఇతర పదాల మొదటి అక్షరం పెద్ద అక్షరంతో ప్రారంభం కావాలి. ఉదా: getAddressDetails ()

జావా పద్ధతిని ప్రారంభించండి  

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

method_name(arguments);

క్రింద ఒక పద్ధతిని ప్రారంభించడానికి ఒక సాధారణ ఉదాహరణ. పద్ధతులు ఒక తరగతిలో నిర్వచించబడినందున, మేము క్లాస్ ఉదాహరణను మాత్రమే ఉపయోగించడం ద్వారా పద్ధతిని ప్రారంభించవచ్చు. ఈ ఉదాహరణలో, జోడించడానికి పద్ధతి మరియు m తరగతి వస్తువు.

public class MethodExample {
  
  public void add() {
    System.out.println("Addition method");
  }
  
  public static void main(String[] args) {
    MethodExample m = new MethodExample();
    m.add();
  }

}
Addition method

పరామితి మరియు రిటర్న్ రకం లేని పద్ధతి  

దిగువ వాదనలు లేదా రిటర్న్ రకాలు లేని జావా పద్ధతికి ఉదాహరణ. పద్ధతి ఏ విలువను తిరిగి ఇవ్వనప్పుడు, మేము పేర్కొన్నాము శూన్యమైన కీవర్డ్ రిటర్న్ రకంగా. పద్ధతికి వాదనలు లేనప్పుడు, మేము దానిని ఖాళీ కుండలీకరణాలతో ప్రస్తావించాము.

ఇది కూడ చూడు
జావాలోని సెమాఫోర్

మేము పూర్ణాంక చరరాశులను ప్రారంభిస్తాము x, y కన్స్ట్రక్టర్ ఉపయోగించి, మరియు ఈ విలువను నేరుగా లోపల ఉపయోగించండి జోడించడానికి పద్ధతి. ఈ పద్ధతిలో పారామితులు లేవు మరియు తిరిగి వచ్చే రకం లేదు.

public class Addition {

  int x,y;
  Addition(int x, int y) {
    this.x = x;
    this.y = y;
  }
  
  public void add() {
    int sum = x + y;
    System.out.println("Sum is: " + sum);
  }
  public static void main(String[] args) {
    Addition a = new Addition(5,8);
    a.add();
  }

}
Sum is: 13

పారామితులతో పద్ధతి కానీ తిరిగి వచ్చే రకం లేదు  

దిగువ ఉదాహరణ పారామితులతో ఒక పద్ధతిని వివరిస్తుంది కాని ఏ విలువను ఇవ్వదు. పద్దతి తేడా పూర్ణాంక రకం రెండు పారామితులను అంగీకరిస్తుంది. అందువల్ల మేము పద్ధతిని పిలిచినప్పుడు, పద్ధతి లోపల పారామితి వేరియబుల్స్‌కు కేటాయించే పద్ధతికి విలువలను పాస్ చేయాలి. ఇక్కడ, x మరియు y పారామితులు వరుసగా 4 మరియు 5 విలువలను తీసుకుంటాయి.

public class Subtraction {
  
  public void difference(int x, int y) {
    int diff = x - y;
    System.out.println("Difference is: " + diff);
  }

  public static void main(String[] args) {
    Subtraction s = new Subtraction();
    s.difference(10, 4);
  }

}
Difference is: 6

క్లాస్ వేరియబుల్స్ మరియు పారామితి వేరియబుల్స్ మధ్య ఉన్న ప్రధాన వ్యత్యాసం ఏమిటంటే, క్లాస్ వేరియబుల్స్ మొత్తం క్లాస్‌లో ఉపయోగించబడతాయి, ఇక్కడ పారామితి వేరియబుల్స్ పద్ధతిలో మాత్రమే ఉపయోగించబడతాయి.

రిటర్న్ రకాన్ని కలిగి ఉన్న విధానం కాని పారామితులు లేవు  

దిగువ ఉదాహరణలో, పద్ధతి ఉత్పత్తి పూర్ణాంక రకం విలువను అందిస్తుంది. తిరిగి విలువను కలిగి ఉన్న ఏదైనా పద్ధతి ఉండాలి రిటర్న్ స్టేట్మెంట్ తిరిగి ఇవ్వవలసిన విలువతో. ఈ సందర్భంలో, వేరియబుల్ ఉత్పత్తి తిరిగి విలువ. అదేవిధంగా, రిటర్న్ రకంతో ఒక పద్ధతిని ప్రారంభించేటప్పుడు, ఫంక్షన్ అవుట్‌పుట్‌ను స్వీకరించే అదే రకమైన వేరియబుల్ మనకు ఉండాలి. అందువల్ల మేము ఉపయోగిస్తాము int prod = m.multiply().

public class Multiplication {

  int product,x, y;
  
  Multiplication(int x, int y) {
    this.x = x;
    this.y = y;
  }
  
  public int multiply() {
    product = x * y;
    return product;
  }
  public static void main(String[] args) {
    Multiplication m = new Multiplication(4,8);
    int prod = m.multiply();
    System.out.println("Product is: " + prod);
  }

}
Product is: 32

పరామితి మరియు రిటర్న్ రకంతో పద్ధతి  

ఈ ఉదాహరణలో, పద్ధతి ఎక్కువ సంఖ్య పారామితులు మరియు తిరిగి విలువ రెండింటినీ కలిగి ఉంది. అందువల్ల పద్ధతిని పిలిచేటప్పుడు, మేము వాదనలు పాస్ చేయాలి మరియు పద్ధతి నుండి తిరిగి విలువను కేటాయించడానికి వేరియబుల్ ఉండాలి. ఈ సందర్భంలో, x మరియు y విలువలు ఉన్నాయి 47 మరియు 29 వరుసగా మరియు వేరియబుల్ తిరిగి గరిష్టంగా పద్ధతి నుండి. పద్ధతిని ప్రారంభించేటప్పుడు, మనకు వేరియబుల్ ఉంది విలువ ఈ పద్ధతి యొక్క అవుట్పుట్ను అందుకుంటుంది.

public class Compare {

  int max;
  
  public int greaterNumber(int x, int y) {
    if(x > y)
      max = x;
    else
      max = y;
    
    return max;
  }
  public static void main(String[] args) {
    Compare c = new Compare();
    int value = c.greaterNumber(47, 29);
    System.out.println("Greater value is: " + value);
  }

}
Greater value is: 47

స్టాటిక్ జావా విధానం  

మేము చూశాము జావా స్టాటిక్ కీవర్డ్ ట్యుటోరియల్, మేము ఉపయోగించవచ్చు static పద్ధతుల కోసం కీవర్డ్. ఈ సందర్భంలో, స్టాటిక్ పద్ధతిని ప్రారంభించడానికి మాకు ఏ తరగతి వస్తువు అవసరం లేదు మరియు పద్ధతి పేరును ఉపయోగించి నేరుగా కాల్ చేయవచ్చు.

public class MethodExample {
  
  public static void add() {
    System.out.println("Addition method");
  }
  
  public static void main(String[] args) {
    add();
  }

}
Addition method

ఉదాహరణ పద్ధతులు  

ఉన్న పద్ధతులు non-static మరియు ఒక తరగతికి చెందినది అంటారు instance పద్ధతి. ఈ పద్ధతులకు ఫంక్షన్‌కు కాల్ చేయడానికి ఒక వస్తువు లేదా తరగతి ఉదాహరణ అవసరం. ఇది ఏ వస్తువు అవసరం లేని స్టాటిక్ పద్ధతులకు విరుద్ధంగా ఉంటుంది.

ఇది కూడ చూడు
జావాలో ListIterator

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

public class MethodExample {
  
  //Static method
  public static void add() {
    System.out.println("Addition method");
  }
  
  //Instance method
  public void subtract() {
    System.out.println("Subtraction method");
  }
  public static void main(String[] args) {
    MethodExample m = new MethodExample();
    
    //Invoking a static method
    add();
    
    //Invoking an instance method
    m.subtract();
  }

}

ఉదాహరణ పద్ధతుల రకాలు

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

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

ఉదాహరణ:

public class InstanceMethodDemo {
  
  private String name;
  
  //Getter method
  public String getName() {
    return name;
  }
  
  //Setter method
  public void setName(String name) {
    this.name = name;
  }

  public static void main(String[] args) {
    

  }

}

వియుక్త పద్ధతి  

ఒక నైరూప్య పద్ధతికి ఫంక్షన్ డిక్లరేషన్ మాత్రమే ఉంది మరియు నిర్వచనం లేదు. దీని అర్థం, ఇది ఒక పద్ధతి శరీరాన్ని కలిగి ఉండదు. సంగ్రహణను అమలు చేయడానికి మేము నైరూప్య పద్ధతులను ఉపయోగిస్తాము. వియుక్త తరగతిలో నైరూప్య పద్ధతులు ఉన్నాయి. నైరూప్య తరగతిని విస్తరించే తరగతి నైరూప్య పద్ధతి యొక్క కార్యాచరణను అమలు చేస్తుంది.

abstract class class_name
{
  //abstract method
  abstract void method_name();
}

 

సూచన