ఈ బ్లాగ్ జావాలో రెండు సంఖ్యలను గుణించే విధానాలను ప్రదర్శిస్తుంది.
జావాలో రెండు సంఖ్యలను గుణించడం ఎలా?
అంకగణిత ఆపరేటర్ ' * ” జావాలో రెండు సంఖ్యలను గుణించడానికి ఉపయోగించబడుతుంది. ఈ ఆపరేటర్‌ను ఆపరాండ్‌ల మధ్య ఉంచవచ్చు మరియు సంబంధిత గుణకారాన్ని తిరిగి ఇవ్వవచ్చు.
ఉదాహరణ 1: జావాలో రెండు పూర్ణాంకాలను గుణించండి
ఈ ఉదాహరణలో, రెండు పేర్కొన్న పూర్ణాంకాలు గుణించి తిరిగి ఇవ్వబడతాయి:
int సంఖ్య1 = 3 ;
int సంఖ్య2 = 2 ;
int ఫలితం = సంఖ్య1 * సంఖ్య2 ;
వ్యవస్థ . బయటకు . println ( 'సంఖ్యల గుణకారం:' + ఫలితం ) ;
పై కోడ్ లైన్‌లలో, రెండు పూర్ణాంకాల విలువలను ప్రారంభించి, అంకగణిత ఆపరేటర్‌ని వర్తింపజేయండి ' * ” పేర్కొన్న పూర్ణాంకాలను గుణించడానికి. చివరగా, ఫలిత కంప్యూటెడ్ విలువను ప్రదర్శించండి.
అవుట్‌పుట్
అవుట్‌పుట్‌లో, సంబంధిత గుణకారం తిరిగి ఇవ్వబడిందని సూచించవచ్చు.
ఉదాహరణ 2: జావాలో రెండు ఫ్లోట్‌లను గుణించండి
ఈ ప్రత్యేక కార్యక్రమంలో, అంకగణిత ఆపరేటర్ ' * ” రెండు పేర్కొన్న ఫ్లోట్ విలువలను గుణించడానికి ఉపయోగించవచ్చు:
రెట్టింపు సంఖ్య1 = 2.5 ;రెట్టింపు సంఖ్య2 = 3.5 ;
రెట్టింపు ఫలితం = సంఖ్య1 * సంఖ్య2 ;
వ్యవస్థ . బయటకు . println ( 'సంఖ్యల గుణకారం:' + ఫలితం ) ;
పై కోడ్ స్నిప్పెట్‌లో, రకాన్ని ఇలా పేర్కొనడం ద్వారా రెండు ఫ్లోట్ విలువలను ప్రారంభించండి రెట్టింపు ”. ఆ తర్వాత, ఫ్లోట్ విలువలను గుణించి, ఫలిత ఫ్లోట్ విలువను కన్సోల్‌లో ప్రదర్శించండి.
అవుట్‌పుట్
ఉదాహరణ 3: జావాలో వినియోగదారు నిర్వచించిన సంఖ్యలను గుణించండి
ది ' nextInt() ” పద్ధతి తదుపరి ఇన్పుట్ టోకెన్‌ను పూర్ణాంకం వలె స్కాన్ చేస్తుంది. దిగువ ఉదాహరణలో, రెండు వినియోగదారు ఇన్పుట్ సంఖ్యల గుణకారం నిర్వహించబడుతుంది.
ముందుగా, ఉదాహరణకి వెళ్లే ముందు దిగువ అందించిన లైబ్రరీని చేర్చారని నిర్ధారించుకోండి:
దిగుమతి java.util.Scanner ;ఇప్పుడు, కింది కోడ్‌ను ''లో జోడిద్దాం ప్రధాన () 'పద్ధతి:
int సంఖ్య1,సంఖ్య2,ఫలితం ;స్కానర్ ఇన్పుట్ = కొత్త స్కానర్ ( వ్యవస్థ . లో ) ;
వ్యవస్థ . బయటకు . println ( 'మొదటి సంఖ్యను నమోదు చేయండి:' ) ;
సంఖ్య1 = ఇన్పుట్. తదుపరిఇంట్ ( ) ;
వ్యవస్థ . బయటకు . println ( 'రెండవ సంఖ్యను నమోదు చేయండి:' ) ;
సంఖ్య2 = ఇన్పుట్. తదుపరిఇంట్ ( ) ;
ఫలితం = సంఖ్య1 * సంఖ్య2 ;
వ్యవస్థ . బయటకు . println ( 'సంఖ్యల గుణకారం:' + ఫలితం ) ;
ఎగువ కోడ్ బ్లాక్‌లో, ఈ క్రింది దశలను వర్తించండి:
- ముందుగా, ఒక 'ని సృష్టించండి స్కానర్ 'వస్తువు' ఉపయోగించి ' కొత్త 'కీవర్డ్ మరియు' స్కానర్() ” కన్స్ట్రక్టర్, వరుసగా.
- ది ' System.in ” పారామితి వినియోగదారు నుండి ఇన్‌పుట్‌ను తీసుకుంటుంది.
- ఇప్పుడు, వినియోగదారు నుండి రెండు సంఖ్యలను ఇన్పుట్ చేయండి. అనుబంధిత ' nextInt() ” పద్ధతి వినియోగదారు ఇన్పుట్ సంఖ్యలు పూర్ణాంకాల రూపంలో ఉండేలా చూస్తుంది.
- చివరగా, అంకగణిత ఆపరేటర్ ద్వారా ఇన్పుట్ సంఖ్యలను గుణించండి ' * ” మరియు కంప్యూటెడ్ గుణకారాన్ని ప్రదర్శించండి.
అవుట్‌పుట్
ఈ ఫలితం నుండి, వినియోగదారు నిర్వచించిన సంఖ్యలు తగిన విధంగా మూల్యాంకనం చేయబడతాయని విశ్లేషించవచ్చు.
ముగింపు
అంకగణిత ఆపరేటర్ ' * ” జావాలో రెండు సంఖ్యలను గుణించడానికి ఉపయోగించబడుతుంది. ఈ సంఖ్యలు పూర్ణాంకం, ఫ్లోట్ లేదా వినియోగదారు-ఇన్పుట్ సంఖ్యలు కావచ్చు. ఈ ఆపరేటర్‌ని ఆపరాండ్‌ల మధ్య ఉంచడం ద్వారా మరియు గుణకారాన్ని తిరిగి ఇవ్వడం ద్వారా వర్తించవచ్చు. ఈ బ్లాగ్ జావాలో రెండు సంఖ్యలను గుణించే విధానాలను చర్చించింది.