జావాలో ఒక పద్ధతిని ఎలా కాల్ చేయాలి

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

ఒక పద్ధతి అంటే ఏమిటి?

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

1. ఇది పద్ధతిలోని అన్ని కోడ్‌లను పూర్తి చేసి, దాని ముగింపుకు చేరుకుంటుంది.
2. ఇది రిటర్న్ స్టేట్‌మెంట్‌కు చేరుకుంటుంది.
3. ఇది మినహాయింపును విసురుతుంది.

పద్ధతులు ఎందుకు ఉపయోగించబడతాయి?

పద్ధతులు ఉపయోగించబడతాయి ఎందుకంటే అవి కోడ్‌ను మళ్లీ మళ్లీ మళ్లీ వ్రాయకుండా మళ్లీ ఉపయోగించేందుకు అనుమతిస్తాయి. పద్ధతులు టైమ్‌సేవర్‌లు మరియు కోడ్‌ను క్రమబద్ధంగా మరియు చదవగలిగేలా ఉంచుతాయి. ఇది బహుళ కోడర్‌లకు కోడ్‌ను అర్థమయ్యేలా చేస్తుంది. ఇది ప్రోగ్రామ్‌ను మాడ్యులరైజ్ చేయడంలో సహాయపడుతుంది. పద్ధతులు ఉపయోగించబడకపోతే ప్రోగ్రామ్ చాలా పొడవుగా మారుతుంది మరియు కోడ్‌ను పరీక్షించడం, డీబగ్ చేయడం లేదా నిర్వహించడం కష్టమవుతుంది.

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

public class Driver {

	public static void printName(String name) {

		System.out.println("Hi, I am " + name + "!");
	}
}

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

సాధారణంగా, పద్ధతి ప్రకటన క్రింది భాగాలను కలిగి ఉంటుంది:

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

2. రిటర్న్ రకం : పద్ధతి తిరిగి ఇచ్చే విలువ యొక్క డేటా రకం. ఈ సందర్భంలో, అది శూన్యం అంటే దేనినీ తిరిగి ఇవ్వదు.

3. పద్ధతి పేరు : ఇది మా ప్రోగ్రామ్‌లో పిలవబడే పద్ధతి పేరు. మా పద్ధతి పేరు printName .

4. పరామితి జాబితా : ఇది పద్ధతిలో పాస్ చేయవలసిన డేటా జాబితా. ఇది కామాతో వేరు చేయబడింది మరియు ప్రతి ఇన్‌పుట్ డేటా దాని డేటాటైప్‌తో ముందు ఉంటుంది. పాస్ చేయవలసిన డేటా లేకుంటే బ్రాకెట్లు () ఖాళీగా ఉంటాయి. మేము స్ట్రింగ్ టైప్ యొక్క ఒక పారామీటర్ పేరును పాస్ చేసాము .

5. మెథడ్ బాడీ : ఇది కర్లీ బ్రేస్‌ల లోపల జతచేయబడిన అమలు చేయవలసిన కోడ్‌ను కలిగి ఉంటుంది {} .

ఒక పద్ధతికి కాల్ చేయండి

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

ఉదాహరణ 1

public class Driver {

	public static void printName(String name) {

		System.out.println("Hi, I am " + name + "!");
	}

	public static void main(String[] args) {

		String name = "Mary";
		printName(name);

		String name1 = "Lucy";
		printName(name1);

		String name2 = "Alex";
		printName(name2);

		String name3 = "Zoey";
		printName(name3);
	}
}

అవుట్‌పుట్

వివరణ

పై స్నిప్పెట్‌లో, మేము నిర్వచించిన పద్ధతిని ప్రధానంగా అంటారు. ఇది ఆమోదించవలసిన ఒక వాదనను కలిగి ఉంది. మేము పద్ధతిని నాలుగుసార్లు పిలిచాము, ప్రతిసారీ వాదనను మారుస్తాము. నాలుగు వేర్వేరు వాదనలతో, పద్ధతి వేర్వేరు పేర్లకు వేర్వేరు అవుట్‌పుట్‌లను అందించింది.

ఉదాహరణ 2

public class Driver {

	static int add(int x, int y) {

		int sum = x + y;
		return sum;
	}

	public static void main(String[] args) {

		int x = 10;
		int y = 20;
		int z = add(x, y);
		System.out.println(x + " + " + y + " = " + z);

		x = 5;
		y = 4;
		z = add(x, y);
		System.out.println(x + " + " + y + " = " + z);

		x = 100;
		y = 15;
		z = add(x, y);
		System.out.println(x + " + " + y + " = " + z);

		x = 50;
		y = 5;
		z = add(x, y);
		System.out.println(x + " + " + y + " = " + z);
	}
}

అవుట్‌పుట్

వివరణ

పైన ఉన్న స్నిప్పెట్‌లో, మేము "జోడించు" అని పిలిచే ఒక సాధారణ అదనపు పద్ధతిని నిర్వచించాము. ఇది రెండు పూర్ణాంకాలను తీసుకుంటుంది, వాటి మొత్తాన్ని కనుగొని, దానిని తిరిగి ఇస్తుంది, అది కూడా పూర్ణాంకం. మేము పైన నిర్వచించిన పద్ధతిని ప్రధానంగా పిలుస్తారు. ఇది ఆమోదించవలసిన రెండు వాదనలు ఉన్నాయి. ఆర్గ్యుమెంట్‌లు కామాలతో వేరు చేయబడినందున x మరియు y యొక్క విభిన్న విలువలు ప్రతిసారీ పాస్ చేయబడతాయి. ఈ పద్దతి వేరియబుల్ z లో నిల్వ చేయబడిన పూర్ణాంక విలువను కూడా అందిస్తుంది . మేము పద్ధతిని నాలుగుసార్లు పిలిచాము, ప్రతిసారీ వాదనను మారుస్తాము. మొత్తం నాలుగు వేర్వేరు ఆర్గ్యుమెంట్‌లతో, పద్ధతి మొత్తం వేర్వేరు విలువలను గణించింది మరియు విభిన్న అవుట్‌పుట్‌లను అందించింది. System.out.println() ని గమనించడం ముఖ్యం ;అనేది అంతర్నిర్మిత జావా పద్ధతి, దీనిని మనం మనమే నిర్వచించిన పద్ధతుల మాదిరిగానే పిలుస్తారు.

ముగింపు

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