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

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.

"అమిగో, మీరు ఇప్పటికే ఇక్కడ ఉన్నారా? మీరు ఇప్పటికే చాలా జావా కమాండ్‌లు నేర్చుకున్నారని నాకు తెలుసు. మీరు దాదాపు నా స్థాయికి చేరుకున్నారు!"

"అది నిజమేనా, డియెగో?"

"అఫ్ కోర్స్ కాదు, హ-హ. మీకు ఇంకా చాలా చదువులు మరియు నేర్చుకోవడం ఉంది. అయినప్పటికీ, మీకు ఇప్పటికే చాలా క్లిష్టమైన ప్రోగ్రామ్‌లు రాయడానికి తగినంతగా తెలుసు. ప్రోగ్రామ్‌లో 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()అమలు చేయబడతాయి. మేము ఇప్పుడే కొత్త కమాండ్‌ను (పద్ధతి) సృష్టించాము, అనేక కమాండ్‌లను ఒకే సమూహంగా కలుపుతాము.

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

"ప్రోగ్రామ్‌ను పద్ధతులుగా విభజించడం గొప్ప ఆలోచన.

"మీ స్వంత పద్ధతులను రూపొందించకుండా మీరు ప్రోగ్రామ్‌లను ఎలా వ్రాస్తారో త్వరలో మీరు ఆశ్చర్యంతో గుర్తుకు తెచ్చుకుంటారు."

"నేను వినడానికి సిద్ధంగా ఉన్నాను మరియు పద్ధతులు వ్రాయడానికి ప్రయత్నించాను! దీన్ని ఎలా చేయాలో నాకు చెప్పండి."

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

"మేము సరళమైన పద్ధతిని ఎలా ప్రకటించగలము? ఇక్కడ ఎలా ఉంది:

public static void name()
{
  method body
}

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

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

name();

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

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

"ఇప్పుడు, అమిగో, మీరు ఇప్పటికే నేర్చుకున్న ఆదేశాలను కొత్త కళ్లతో చూడండి. ఉదాహరణకు, . ఇది నిజంగా ఏమిటో గుర్తుకు వస్తుందా?"System.out.println()

"ఈ ఆదేశాలన్నీ ఇతర ప్రోగ్రామర్లు వ్రాసిన పద్ధతులు మాత్రమే అని మీరు చెబుతున్నారా?"

"అందరూ కాదు, చాలా మంది ఉన్నారు. అవును, సరిగ్గా! ఇతరులు మన జీవితాలను సులభతరం చేయడానికి వాటిని వ్రాసారు."

"అలా public static void main(String[] args)కూడా ఒక పద్దతి... ఇప్పుడు ఇంకేం అర్ధమైంది!"

"అయితే, ఇది జరుగుతుంది! ఇది ప్రోగ్రామింగ్! ఇది ప్రధాన పద్ధతి - ప్రోగ్రామ్ యొక్క ఆల్ఫా మరియు ఒమేగా - ఇతర పద్ధతులకు కాల్‌లను కలిగి ఉండవచ్చని తేలింది:

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");
   }
}

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

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

వాస్తవం 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. ఒక పద్ధతిలోని వేరియబుల్స్ ఇతర పద్ధతుల వేరియబుల్స్‌తో ఏ విధంగానూ సంబంధం కలిగి ఉండవు

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

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

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

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

"ఇది చాలా కష్టమని నేను ఎప్పుడూ అనుకోలేదు!"

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

"జావాలో, ఈ సూత్రాలను అనుసరించడం ఆచారం:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ఇప్పుడు కంటే చాలా పొడవుగా ఉంది, సరియైనదా? అది మొదటి పాయింట్.

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

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

ముఖ్యమైన:

పద్ధతి పేరు తప్పనిసరిగా అక్షరంతో ప్రారంభం కావాలి (అది సంఖ్యతో ప్రారంభం కాదు).

"ఇవన్నీ జావాలో పద్ధతి పేరు పెట్టడాన్ని నియంత్రించే ప్రాథమిక సూత్రాలు. పాఠం ఇప్పుడు ముగిసింది. టాస్క్‌లను పరిష్కరించండి!"

"నేను ఇప్పటికే నడుస్తున్నాను, డియెగో!"

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.