ఇతర

Mac [Java] డబుల్‌ని డిఫరెన్స్ చేయడం సాధ్యం కాదు

డి

డేవ్ టేలర్

ఒరిజినల్ పోస్టర్
నవంబర్ 6, 2007
అబెర్డీన్‌షైర్, స్కాట్లాండ్
  • జనవరి 25, 2010
కోడ్: |_+_|
సహాయం? LOL

iShater

ఆగస్ట్ 13, 2002


చికాగోలాండ్
  • జనవరి 25, 2010
మీరు అసలు లోపాన్ని పోస్ట్ చేయగలరా? మీ పద్ధతి ముగిసేలోపు మీ రిటర్న్ స్టేట్‌మెంట్ ఎందుకు? ఎస్

stanl8

డిసెంబర్ 24, 2009
మాంచెస్టర్, UK
  • జనవరి 25, 2010
అన్నింటిలో మొదటిది, మీరు ప్రయత్నించాలి
రిటర్న్ ('' + BMI);
అంటే, '+' ఆపరేటర్ సంయోగాన్ని నిర్వహిస్తుంది.

రెండవది, ఆ if స్టేట్‌మెంట్‌లు ఎప్పుడు ఎగ్జిక్యూట్ అవుతాయో నాకు అర్థం కాలేదు, ఎందుకంటే మీరు పైన రిటర్న్ స్టేట్‌మెంట్‌ని కలిగి ఉన్నందున అది ఎల్లప్పుడూ అమలు అవుతుంది డి

డేవ్ టేలర్

ఒరిజినల్ పోస్టర్
నవంబర్ 6, 2007
అబెర్డీన్‌షైర్, స్కాట్లాండ్
  • జనవరి 25, 2010
iShater చెప్పారు: మీరు అసలు లోపాన్ని పోస్ట్ చేయగలరా? మీ పద్ధతి ముగిసేలోపు మీ రిటర్న్ స్టేట్‌మెంట్ ఎందుకు? విస్తరించడానికి క్లిక్ చేయండి...

అసలైన లోపం రెట్టింపుగా ఉంది, దానిని తిరస్కరించడం సాధ్యం కాదు.

క్రోమ్యులెంట్

అక్టోబర్ 2, 2006
ది ల్యాండ్ ఆఫ్ హోప్ అండ్ గ్లోరీ
  • జనవరి 25, 2010
అన్నింటిలో మొదటిది, మీరు మీ if.. else స్టేట్‌మెంట్‌లను కొట్టే ముందు తిరిగి రావాలి అంటే వారు ఎప్పటికీ పిలవరు.

రెండవది మీ పద్ధతి రెండింతలను అందిస్తుంది, అయితే మీరు మీ if.. else స్టేట్‌మెంట్‌లలో స్ట్రింగ్‌ను తిరిగి ఇవ్వడానికి ప్రయత్నిస్తున్నారు.

మూడవదిగా toString() పద్ధతిని కాల్ చేస్తున్నప్పుడు మీరు ఆబ్జెక్ట్‌ను ఆదిమ రకం కంటే డబుల్‌ని ఉపయోగించాలి. కాబట్టి మీరు BMIని రెట్టింపుగా కాకుండా డబుల్ (java.lang.Double)గా ప్రకటించాలి.

ఇక్కడ ఒక సాధారణ ఉదాహరణ:

కోడ్: |_+_|

చౌన్33

మోడరేటర్
సిబ్బంది
ఆగస్ట్ 9, 2009
అబిస్మల్ ప్లేన్
  • జనవరి 25, 2010
DaveTaylor ఇలా అన్నారు: అసలు లోపం రెట్టింపుగా ఉంది, దానిని విస్మరించలేము. విస్తరించడానికి క్లిక్ చేయండి...

మొదట, మీరు దీన్ని చేయలేరు:
కోడ్: |_+_|
ఎందుకంటే BMI గా ప్రకటించబడింది రెట్టింపు , ఆదిమ రకం. నేను గుర్తుచేసుకున్నట్లుగా, ఈ పరిస్థితిలో జావా ఆటోబాక్సింగ్ చేయదు.

BMI గా ప్రకటించబడితే రెట్టింపు , ఆదిమ రకం కోసం రేపర్ క్లాస్, అప్పుడు అది పని చేయవచ్చు...

మీరు దీన్ని చేయలేరు తప్ప:
కోడ్: |_+_|
ఎందుకంటే జావా స్వయంచాలకంగా మీ కోసం ()లను జోడించదు. మీరు ఆబ్జెక్ట్‌పై toString పద్ధతిని అమలు చేయాలనుకుంటే, మీరు దానిని మెథడ్ ఇన్‌వోకేషన్‌గా వ్రాయాలి:
కోడ్: |_+_|
మీరు ట్యుటోరియల్ లేదా పుస్తకాన్ని ఉపయోగించకుంటే, మీరు నిజంగానే ఉండాలి.

lee1210

జనవరి 10, 2005
డల్లాస్, TX
  • జనవరి 25, 2010
నేను java.lang.String యొక్క valueOf(డబుల్) పద్ధతిని ఉపయోగించమని సూచించడం ద్వారా ఇప్పటివరకు చేసిన మంచి పరిశీలనలను జోడించాలనుకుంటున్నాను. మీరు దీన్ని అమలు చేసి, స్ట్రింగ్‌ను తిరిగి పొందవచ్చు. స్ట్రింగ్ + డబుల్ ఆపరేటర్‌ని ఉపయోగించడం కూడా బాగానే పని చేస్తుంది, అయితే మీకు రెండింతల స్ట్రింగ్ రిప్రజెంటేషన్ కావాలంటే ఇది అవసరం లేదు.

-చదవండి సి

cx300

సెప్టెంబరు 12, 2008
క్లెర్మోంట్, FL
  • జనవరి 25, 2010
నా జావా కొద్దిగా తుప్పు పట్టింది కానీ ఇది సరిగ్గా ఉండాలి...

కోడ్: |_+_|

చౌన్33

మోడరేటర్
సిబ్బంది
ఆగస్ట్ 9, 2009
అబిస్మల్ ప్లేన్
  • జనవరి 25, 2010
cx300 చెప్పారు: నా జావా కొద్దిగా తుప్పు పట్టింది కానీ ఇది సరిగ్గా ఉండాలి...

కోడ్: |_+_| విస్తరించడానికి క్లిక్ చేయండి...

గణన (బరువు/(ద్రవ్యరాశి * ద్రవ్యరాశి)) ఇతర గుణకాలు లేకుండా ఉన్నప్పుడు, ఎత్తు యూనిట్లు మీటర్లు మరియు ద్రవ్యరాశి (బరువు) యూనిట్లు కిలోగ్రాములు. ఎత్తు పూర్ణాంకాల మీటర్లు (1, 2, 3) మాత్రమే తీసుకుంటే, మీకు తీవ్రమైన ఖచ్చితత్వ సమస్య ఉంది.

http://en.wikipedia.org/wiki/Body_mass_index

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

ఈ సమస్య జావాకు ప్రత్యేకమైనదని నేను అనుకోను. పూర్ణాంకం మరియు డబుల్ అంకగణితానికి ఒకే విధమైన నియమాలను కలిగి ఉన్న Cలో మీకు ఇలాంటి సమస్యలు ఉంటాయి.