మీ స్వంత పద్ధతులను సృష్టించడం మరియు వాదనలను ఆమోదించడం

1. జావాలో విధులు/పద్ధతులు

మీరు ఇప్పటికే చాలా జావా ఆదేశాలను నేర్చుకున్నారు, అంటే మీరు చాలా క్లిష్టమైన ప్రోగ్రామ్‌లను వ్రాయవచ్చు. ప్రోగ్రామ్‌లో 10, 20, 30 లైన్ల కోడ్ చాలా పెద్ద ప్రోగ్రామ్ కాదు, సరియైనదా?

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

అవును, మరియు పద్ధతులు (లేదా విధులు) దీనికి మాకు సహాయపడతాయి.

ఒక పద్ధతి ఏమిటి? చాలా సరళంగా చెప్పాలంటే, ఒక పద్ధతి అనేది ప్రత్యేకమైన పేరును కలిగి ఉన్న ఆదేశాల సమూహం . మరో మాటలో చెప్పాలంటే, మేము అనేక కమాండ్‌లను ఒక సమూహంలో ఉంచాము మరియు దానికి ప్రత్యేకమైన పేరుని ఇస్తాము. మరియు అంతే - పద్ధతి సిద్ధంగా ఉంది.

ఉదాహరణ:

class Solution
{
   public static void main(String[] args)
   {
     System.out.print("Wi-");
     System.out.println("Fi");
     System.out.print("Wi-");
     System.out.println("Fi");

     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

class Solution
{
   public static void main(String[] args)
   {
     printWiFi();
     printWiFi();
     printWiFi();
   }
   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

ఎడమ కాలమ్‌లోని ప్రోగ్రామ్‌లో, మేము అదే కోడ్‌ను మూడుసార్లు పునరావృతం చేస్తాము - మేము ఒక పాయింట్‌ను వివరించడానికి ఉద్దేశపూర్వకంగా దీన్ని చేసాము. కానీ కుడి వైపున ఉన్న ప్రోగ్రామ్‌లో, మేము పునరావృతమయ్యే కోడ్‌ను ప్రత్యేక పద్ధతిలోకి తరలించాము మరియు దానికి ఒక ప్రత్యేక పేరు పెట్టాము — printWiFi.

మరియు మార్చబడిన కోడ్‌కు బదులుగా, మేము printWiFi()పద్ధతిని 3 సార్లు పిలుస్తాము.

కుడి వైపున ఉన్న కాలమ్‌లోని ప్రోగ్రామ్ రన్ చేయబడినప్పుడు, ప్రతిసారీ printWiFi()పద్ధతి అమలు చేయబడినప్పుడు, పద్ధతిలోని అన్ని ఆదేశాలు printWiFi()అమలు చేయబడతాయి. మేము ఇప్పుడే ఒక కొత్త కమాండ్ (పద్ధతి) సృష్టించాము, అనేక కమాండ్‌లను ఒకే సమూహంలో కలపడం.

ఏదైనా కోడ్‌ని ప్రత్యేక పద్ధతులుగా విభజించవచ్చు. విషయాలను సులభతరం చేయడానికి ఇది జరుగుతుంది: ఒక పెద్ద పద్ధతి కంటే చాలా చిన్న పద్ధతులను కలిగి ఉండటం మంచిది. మీరు మీ స్వంత పద్ధతులను వ్రాయకుండా మీ స్వంత ప్రోగ్రామ్‌లను వ్రాసిన సమయం ఎప్పుడైనా ఉందని మీరు త్వరలో ఆశ్చర్యపోతారు.

2. జావాలో ఒక పద్ధతిని ప్రకటించడం

కాబట్టి మీరు మీ పద్ధతిని సరిగ్గా ఎలా వ్రాయాలి?

public static void name()
{
  method body
}

ఒక పద్ధతిని ప్రకటించేటప్పుడు (సృష్టించేటప్పుడు) పరిగణించవలసిన సూక్ష్మ నైపుణ్యాలు పుష్కలంగా ఉన్నాయి, కానీ మేము ప్రాథమిక అంశాలతో ప్రారంభిస్తాము. మేము సరళమైన పద్ధతిని ఎలా ప్రకటించగలము? ఒక సాధారణ పద్ధతి ప్రకటన ఇలా కనిపిస్తుంది:

name పద్ధతి యొక్క ప్రత్యేక పేరు ఎక్కడ ఉంది మరియు method bodyపద్ధతిని రూపొందించే ఆదేశాలను సూచిస్తుంది. పదాల అర్థం public, staticమరియు voidతరువాత చర్చించబడుతుంది.

మేము ఒక పద్ధతిని సృష్టించిన తర్వాత, దానిని మన ఇతర పద్ధతులలో కాల్ చేయవచ్చు. పద్ధతి కాల్ ఇలా కనిపిస్తుంది:

name();

nameమనం కాల్ చేయాలనుకుంటున్న పద్ధతి యొక్క ప్రత్యేక పేరు ఎక్కడ ఉంది, అంటే మనం మెథడ్ కాల్ వద్దకు వచ్చినప్పుడు ఆ ఆదేశాలను అమలు చేయాలనుకుంటున్న పద్ధతి.

ప్రోగ్రామ్ మెథడ్ కాల్‌కు చేరుకున్నప్పుడు, అది కేవలం పద్ధతిలోకి అడుగు పెడుతుంది, దాని అన్ని ఆదేశాలను అమలు చేస్తుంది, అసలు పద్ధతికి తిరిగి వస్తుంది మరియు అమలును కొనసాగిస్తుంది.

మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, మేము ఇప్పటివరకు నేర్చుకున్న చాలా కమాండ్‌లు మన జీవితాన్ని సులభతరం చేయడానికి ఇతర ప్రోగ్రామర్లు వ్రాసిన పద్ధతులు మాత్రమే: , , మొదలైనవి.System.out.println()Thread.sleep()

ఒక పద్ధతి ఇతర పద్ధతులకు కాల్‌లను కలిగి ఉండవచ్చు:

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

   public static void printWiFi10Times()
   {
     for (int i = 0; i < 10; i++)
       printWiFi();
   }

   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

Wi-Fi

3. పద్ధతుల గురించి వాస్తవాలు

పద్ధతుల గురించి మరికొన్ని వాస్తవాలు ఇక్కడ ఉన్నాయి:

వాస్తవం 1. ఒక పద్ధతి ఎల్లప్పుడూ తరగతిలో భాగం.

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

వాస్తవం 2. ఒక పద్ధతి పేరుకు పవిత్రమైన అర్థం లేదు.

ఏ పద్ధతులను పిలిచినా పట్టింపు లేదు — అది దేనినీ ప్రభావితం చేయదు. ప్రధాన పద్ధతి అన్ని ఇతర మాదిరిగానే ఒక పద్ధతి. జావా మెషీన్ ప్రోగ్రామ్ యొక్క అమలును ప్రారంభించే పద్ధతికి ఈ పేరు ఎంపిక చేయబడింది. ఇందులో మాయాజాలం ఏమీ లేదు.

వాస్తవం 3. తరగతిలోని పద్ధతుల క్రమం పట్టింపు లేదు.

మీరు మీ పద్ధతులను ఏ క్రమంలోనైనా తరగతిలో వ్రాయవచ్చు - ఇది ప్రోగ్రామ్ యొక్క అమలును ఏ విధంగానూ ప్రభావితం చేయదు. ఉదాహరణ:

class Solution
{
   public static void printWiFi10Times()
   {
     for (int i = 0; i < 10; i++)
       printWiFi();
   }
   
   public static void main(String[] args)
   {
     printWiFi10Times();
   }

   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

class Solution
{
   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }

   public static void printWiFi10Times()
   {
     for (int i = 0; i < 10; i++)
       printWiFi();
   }
   public static void main(String[] args)
   {
     printWiFi10Times();
   }
}

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

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

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

4. పద్ధతి పేర్లు

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

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

సూత్రం 1. ఒక పద్ధతి పేరు పద్ధతి ఏమి చేస్తుందో క్లుప్తంగా వివరించాలి.

మీ కోడ్‌ని చదివే మరొక ప్రోగ్రామర్ కోడ్ ఏమి చేస్తుందో ఊహించడానికి పద్ధతి పేరుపై ఆధారపడవచ్చు. అతను లేదా ఆమె పిలిచే పద్ధతుల కోడ్‌ని ప్రతిసారీ చూడవలసిన అవసరం లేదు. మరియు పద్ధతుల ప్రయోజనం గుర్తుంచుకోవడం సులభం.

'ప్రోగ్రామ్‌ను నిద్రలోకి తీసుకురావడానికి' ఉపయోగించబడిందని మరియు 'తదుపరి పూర్ణాంకాన్ని చదవడానికి' ఉపయోగించబడిందని గుర్తుచేసుకోండి . అనుకూలమైనది, సరియైనదా?Thread.sleep()Scanner.nextInt()

సూత్రం 2. ఒక పద్ధతి పేరు బహుళ పదాలు కావచ్చు.

అయితే, దీన్ని చేసేటప్పుడు అనేక పరిమితులు ఉన్నాయి:

• మీరు పద్ధతి పేరులో ఖాళీలను కలిగి ఉండకూడదు: అన్ని పదాలు కలిసి వ్రాయబడతాయి.
• మొదటి పదం మినహా ప్రతి పదం క్యాపిటలైజ్ చేయబడింది.
• పద్ధతి పేరు ఎల్లప్పుడూ చిన్న అక్షరంతో ప్రారంభమవుతుంది

పద్ధతిని గుర్తుకు తెచ్చుకోండి printWiFi10Times. ఆ పేరుకి అర్థం ఏమిటి? "WiFi' పదాన్ని 10 సార్లు ప్రదర్శించు". మీరు పద్ధతి పేరుతో చాలా పదాలను చేర్చకూడదు: పేరు దాని సారాన్ని ప్రతిబింబించాలి.

పేరు పెట్టే పద్ధతులకు సంబంధించిన ఈ ప్రమాణాన్ని CamelCase అని పిలుస్తారు (పెద్ద అక్షరాలు ఒంటె యొక్క హంప్స్ లాగా ఉంటాయి).

సూత్రం 3. ఒక పద్ధతి పేరు క్రియతో ప్రారంభమవుతుంది.

ఒక పద్ధతి ఎల్లప్పుడూ ఏదో ఒకటి చేస్తుంది, కాబట్టి పద్ధతి పేరులోని మొదటి పదం ఎల్లప్పుడూ ఒక చర్య.

పద్ధతుల కోసం ఇక్కడ కొన్ని చెడ్డ పేర్లు ఉన్నాయి: home, cat, car, train, ...;

కొన్ని మంచి పేర్లు: run, execute, print, read, write...

సూత్రం 4. లాటిన్ అక్షరాలు మరియు సంఖ్యలను మాత్రమే ఉపయోగించండి.

జావా వివిధ భాషలకు అద్భుతమైన మద్దతును కలిగి ఉంది. మీరు రష్యన్ మరియు చైనీస్ భాషలలో వేరియబుల్స్, పద్ధతులు మరియు తరగతుల పేర్లను వ్రాయవచ్చు - ప్రతిదీ పని చేస్తుంది!

కానీ! System.out.println()పద్ధతి చైనీస్‌లో వ్రాసినట్లయితే , మీరు జావాను ఎంతకాలం అధ్యయనం చేయాలి ? ఇప్పుడు కంటే చాలా పొడవుగా ఉంది, సరియైనదా? అది మొదటి పాయింట్.

రెండవది, అనేక సాఫ్ట్‌వేర్ అభివృద్ధి బృందాలు అంతర్జాతీయంగా ఉన్నాయి. చాలా పెద్ద సంఖ్యలో జావా లైబ్రరీలను ప్రపంచం నలుమూలల నుండి ప్రోగ్రామర్లు ఉపయోగిస్తున్నారు.

అందువల్ల, పద్ధతి పేర్లలో లాటిన్ అక్షరాలు మరియు సంఖ్యలను మాత్రమే ఉపయోగించమని సిఫార్సు చేయబడింది.