సి లోని విధుల గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ?

ఈ ఆర్టికల్ మీకు సి లో విధులు అనే సరళమైన ఇంకా చాలా ప్రాథమిక మరియు ముఖ్యమైన భావనను పరిచయం చేస్తుంది మరియు దానిని ప్రదర్శనతో అనుసరిస్తుంది.

ఈ వ్యాసం మీకు సరళమైన ఇంకా చాలా ప్రాథమికమైన మరియు ముఖ్యమైనదాన్ని పరిచయం చేస్తుంది సి లో విధులు అనే భావన మరియు దానిని ప్రదర్శనతో అనుసరించండి. ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,



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



చాలా ప్రాథమిక ప్రశ్నతో ప్రారంభిద్దాం.

సి లో విధులు ఏమిటి?

ఏ ఇతర ప్రోగ్రామింగ్ భాష మాదిరిగానే C లో విధులు ఒకే విధంగా ఉంటాయి. ఇది ఒక నిర్దిష్ట పనిని నిర్వహించడానికి సంకేతాల సమితి. అమలు చేయవలసిన కోడ్ సెట్ వంకర కలుపులలో పేర్కొనబడింది, అనగా ‘{}’.



సి లో ఒక ఫంక్షన్ ఎలా రాయాలో తెలుసుకోవడానికి ముందు, ప్రయోజనాలు ఏమిటో మొదట అర్థం చేసుకుందాం.

సి లో విధుల యొక్క ప్రయోజనాలు

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

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



ఫంక్షన్ కూడా సంగ్రహణను అందిస్తుంది, ఇక్కడ మనం ఒక ఫంక్షన్‌ను పిలుస్తాము మరియు అంతర్గత అమలు తెలియకుండానే అవుట్‌పుట్ పొందవచ్చు.

ఫంక్షన్ సి రకములతో కదులుతోంది

సి లో ఫంక్షన్ రకాలు

రెండు రకాల విధులు ఉన్నాయి:
లైబ్రరీ విధులు
వినియోగదారు నిర్వచించిన విధులు

లైబ్రరీ ఫంక్షన్లు సి లైబ్రరీలో ఇప్పటికే నిర్వచించబడిన ఫంక్షన్లు, అవి strcat (), printf (), scanf () మొదలైనవి. ఈ ఫంక్షన్లను ఉపయోగించడానికి మీరు తగిన హెడర్ ఫైళ్ళను చేర్చాలి.
వినియోగదారు నిర్వచించిన విధులు వినియోగదారు నిర్వచించిన విధులు. ఈ విధులు కోడ్ పునర్వినియోగం కోసం మరియు సమయం మరియు స్థలాన్ని ఆదా చేయడం కోసం తయారు చేయబడతాయి.

ఫంక్షన్‌ను సృష్టించడం వల్ల కలిగే ప్రయోజనాలు ఇప్పుడు మనకు తెలుసు. సి లో ఒక ఫంక్షన్‌ను ఎలా డిక్లేర్ చేయాలో అర్థం చేసుకుందాం.

ఫంక్షన్ డిక్లరేషన్ & డెఫినిషన్

ఫంక్షన్ డిక్లరేషన్:

ఫంక్షన్ డిక్లరేషన్ యొక్క సింటాక్స్:

return_type function_name (data_type arg1, data_type arg2) int add (int x, int y) // ఫంక్షన్ డిక్లరేషన్

ఫంక్షన్ డిక్లరేషన్‌లో, మేము ఫంక్షన్ పేరు, ఇన్‌పుట్ పరామితి సంఖ్య, వాటి డేటాటైప్స్ & ఫంక్షన్ యొక్క తిరిగి రకాన్ని పేర్కొంటాము. ఫంక్షన్ డిక్లరేషన్ కంపైలర్‌కు ఫంక్షన్ వారి డేటా రకాలు & ఫంక్షన్ యొక్క రిటర్న్ రకంతో ఆశిస్తున్న వాదనల జాబితా గురించి చెబుతుంది.

ఫంక్షన్ డిక్లరేషన్‌లో, పరామితి పేర్లను పేర్కొనడం ఐచ్ఛికం, కానీ వాటి డేటా రకాలను పేర్కొనడం తప్పనిసరి.

int add (int, int) // ఫంక్షన్ డిక్లరేషన్

పైన పేర్కొన్న ఫంక్షన్ రెండు పూర్ణాంక పారామితులను తీసుకుంటుంది.

ఫంక్షన్ నిర్వచనం

 చిత్రం- సి- ఎడురేకాలో విధులు
పూర్ణాంకానికి జోడించు (పూర్ణాంకానికి, పూర్ణాంకానికి) // ఫంక్షన్ డిక్లరేషన్ రిటర్న్_టైప్ ఫంక్షన్_పేరు (పారామితులు) {ఫంక్షన్ బాడీ}

పై చిత్రంలో చూపిన విధంగా ఫంక్షన్ నిర్వచనం రెండు భాగాలను కలిగి ఉంటుంది, అనగా ఫంక్షన్ హెడర్ & ఫంక్షన్ బాడీ

ఫంక్షన్ హెడర్: ఫంక్షన్ హెడర్ సెమికోలన్ లేకుండా ఫంక్షన్ డిక్లరేషన్ వలె ఉంటుంది. ఫంక్షన్ హెడర్ ఫంక్షన్ పేరు, పారామితి & రిటర్న్ రకాన్ని కలిగి ఉంటుంది.

  • తిరిగి వచ్చే రకం: రిటర్న్ రకం విలువ ద్వారా డేటా రకం, ఇది ఫంక్షన్ ద్వారా తిరిగి వస్తుంది. ఫంక్షన్ విలువను తిరిగి ఇవ్వకపోవచ్చు లేదా ఇవ్వకపోవచ్చు. అలా చేస్తే, తిరిగి పొందే విలువ యొక్క డేటా రకం పేర్కొనబడాలి, లేకపోతే తిరిగి వచ్చే రకం శూన్యంగా ఉండాలి.

  • ఫంక్షన్ పేరు: ఇది ఫంక్షన్ పేరు మరియు అవసరమైనప్పుడు ఫంక్షన్ అని పిలుస్తాము.

  • పారామితులు: పారామితులు ఫంక్షన్కు పంపబడే ఇన్పుట్ విలువలు. ఇది వాదనల యొక్క డేటా రకాలు, వాటి క్రమం మరియు ఫంక్షన్‌కు పంపబడే వాదనల సంఖ్య గురించి చెబుతుంది. పారామితులు ఐచ్ఛికం. మీరు పారామితులు లేకుండా విధులు కూడా కలిగి ఉండవచ్చు.

    జావా డబుల్ పూర్ణాంకానికి మారుస్తుంది

ఫంక్షన్ బాడీ: ఫంక్షన్ బాడీ అనేది ఒక నిర్దిష్ట పనిని చేసే స్టేట్మెంట్ సెట్. ఇది ఫంక్షన్ ఏమి చేస్తుందో నిర్వచిస్తుంది.

ఉదాహరణ:

int జోడించు (int x, int y) {int sum = x + y return (sum)}

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

ఉదాహరణ:

# int add (int, int) // ఫంక్షన్ డిక్లరేషన్ // ఫంక్షన్ డెఫినిషన్ int add (int x, int y) // ఫంక్షన్ హెడర్ {// ఫంక్షన్ బాడీ int sum = x + y రిటర్న్ (మొత్తం)} // ప్రధాన ఫంక్షన్ int main () {int sum = add (23, 31) printf ('% d', sum) return 0}

పై ఉదాహరణలో మనం int sum = add (23, 31) స్టేట్మెంట్ ఉపయోగించి ఫంక్షన్ అని పిలుస్తున్నట్లు చూడవచ్చు. ఫంక్షన్ నుండి తిరిగి వచ్చిన విలువ మొత్తం వేరియబుల్‌లో నిల్వ చేయబడుతుంది.

మేము ముందుకు వెళ్ళే ముందు, పారామెంట్ గురించి అర్థం చేసుకోవడానికి మరో ముఖ్యమైన భావన ఉంది. పరామితిలో రెండు రకాలు ఉన్నాయి:

వాస్తవ పరామితి : ఫంక్షన్లను పిలిచేటప్పుడు వాటిని పంపించే పారామితులను వాస్తవ పరామితి అంటారు. ఉదాహరణకు, పై ఉదాహరణలో 23 & 31 అసలు పారామితులు.

అధికారిక పరామితి : ఫంక్షన్ల ద్వారా స్వీకరించబడిన పారామితులను అధికారిక పారామితులు అంటారు. ఉదాహరణకు, పై ఉదాహరణలోని x & y అధికారిక పారామితులు.

సి లో ఫంక్షన్‌ను పిలిచే వివిధ మార్గాలను త్వరగా అర్థం చేసుకుందాం.

ఒక ఫంక్షన్ పిలుస్తోంది

మనం ఫంక్షన్ అని పిలవడానికి రెండు మార్గాలు ఉన్నాయి:

  • విలువ ద్వారా కాల్ చేయండి
  • సూచన ద్వారా కాల్ చేయండి

విలువ ద్వారా కాల్ చేయండి

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

కాల్ బి విలువ పద్ధతిలో, ఫార్మల్ & అసలైన పారామితులకు వేర్వేరు మెమరీ చిరునామా కేటాయించబడుతుంది. వాస్తవ పరామితి యొక్క విలువ అధికారిక పారామితికి కాపీ చేయబడుతుంది.

ఉదాహరణ:

# శూన్యమైన కాల్_బై_వాల్యూ (int num1) {num1 = 42 printf ('n ఇన్సైడ్ ఫంక్షన్, సంఖ్య% d', num1)} int main () {int num num = 24 printf ('n ఫంక్షన్ ముందు, సంఖ్య% d', num ) Call_By_Value (num) printf ('n ఫంక్షన్ తరువాత, సంఖ్య% dn', సంఖ్య) తిరిగి 0}

అవుట్పుట్

పై ఉదాహరణలో, విలువ ఫంక్షన్ ద్వారా కాల్ చేయడానికి ముందు, సంఖ్య యొక్క విలువ 24. అప్పుడు, ఒకసారి మేము ఫంక్షన్‌ను పిలిచి విలువను పాస్ చేసి, దాన్ని ఫంక్షన్ లోపల మార్చినట్లయితే, అది 42 అవుతుంది. మనం తిరిగి వచ్చి విలువను ప్రింట్ చేసినప్పుడు ప్రధాన ఫంక్షన్లో సంఖ్య, ఇది 24 అవుతుంది.

సూచన ద్వారా కాల్ చేయండి

రిఫరెన్స్ కాల్‌లో, వాస్తవ పరామితి యొక్క మెమరీ చిరునామా ఫంక్షన్‌కు ఆర్గ్యుమెంట్‌గా పంపబడుతుంది. ఇక్కడ, వాస్తవ పరామితి యొక్క విలువను అధికారిక పరామితి ద్వారా మార్చవచ్చు.

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

సి లో మేము సూచన ద్వారా కాల్ అమలు చేయడానికి పాయింటర్లను ఉపయోగిస్తాము. దిగువ ఉదాహరణలో మీరు చూడగలిగినట్లుగా, కాల్_బై_ రిఫరెన్స్ ఫంక్షన్ ఒక పూర్ణాంకానికి పాయింటర్‌ను ఆశిస్తోంది.

ఇప్పుడు, ఈ num1 వేరియబుల్ అసలు పరామితి యొక్క మెమరీ చిరునామాను నిల్వ చేస్తుంది. కాబట్టి, num1 చేత సూచించబడిన మెమరీ చిరునామాలో నిల్వ చేయబడిన విలువను ప్రింట్ చేయడానికి మనం డీరెఫరెన్స్ ఆపరేటర్‌ని ఉపయోగించాలి. *. కాబట్టి, * num1 విలువ 42.

అడ్రస్ ఆపరేటర్ & ఏదైనా డేటా రకం యొక్క వేరియబుల్ యొక్క చిరునామాను పొందడానికి ఉపయోగించబడుతుంది. కాబట్టి ఫంక్షన్ కాల్ స్టేట్మెంట్ ‘కాల్_బై_ రిఫరెన్స్ (& నం)’ లో, నం యొక్క చిరునామా పాస్ అవుతుంది, తద్వారా నం దాని చిరునామాను ఉపయోగించి సవరించబడుతుంది.

ఉదాహరణ

# చేర్చండి // ఫంక్షన్ డెఫినిషన్ శూన్యమైన కాల్_బై_ రిఫరెన్స్ (పూర్ణాంకానికి * సంఖ్య 1) {* num1 = 42 printf ('n ఫంక్షన్, సంఖ్య% d', * num1)} // ప్రధాన ఫంక్షన్ int main () {int num num = 24 printf ( 'n ముందు ఫంక్షన్, సంఖ్య% d', సంఖ్య) కాల్_బై_ రిఫరెన్స్ (& సంఖ్య) printf ('n ఫంక్షన్ తరువాత, సంఖ్య% dn', సంఖ్య) తిరిగి 0}

అవుట్పుట్

ఈ ఉదాహరణలో, సంఖ్యా విలువ ప్రారంభంలో 24, ప్రధాన ఫంక్షన్ లోపల. ఇది Call_By_Reference ఫంక్షన్‌కు పంపబడిన తర్వాత మరియు విలువ అధికారిక పరామితి ద్వారా సవరించబడితే, అది వాస్తవ పరామితికి కూడా మార్చబడుతుంది. అందువల్ల మేము ఫంక్షన్ తర్వాత సంఖ్య యొక్క విలువను ప్రింట్ చేస్తున్నప్పుడు అది 42 ను ప్రింట్ చేస్తుంది.

C లో వినియోగదారు నిర్వచించిన ఫంక్షన్ రకములతో కదులుతోంది

వినియోగదారు నిర్వచించిన రకాలు ఫంక్షన్ సి లో

రిటర్న్ రకం & వాదనలు ఆధారంగా వివిధ రకాల వినియోగదారు-నిర్వచించిన విధులు ఉన్నాయి.

వాదనలు ఆమోదించబడలేదు మరియు తిరిగి విలువ లేదు

1. వాదనలు ఆమోదించబడలేదు మరియు తిరిగి విలువ లేదు

సింటాక్స్:

ఫంక్షన్ డిక్లరేషన్:

శూన్య ఫంక్షన్ () ఫంక్షన్ కాల్: ఫంక్షన్ () ఫంక్షన్ నిర్వచనం: శూన్య ఫంక్షన్ () {ప్రకటనలు}

ఉదాహరణ

# శూన్య యాడ్ () శూన్య యాడ్ () {int x = 20 int y = 30 int sum = x + y printf ('sum% d', sum)} int main () {add () return 0}

ఎటువంటి వాదనలు ఆమోదించబడలేదు కాని తిరిగి వచ్చే విలువ

2 వాదనలు ఆమోదించబడలేదు కాని తిరిగి వచ్చే విలువ

సింటాక్స్:

ఫంక్షన్ డిక్లరేషన్:

పూర్ణాంక ఫంక్షన్ () ఫంక్షన్ కాల్: ఫంక్షన్ () ఫంక్షన్ నిర్వచనం: పూర్ణాంక ఫంక్షన్ () {ప్రకటనలు ఒక return

ఉదాహరణ:

# int add () int add () {int x = 20 int y = 30 int sum = x + y return (sum)} int main () {int sum sum = add () printf ('sum% d', మొత్తం) తిరిగి 0}

ఆర్గ్యుమెంట్‌లతో కదులుతున్నప్పటికీ తిరిగి విలువ లేదు

3 వాదన ఆమోదించింది కాని తిరిగి విలువ లేదు

సింటాక్స్:

ఫంక్షన్ డిక్లరేషన్:

శూన్య ఫంక్షన్ (పూర్ణాంకానికి) ఫంక్షన్ కాల్: ఫంక్షన్ (ఎ) ఫంక్షన్ నిర్వచనం: శూన్య ఫంక్షన్ (పూర్ణాంకానికి) {ప్రకటనలు}

ఉదాహరణ:

# శూన్య యాడ్ (పూర్ణాంకానికి, పూర్ణాంకానికి) శూన్య జోడించు (పూర్ణాంకానికి x, పూర్ణాంకానికి y) {int మొత్తం = x + y తిరిగి (మొత్తం)} int ప్రధాన () {జోడించు (23, 31) తిరిగి 0}

ఆర్గ్యుమెంట్ పాస్ మరియు రిటర్న్ వాల్యూతో కదులుతోంది

4 వాదన ఆమోదించింది మరియు తిరిగి వచ్చే విలువ

సింటాక్స్:

పోజో ఆధారిత ప్రోగ్రామింగ్ మోడల్ అంటే ఏమిటి

ఫంక్షన్ డిక్లరేషన్:

పూర్ణాంక ఫంక్షన్ (పూర్ణాంకానికి) ఫంక్షన్ కాల్: ఫంక్షన్ (ఎ) ఫంక్షన్ నిర్వచనం: పూర్ణాంక ఫంక్షన్ (పూర్ణాంకానికి a) {ప్రకటనలు తిరిగి ఇస్తాయి}

ఉదాహరణ

# int add (int, int) int add (int x, int y) {int sum = x + y return (sum)} int main () {int sum = add (23, 31) printf ('% d' , మొత్తం) తిరిగి 0}

ఇప్పుడు ప్రోగ్రామ్ రాయడానికి ముఖ్యమైన సి లైబ్రరీ ఫంక్షన్లను త్వరగా చూద్దాం.

సి లైబ్రరీ విధులు

లైబ్రరీ ఫంక్షన్లు C లోని ఫంక్షన్లు, ఇవి ముందుగా నిర్వచించబడినవి మరియు అప్రమేయంగా ఉంటాయి. మీరు ప్రోగ్రామ్‌లో నిర్దిష్ట హెడర్ ఫైల్‌ను చేర్చాలి & మీరు ఆ హెడర్ ఫైల్‌లో నిర్వచించిన ఫంక్షన్లను ఉపయోగించవచ్చు. ప్రతి హెడర్ ఫైల్ నిర్దిష్ట రకమైన కార్యాచరణను అందిస్తుంది. హెడర్ ఫైల్ యొక్క పొడిగింపు .h.

ఉదాహరణకు, printf / scanf ఫంక్షన్లను ఉపయోగించడానికి మన ప్రోగ్రామ్లో stdio.h ను చేర్చాలి, ఇవి ప్రామాణిక ఇన్పుట్ / అవుట్పుట్కు సంబంధించి కార్యాచరణను అందిస్తాయి.

హెడర్ ఫైళ్ళ జాబితా క్రింది ఉంది.

ఒకటిstdio.hప్రామాణిక ఇన్పుట్ / అవుట్పుట్ హెడర్ ఫైల్
2minting.hకన్సోల్ ఇన్పుట్ / అవుట్పుట్ హెడర్ ఫైల్
3string.hగెట్స్ (), పుట్స్ (), వంటి స్ట్రింగ్ సంబంధిత లైబ్రరీ ఫంక్షన్లు.
4stdlib.hమాలోక్ (), కాలోక్ (), నిష్క్రమణ () మొదలైన సాధారణ లైబ్రరీ విధులు.
5math.hగణిత కార్యకలాపాలకు సంబంధించిన ఫంక్షన్లు sqrt (), pow (), మొదలైనవి.
6time.hసమయ సంబంధిత విధులు
7ctype.hఅక్షర నిర్వహణ విధులు
8stdarg.hవేరియబుల్ ఆర్గ్యుమెంట్ ఫంక్షన్లు
9signal.hసిగ్నల్ నిర్వహణ విధులు
10setjmp.hవిధులు జంప్ చేయండి
పదకొండుlocale.hలొకేల్ విధులు
12errno.hవిధులను నిర్వహించడంలో లోపం
13assert.hడయాగ్నోస్టిక్స్ విధులు

ఇప్పుడు పై సి ఫంక్షన్ల ద్వారా వెళ్ళిన తరువాత మీరు ఫంక్షన్ యొక్క ప్రతి స్వల్పభేదాన్ని మరియు సి భాషలో ఎలా అమలు చేయాలో అర్థం చేసుకోవచ్చు. ఈ బ్లాగ్ మీకు సమాచారం మరియు అదనపు విలువను ఇస్తుందని నేను ఆశిస్తున్నాను.

ఈ విధంగా మేము ‘సి లో విధులు’ అనే ఈ వ్యాసం ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి , విశ్వసనీయ ఆన్‌లైన్ అభ్యాస సంస్థ. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.