స్టాటిక్ పద్ధతులు

1. స్టాటిక్ పద్ధతులు

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

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

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

ఉదాహరణ:

public class DataInfo
{
   public int getValue()
   {
      return 100;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      System.out.println(DataInfo.getValue()); // This will generate an error!
   }
}

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

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

static Type name(parameters)
{
   method code
}

ఉదాహరణలు:

public class Solution
{
   public static void main(String args[])
   {
      test();
   }

   public static void test()
   {
      int d = 2/0;
   }
}

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

Type name = ClassName.methodName(arguments)

ఉదాహరణలు:

int x = Math.min(a, b);

int min(int a, int b)

Thread.sleep(200);

void sleep(long ms)

Path path = Path.of("c:\\readme.txt");

Path of(String str)

2. స్టాటిక్ vs సాధారణ (నాన్-స్టాటిక్) పద్ధతులు

స్టాటిక్ పద్ధతులు మరియు సాధారణ పద్ధతుల మధ్య తేడా ఏమిటి?

ఒక సాధారణ పద్ధతి ఒక సాధారణ వస్తువుకు (ఒక తరగతికి సంబంధించిన ఉదాహరణ) కట్టుబడి ఉంటుంది, అయితే స్థిర పద్ధతి కాదు. ఒక సాధారణ పద్ధతి దాని సందర్భంలో వేరియబుల్స్‌ని యాక్సెస్ చేయగలదు, కానీ స్టాటిక్ పద్ధతి కాదు: దీనికి అనుబంధిత ఉదాహరణ లేదు.

రెండు రకాల పద్ధతుల మధ్య తేడాలు క్రింది పట్టికలో వ్యక్తీకరించబడ్డాయి:

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

ముందుగా, స్టాటిక్ మెథడ్స్ మరియు వేరియబుల్స్‌ని యాక్సెస్ చేయడానికి మీరు ఏ ఆబ్జెక్ట్ రిఫరెన్స్‌ను పాస్ చేయాల్సిన అవసరం లేదు.

రెండవది, కొన్నిసార్లు మీరు వేరియబుల్ యొక్క ఒకే ఒక్క ఉదాహరణ మాత్రమే ఉండాలి. ఉదాహరణకు, System.out( సిస్టమ్ క్లాస్ స్టాటిక్ అవుట్ వేరియబుల్ ).

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

తరగతి యొక్క ఉదాహరణకి కట్టుబడి ఉంది

ఒక సాధారణ పద్ధతిని పిలిచినప్పుడు, ఒక వాదన - పద్ధతి అని పిలువబడే వస్తువు - దానికి పరోక్షంగా పంపబడుతుంది. ఈ పరామితిని అంటారు this. ఈ అవ్యక్త పరామితి (పద్ధతి అని పిలువబడే వస్తువుకు సూచన) స్థిరమైన వాటి నుండి సాధారణ పద్ధతులను వేరు చేస్తుంది.

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

తరగతి యొక్క సాధారణ పద్ధతులను కాల్ చేయవచ్చు

ఒక సాధారణ పద్ధతి ఎల్లప్పుడూ అవ్యక్త thisపరామితిని కలిగి ఉంటుంది, కాబట్టి మీరు ఎల్లప్పుడూ పద్ధతిని పిలిచే వస్తువుకు సూచనను కలిగి ఉంటారు. మీరు మరొక సాధారణ పద్ధతిలో ఒక సాధారణ పద్ధతిని పిలిచినప్పుడల్లా, thisఆ కాల్ చేయడానికి అవ్యక్త పరామితి ఉపయోగించబడుతుంది. ఉదాహరణ

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = min(a, b);
   return min(t, c);
}

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = this.min(a, b);
   return this.min(t, c);
}

అందుకే మీరు స్టాటిక్ నుండి సాధారణ పద్ధతిని పిలవలేరు. thisస్టాటిక్ పద్ధతిలో పేరు పెట్టబడిన అవ్యక్త వేరియబుల్ లేదు .

లేదా మరొక పరిస్థితిని ఊహించుకోండి: మా ప్రోగ్రామ్‌లో మా తరగతికి చెందిన ఒక్క వస్తువు కూడా ఇంకా సృష్టించబడలేదు. మేము మా తరగతి యొక్క స్టాటిక్ పద్ధతిని పిలవవచ్చా? అవును. మరియు ఈ స్టాటిక్ పద్ధతిని సాధారణ (నాన్-స్టాటిక్) పద్ధతిని పిలవవచ్చా?

సరే, మనం దానిని ఏ వస్తువుపై పిలుస్తాము? అన్నింటికంటే, మా తరగతికి సంబంధించిన ఒక్క ఉదాహరణ కూడా ఇంకా లేదు!

తరగతి యొక్క స్టాటిక్ పద్ధతులను కాల్ చేయవచ్చు

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

తరగతి యొక్క సాధారణ వేరియబుల్స్‌ని యాక్సెస్ చేయవచ్చు

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

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

ఫలితంగా, స్టాటిక్ పద్ధతులు తరగతి యొక్క సాధారణ వేరియబుల్‌లను యాక్సెస్ చేయలేవు.

స్టాటిక్ పద్ధతి ఒక సాధారణ పద్ధతి అని అనుకుందాం. ఆ సాధారణ పద్ధతిని ఏ వస్తువుపై పిలవాలి?

ఎవరికీ తెలియదు! అందుకే మీరు ఆబ్జెక్ట్‌కి రిఫరెన్స్‌లో పాస్ చేయకుండా స్టాటిక్ నుండి సాధారణ పద్ధతిని పిలవలేరు !

క్లాస్ యొక్క స్టాటిక్ వేరియబుల్స్‌ని యాక్సెస్ చేయవచ్చు

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

ఒక వస్తువుపై పిలవవచ్చు

స్థిరమైన మరియు సాధారణ పద్ధతులు రెండింటినీ ఒక వస్తువుపై పిలుస్తారు. ఒక సాధారణ పద్ధతి కాల్ సాధ్యం - నిజానికి, సాధారణ పద్ధతిని పిలవడానికి ఇది ఏకైక మార్గం. ఒక వస్తువుపై స్టాటిక్ పద్ధతిని కూడా పిలుస్తారు: ఈ సందర్భంలో కంపైలర్ స్వయంగా వేరియబుల్ రకాన్ని నిర్ణయిస్తుంది మరియు దాని రకాన్ని బట్టి స్టాటిక్ పద్ధతిని పిలుస్తుంది:

Thread th = Thread.current();
th.sleep(1000);

Thread th = Thread.current();
Thread.sleep(1000);

Integer i = 1;
int x = i.parseInt("12");

Integer i = 1;
int x = Integer.parseInt("12");

"".valueOf(12);

String.valueOf(12);

తరగతికి పిలవవచ్చు

మీరు క్లాస్‌లో స్టాటిక్ పద్ధతిని మాత్రమే కాల్ చేయవచ్చు. సాధారణ పద్ధతిని కాల్ చేయడానికి, మీకు తరగతి యొక్క ఉదాహరణకి సూచన అవసరం. అందువల్ల, మీరు ఈ నిర్మాణాన్ని ఉపయోగించి సాధారణ పద్ధతిని పిలవలేరు:ClassName.methodName(arguments)