రెండు సంఖ్యలను గుణించడానికి జావా ప్రోగ్రామ్

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

int a = 5; int b = 10; int c = a*b; డబుల్ x = 1.2; డబుల్ y = a * x;

జావాలో రెండు సంఖ్యలను గుణించే కొన్ని ఉదాహరణలను చూద్దాం. ఉదాహరణ 1. రెండు పూర్ణాంకాల గుణకారం

public class MultiplyExample {
   public static void main(String[] args) {
       int a;
       int b;
       int c;
       a = 5;
       b = 58;
       c = a*b; //integer number to keep the result of multiplication
       System.out.println("5*58 = " + c);
   }
}

అవుట్‌పుట్:

5*58 = 290

వాస్తవానికి, మీరు రెండు పూర్ణాంకాల విలువలను వేరియబుల్‌కు కేటాయించకుండా స్పష్టంగా గుణించవచ్చు మరియు స్క్రీన్‌పై చర్య యొక్క ఫలితాన్ని ప్రదర్శించవచ్చు లేదా వేరియబుల్ ద్వారా సంఖ్యను గుణించవచ్చు: ఉదాహరణ 2. సంఖ్యల గుణకారం.

public class MultiplyExample {
   public static void main(String[] args) {
       int a;
       a = 5;
       System.out.println("7*7 = " + 7*7);
       System.out.println("a*5 = " + a*5);
   }
}

మరియు ఇక్కడ అవుట్‌పుట్ ఉంది:

7*7 = 49 a*5 = 25

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

public class MultiplyExample2 {
   public static void main(String[] args) {
       double x = 15.7;
       double y = 2.1;
       int a = 3;
       double z = x*y;
       double b = a*x;
       //if you try something like int s = a*x; your program won't run, it's a mistake.
       System.out.println(x + "*" + y + " = " + z);
       System.out.println(a + "*" + x + " = " + b);
   }
}

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

public class MultiplyExample3 {
   public static void main(String[] args) {
       short myShort1 = 32767;
       short myShort2 = 2;
       short myShort3 = myShort1*myShort2;
   }
}

IDEA వంటి ఆధునిక IDE, వేరియబుల్ myShort3 ఎరుపు రంగులో నిర్వచించబడిన పంక్తిని అండర్‌లైన్ చేస్తుంది, అయితే మనం ప్రోగ్రామ్‌ను అమలు చేస్తే, మనకు ఈ క్రింది దోష సందేశం వస్తుంది:

లోపం:(5, 34) జావా: అననుకూల రకాలు: పూర్ణాంకం నుండి సంక్షిప్తంగా మారే అవకాశం ఉంది

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

import java.util.Scanner;

public class MultiplyExample3 {

       public static void main(String[] args) {

           Scanner scanner = new Scanner(System.in);
           System.out.print("Enter first number = ");
           double myDouble1 = scanner.nextDouble();
           System.out.print("Enter second number =  ");
           double myDouble2 = scanner.nextDouble();
           scanner.close();

           double result = myDouble1*myDouble2;

           // Displaying the multiplication result
           System.out.println(myDouble1 + "*" + myDouble2 + " = " + result);
       }
   }

ఇక్కడ ఫలితం ఉంది:

మొదటి సంఖ్యను నమోదు చేయండి = 5 రెండవ సంఖ్యను నమోదు చేయండి = 12 5.0*12.0 = 60.0