జావా ఎనుమ్ ట్యుటోరియల్: ఇది ఏమిటి మరియు దాన్ని ఎలా అమలు చేయాలి?

ది లో గణన స్థిరమైన మరియు పేరున్న స్థిరాంకాలతో ఒక తరగతిని వాటితో నిర్వచించే మార్గం కీవర్డ్ ఉపయోగించి enum. ఇందులో “ జావా ఎనుమ్ ట్యుటోరియల్ ”వ్యాసం, మేము నేర్చుకుంటాముగణనను నిర్వచించండిమంచి అవగాహన కోసం ఉదాహరణలు.

• గణన అంటే ఏమిటి?
• మనకు గణన ఎందుకు అవసరం?
• ఎనుమ్ మరియు క్లాస్ మధ్య తేడాలు
• ఎనుమ్ యొక్క ప్రాక్టికల్ ఉదాహరణలు
• ఎనుమ్ యొక్క ప్రయోజనాలు
• ఎనుమ్ యూస్‌కేస్: రాక్, పేపర్, సిజర్స్ గేమ్

గణన అంటే ఏమిటి?

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

సాస్ ప్రోగ్రామింగ్ పరిచయం ప్రాథమిక అంశాలు

మనకు గణన ఎందుకు అవసరం?

enum బాయిలర్‌ప్లేట్ కోడ్‌ను తప్పించడం ద్వారా రన్-టైమ్‌లో లోపాలను నివారించడానికి కంపైల్-టైమ్ చెకింగ్ వద్ద టైప్ భద్రతను మెరుగుపరుస్తుంది. ఉదాహరణకు, మీరు అందుబాటులో ఉన్న తక్కువ సంఖ్యలో ఎంపికలలో ఒక అవకాశాన్ని ఎంచుకోవలసి వస్తే, చెప్పండి

ఉద్యోగం రకం: (ఒప్పందం / తాత్కాలికం / శాశ్వతం)

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

ఎనుమ్ మరియు క్లాస్ మధ్య తేడాలు

జావా వాతావరణంలో ఒక తరగతి మరియు ఎనుమ్ ఒకే విధమైన కార్యాచరణను కలిగి ఉన్నప్పటికీ, అవి కొన్ని అంశాలలో విభిన్నంగా ఉంటాయి. తేడాలు చర్చిద్దాం

ఎనుమ్ యొక్క ప్రాక్టికల్ ఉదాహరణలు

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

• జావాలో గణనను నిర్వచించడం
• స్విచ్ కేసులో ఎనుమ్ ఉపయోగించబడింది
• ఎనుమ్ ఉపయోగించి వారసత్వం
• అనుకూలీకరించిన విలువలతో ఎనుమ్
• If-else-if స్టేట్మెంట్లలో ఎన్యూమ్ చేయండి
• ఎనుమ్‌తో ఉపయోగించే వివిధ పద్ధతులు
  1. విలువలు ()
  2. విలువలు ()
  3. ఆర్డినల్ ()

జావాలో గణనను నిర్వచించడం

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

సింటాక్స్:

enum name {స్థిరాంకాలు}

ఈ ఉదాహరణలో, మేము ప్రకటించాము ప్రధాన () పద్ధతి లోపల enum

ప్యాకేజీ నిర్వచనం పబ్లిక్ క్లాస్ ఎడురేకా {enum స్థాయి {BAJA, KTM, YAMAHA} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్థాయి myVar = Level.KTM System.out.println (myVar)}}

// up పుట్

KTM

ఈ ఉదాహరణలో, ది ప్రధాన () పద్ధతి ప్రకటించబడింది బయట enum యొక్క.

ప్యాకేజీ నిర్వచనం enum రంగు {BAJAJ, KTM, YAMAHA} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {బైక్ b1 = కలర్.యమహా సిస్టమ్.అవుట్.ప్రింట్ల్న్ (బి 1)}}

// అవుట్పుట్:

యమహా

స్విచ్ కేసులో ఎనుమ్ ఉపయోగించబడింది

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

ఇక్కడ, మేము వారంలోని రోజులతో ఒక ఎనుమ్‌ను దాని మూలకాలుగా ప్రకటిస్తాము మరియు మ్యాచింగ్ కేసు యొక్క డేటాను ముద్రించడానికి డేటాను స్ట్రింగ్ రూపంలో పాస్ చేస్తాము.

ప్యాకేజీ స్విచ్డ్ ఎన్యూమ్ డే {ఆదివారం, సోమవారం, మంగళవారం, బుధవారం, గురువారం, శుక్రవారం, శనివారం} పబ్లిక్ క్లాస్ ఎడురేకా {డే డే పబ్లిక్ ఎడురేకా (డే డే) {this.day = day} public void dayIsLike () {స్విచ్ (రోజు) {కేసు సోమవారం: System.out.println ('హాయ్, ఈ రోజు సోమవారం') బ్రేక్ కేసు మంగళవారం: System.out.println ('హాయ్, ఈ రోజు మంగళవారం') బ్రేక్ కేసు బుధవారం: System.out.println ('హాయ్, ఈ రోజు బుధవారం ') బ్రేక్ కేసు గురువారం: System.out.println (' హాయ్, ఈ రోజు గురువారం ') బ్రేక్ కేసు శుక్రవారం: System.out.println (' హలో, ఈ రోజు శుక్రవారం. ') బ్రేక్ కేసు శనివారం: System.out.println (' హాయ్, ఈ రోజు మీ వీకెండ్ ') బ్రేక్ కేసు ఆదివారం: System.out.println (' హాయ్, ఈ రోజు ఒక హాలిడే ') బ్రేక్ డిఫాల్ట్: System.out.println (' దయచేసి చెల్లుబాటు అయ్యే రోజును నమోదు చేయండి. ') బ్రేక్}} పబ్లిక్ స్టాటిక్ void main (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్ str = 'MONDAY' Edureka e1 = new Edureka (Day.valueOf (str)) e1.dayIsLike ()}}

// అవుట్పుట్:

హాయ్, ఈ రోజుసోమవారం

ఎనుమ్ ఉపయోగించి వారసత్వం

సాధారణంగా, ఏదైనా enum నైరూప్య తరగతి java.lang ను విస్తరించే తరగతిగా సూచించబడుతుంది. ఎనుమ్ మరియు అనేక స్టాటిక్ సభ్యులను కలిగి ఉంది. అందువలన, ఒక enum ఏ ఇతర తరగతిని పొడిగించలేరు లేదా enum బహుళ లేదు వారసత్వం . ఒక మంచి మార్గంలో అర్థం చేసుకోవడానికి ఒక ఉదాహరణను అమలు చేద్దాం.

ఇక్కడ, మేము ఫోన్ తయారీదారు ఆధారంగా OS ని వారసత్వంగా పొందుతాము.

ప్యాకేజీ వారసత్వ దిగుమతి java.util.ArrayList దిగుమతి java.util.List పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {జాబితా వారసత్వం = కొత్త శ్రేణి జాబితా () వారసత్వంగా. (లైబ్రరీఎనుమ్.ఫస్ట్) వారసత్వంగా. (క్లయింట్ఎనమ్. google) (HTTPMethodConvertible ఎలిమెంట్: వారసత్వంగా) . ('iOS'), గూగుల్ ('ఆండ్రాయిడ్ వన్') స్ట్రింగ్ httpMethodType ClientEnum (స్ట్రింగ్ లు) {httpMethodType = s} పబ్లిక్ స్ట్రింగ్ getHTTPMethodType () {తిరిగి httpMethodType}}}

// అవుట్పుట్:

గూగుల్ పిక్సెల్
Android One

అనుకూలీకరించిన విలువలతో ఎనుమ్

ఎనుమ్స్ డిఫాల్ట్‌గా వాటి స్వంత స్ట్రింగ్ విలువలను కలిగి ఉంటాయి, మేము కొన్ని అనుకూల విలువలను ఎనుమ్‌లకు కేటాయించవచ్చు. ఈ క్రింది ఉదాహరణను పరిశీలిద్దాం.

enum Traffic {RED (“STOP”), ORANGE (“WAIT”), GREEN (“GO”)}

పై ఉదాహరణలో, ట్రాఫిక్ ఎనుమ్కు ముగ్గురు సభ్యులు ఉన్నారని మనం చూడవచ్చు. అవి,

రెడ్, ఆరెంజ్ మరియు గ్రీన్ వారి స్వంత అనుకూల విలువలను కలిగి ఉంటాయి ఆపు, వేచి ఉండండి మరియు వెళ్ళండి వరుసగా.

ఇప్పుడు కోడ్‌లో ఒకే రకమైన ఎనుమ్‌ను ఉపయోగించడానికి మేము కొన్ని పాయింట్లను అనుసరిస్తాము:

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

దీని ఆధారంగా ఒక ప్రోగ్రామ్‌ను ఎగ్జిక్యూట్ చేద్దాం.

ప్యాకేజీ ట్రాఫిక్ ఎనమ్ ట్రాఫిక్ సిగ్నల్ {RED ('స్టాప్'), గ్రీన్ ('GO'), ఆరెంజ్ ('WAIT') ప్రైవేట్ స్ట్రింగ్ యాక్షన్ పబ్లిక్ స్ట్రింగ్ getAction () {దీన్ని తిరిగి ఇవ్వండి} ప్రైవేట్ ట్రాఫిక్ సిగ్నల్ (స్ట్రింగ్ చర్య) {this.action = చర్య}} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {ట్రాఫిక్ సిగ్నల్ [] సిగ్నల్స్ = ట్రాఫిక్ సిగ్నల్.వాల్యూస్ () (ట్రాఫిక్ సిగ్నల్ సిగ్నల్: సిగ్నల్స్) {System.out.println ('పేరు:' + సిగ్నల్.నేమ్ () + 'చర్య:' + signal.getAction ())}}}

// అవుట్పుట్:

పేరు: RED చర్య: ఆపు
పేరు: గ్రీన్ చర్య: GO
పురుషుడుఇ: ఆరెంజ్ చర్య: వేచి ఉండండి

If-else-if స్టేట్మెంట్లలో ఎన్యూమ్ చేయండి

ఇప్పుడు, ఒక ప్రోగ్రామ్ ఆధారంగా అమలు చేద్దాం if-else-if స్టేట్మెంట్లలో enum. ఇక్కడ, ఎనుమ్‌లో లభించే దిశల విలువలను దాటడం ద్వారా ట్రావెర్సల్ దిశను కనుగొంటాము.

ప్యాకేజీ దిశలు enum దిశలు {ఈస్ట్, వెస్ట్, నార్త్, సౌత్} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {దిశలు dir = దిశలు. NORTH if (dir == Directions.EAST) {System.out.println ( 'దిశ: తూర్పు')} else if (dir == Directions.WEST) {System.out.println ('Direction: West')} else if (dir == Directions.NORTH) {System.out.println ('Direction : ఉత్తరం ')} else {System.out.println (' దిశ: దక్షిణ ')}}}

// అవుట్పుట్:

చెప్పండిction: ఉత్తరం

ఎనుమ్‌తో ఉపయోగించే వివిధ పద్ధతులు

విలువలు (): మీరు ఒక ఎన్యూమ్ను సృష్టించినప్పుడు, ది జావా కంపైలర్ అంతర్గతంగా జతచేస్తుంది విలువలు () పద్ధతి. ఈ పద్ధతి తిరిగి ఇస్తుంది అమరిక enum యొక్క అన్ని విలువలను కలిగి ఉంటుంది.

// సింటాక్స్:

పబ్లిక్ స్టాటిక్ ఎనుమ్-టైప్ [] విలువలు ()

శ్రేణిలోని ఒక నిర్దిష్ట మూలకం యొక్క సూచిక విలువను మేము కనుగొంటాము.

ప్యాకేజీ విలువలు enum రంగు {RED, GREEN, BLUE} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {కలర్ అర్ర్ [] = కలర్.వాల్యూస్ () (కలర్ కోల్: అర్ర్) {System.out.println ( col + 'at index' + col.ordinal ())} System.out.println (Color.valueOf ('RED'))}}

// అవుట్పుట్:

సూచిక 0 వద్ద RED
ఇండెక్స్ 1 వద్ద గ్రీన్
సూచిక 2 వద్ద నీలం
NET

యొక్క విలువ(): ఇదిగణన స్థిరాంకాన్ని తిరిగి ఇవ్వడానికి పద్ధతి ఉపయోగించబడుతుంది, దీని విలువ సమానంగా ఉంటుంది ఈ పద్ధతిని పిలిచేటప్పుడు వాదనగా ఆమోదించింది.

// సింటాక్స్:

పబ్లిక్ స్టాటిక్ ఎనుమ్-టైప్ వాల్యూఆఫ్ (స్ట్రింగ్ స్ట్రింగ్)

ఇక్కడ, మేము స్ట్రింగ్‌కు పంపే ఇన్‌పుట్ ఆధారంగా ఒక నిర్దిష్ట ఫోన్ ధరను కనుగొంటాము.

ప్యాకేజీ విలువలు మొబైల్ {శామ్‌సంగ్ (1099), ఆపిల్ (1250), గూగుల్ (1325) పూర్ణాంక ధర మొబైల్ (పూర్ణాంకం) {ధర = పి} పూర్ణాంక ప్రదర్శన () {తిరిగి ధర}} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ args []) {(మొబైల్ m: Mobile.values ​​()) కోసం System.out.println ('సెల్‌ఫోన్ జాబితా:') {System.out.println (m + 'ఖర్చులు' + m.showPrice () + 'డాలర్లు' )} Mobile ret ret = Mobile.valueOf ('Samsung') System.out.println ('ఎంచుకున్నది:' + ret)}}

// అవుట్పుట్:

శామ్‌సంగ్ ధర 1099 డాలర్లు
ఆపిల్ ధర 1250 డాలర్లు
గూగుల్ ధర 1325 డాలర్లు
ఎంచుకున్నది: శామ్‌సంగ్

సాధారణ (): జావా వ్యాఖ్యాత జతచేస్తుంది ఆర్డినల్ () ఇది సృష్టించినప్పుడు అంతర్గతంగా పద్ధతి enum. ఆర్డినల్ () పద్ధతి తిరిగి ఇస్తుంది సూచిక enum విలువ యొక్క.

// సింటాక్స్:

పబ్లిక్ ఫైనల్ Int ఆర్డినల్ ()

ఇక్కడ, శ్రేణిలోని ఒక నిర్దిష్ట మూలకం యొక్క సూచిక విలువను మేము కనుగొంటాము. మరియు, చెర్రీ పండు యొక్క స్థానం.

ప్యాకేజీ ఆర్డినల్ ఎనుమ్ పండ్లు {ఆపిల్, అరటి, చెర్రీ, తేదీ, ఎల్డర్‌బెర్రీ} enum కూరగాయలు {క్యారెట్, బీట్‌రూట్, బీన్స్, టొమాటో, ఉల్లిపాయ} పబ్లిక్ క్లాస్ ఎడురేకా {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {పండ్లు [] ఫ్రూ = పండ్లు. విలువలు () కోసం (పండ్లు fr: fru) {System.out.println (fr + ':' + fr.ordinal ())} పండ్లు f1, f2, f3 f1 = పండ్లు. ఆపిల్ f2 = పండ్లు.చెర్రీ f3 = పండ్లు. if (f2.compareTo (f1)> 0) {System.out.println (f2 + '' + f1 తర్వాత వస్తుంది)} కూరగాయలు v1 = కూరగాయలు.బీట్రూట్ ఉంటే (f1.equals (v1)) {System.out.println (' తప్పు ')}}}

// అవుట్పుట్:

ఆపిల్: 0
అరటి: 1
చెర్రీ: 2
తేదీ: 3
ఎల్డర్‌బెర్రీ: 4
చెర్రీ ఆపిల్ తరువాత వస్తుంది

ఎనుమ్ యొక్క ప్రయోజనాలు

• జావాలో ఎనుమ్ మెరుగుపడుతుంది టైప్ భద్రత
• ఎనుమ్ సులభంగా ఉపయోగించగలిగేలా రూపొందించబడింది కేసులను మార్చండి
• ఎనుమ్ కావచ్చు ప్రయాణించారు
• ఎనుమ్ కలిగి ఉంటుంది క్షేత్రాలు, పద్ధతులు, మరియు కన్స్ట్రక్టర్లు
• ఎనుమ్ అమలు చేయగలదు ఇంటర్ఫేస్లు
• ఎనుమ్ విస్తరించదు a తరగతి అంతర్గతంగా, ఇది విస్తరించి ఉంది ఎనుమ్ తరగతి

ఎనుమ్ యూస్‌కేస్: రాక్, పేపర్, సిజర్స్ గేమ్

మేము ఉపయోగిస్తాము enum మా చిన్ననాటి ఆటను సృష్టించడానికి జావాలో, రాక్ (రాయి) కాగితం మరియు కత్తెర . కింది కోడ్ ఎలా వివరిస్తుంది.

ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Random దిగుమతి java.util.Scanner enum హ్యాండ్‌సైన్ {SCISSOR, PAPER, STONE} పబ్లిక్ క్లాస్ SPS {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {రాండమ్ రాండమ్ = కొత్త రాండమ్ () బూలియన్ గేమ్ఓవర్ = తప్పుడు హ్యాండ్‌సైన్ playerMove = HandSign.SCISSOR HandSign computerMove int numTrials = 0 int numComputerWon = 0 int numPlayerWon = 0 int numTie = 0 = కొత్త స్కానర్ (System.in) System.out.println ('n మాకు ప్రారంభిద్దాం ... n') (! gameOver) {System.out.printf ('% nScissor-Paper-Stonen') బూలియన్ చెల్లుబాటు అయ్యే ఇన్‌పుట్ చేయండి {System.out.print ('n మీ వంతు (దయచేసి కత్తెర కోసం s, కాగితం కోసం p, రాయి కోసం t, q to quit): n ') char inChar = in.next (). toLowerCase (). charAt (0) validInput = true if (inChar ==' q ') {gameOver = true} else if (inChar ==' s ' ) {playerMove = HandSign.SCISSOR} else if (inChar == 'p') {playerMove = HandSign.PAPER} else if (inChar == 't') {playerMove = HandSign.STONE} else {System.out.println ( 'n దయచేసి ఇన్‌పుట్‌ను తనిఖీ చేసి, మళ్లీ ప్రయత్నించండి! n') validInput = false}} అయితే (! val idInput) if (! gameOver) {int aRandomNumber = random.nextInt (3) if (aRandomNumber == 0) {computerMove = HandSign.SCISSOR System.out.println ('n ఇది నా వంతు: SCISSORn')} లేకపోతే (aRandomNumber = = 0) {computerMove = HandSign.PAPER System.out.println ('ఇది నా వంతు: PAPERn')} else {computerMove = HandSign.STONE System.out.println ('n ఇది నా వంతు: STONEn')} if (computerMove = = playerMove) {System.out.println ('ఇది ఒక టై! n') ++ numTie} else if (computerMove == HandSign.SCISSOR & amp & amp playerMove == HandSign.PAPER) {System.out.println ('nScissor కాగితాన్ని కత్తిరిస్తుంది , నేను గెలిచాను! N ') ++ numComputerWon} else if (computerMove == HandSign.PAPER & amp & amp playerMove == HandSign.STONE) {System.out.println (' n పేపర్ రాయిని చుట్టేస్తుంది, నేను గెలిచాను! N ') ++ numComputerWon} else if (computerMove == HandSign.STONE & amp & amp playerMove == HandSign.SCISSOR) {System.out.println ('n స్టోన్ కత్తెరను విచ్ఛిన్నం చేస్తుంది, నేను గెలిచాను! n') ++ numComputerWon} else {System.out.println ('n అభినందనలు. ..! మీరు గెలిచారు! N ') ++ numPlayerWon} ++ numTrials}} System.out.printf ('% n ట్రయల్స్ సంఖ్య: '+ numTrials) System.out.printf (' నేను% d (%. 2f %%) గెలిచాను. . మీరు% d (%. 2f %%) గెలిచారు.% N ', numComputerWon, 100.0 * numComputerWon / numTrials, numPlayerWon, 100.0 * numPlayerWon / numTrials) System.out.println (' బై !, మీరు ఆనందించారని ఆశిస్తున్నాము ..! ' )}}

// అవుట్పుట్:

ప్రారంభిద్దాం ...
కత్తెర-పేపర్-స్టోన్
మీ వంతు (దయచేసి కత్తెర కోసం s, కాగితం కోసం p, రాయికి t, నిష్క్రమించడానికి q):
s
ఇది నా వంతు: స్టోన్
స్టోన్ కత్తెరను విచ్ఛిన్నం చేస్తుంది, నేను గెలిచాను!
కత్తెర-పేపర్-స్టోన్
మీ వంతు (దయచేసి కత్తెర కోసం s, కాగితం కోసం p, రాయికి t, నిష్క్రమించడానికి q):
ఏమిటి
ట్రయల్స్ సంఖ్య: 1I 1 (100.00%) గెలిచింది. మీరు 0 (0.00%) గెలిచారు.
బై!, మీరు ఆనందించారని ఆశిస్తున్నాము ..!

దీనితో, మేము ఈ జావా ఎనుమ్ ట్యుటోరియల్ ముగింపుకు వచ్చాము. కొన్ని నిజ-సమయ ఉదాహరణల ద్వారా మీరు జావాలోని ఎనుమ్ మరియు దాని అమలును అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.

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

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