Java-programma om twee getallen te vermenigvuldigen

Er zijn speciale operatoren gereserveerd voor rekenkundige bewerkingen in Java, en deze verschillen niet van de algemeen aanvaarde in de informatica. In het bijzonder wordt de operator * gebruikt om twee getallen te vermenigvuldigen. Java heeft verschillende primitieve gegevenstypen die getallen vertegenwoordigen. Ze verschillen in grootte, of beter gezegd, in de hoeveelheid geheugen die ervoor is toegewezen, en ook in het feit of ze gehele getallen (int, byte, short, long) of fractioneel (dubbel, float) zijn. Je kunt elke twee van deze primitieve gegevenstypen vermenigvuldigen, zoals we in de wiskunde elk getal van verschillende groottes, fractioneel en niet-fractionele, met elkaar kunnen vermenigvuldigen. Laten we eens kijken naar enkele voorbeelden van het vermenigvuldigen van twee getallen in Java. Voorbeeld 1. Vermenigvuldiging van twee gehele getallen

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);
   }
}

De uitvoer is: In feite kunt u twee gehele getallen expliciet vermenigvuldigen zonder hun waarde toe te wijzen aan een variabele, en het resultaat van de actie op het scherm weergeven, of het getal vermenigvuldigen met een variabele: Voorbeeld 2. Vermenigvuldiging van getallen.

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);
   }
}

En hier is de uitvoer: Je kunt getallen met breuken ook vermenigvuldigen met andere getallen met breuken of getallen met breuken met gehele getallen. Houd er rekening mee dat het resultaat van de bewerking van het vermenigvuldigen van een breuk met een geheel getal van het breuktype zal zijn. Om dit soort vermenigvuldiging uit te voeren, cast Java een primitief integer-type, bijvoorbeeld int, naar het type van het breukgetal waarmee het wordt vermenigvuldigd (bijvoorbeeld double), en het resultaat zal ook double zijn.

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);
   }
}

Vermenigvuldiging is een zeer eenvoudige handeling, maar moet met zorg worden gebruikt. U kunt bijvoorbeeld een resultaattype voor vermenigvuldiging toewijzen dat te kort is, en het resultaat past gewoon niet in deze variabele. Laten we de variabele kort nemen gelijk aan 32767. Dit is de bovengrenswaarde voor een variabele van dit type (het getal 32768 kan niet langer kort zijn, aangezien het niet past in de 2 bytes die voor dit gegevenstype zijn toegewezen). Laten we een voorbeeld bekijken:

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

Een moderne IDE, zoals IDEA, onderstreept de regel waarin de variabele myShort3 is gedefinieerd in rood, maar als we het programma uitvoeren, krijgen we de volgende foutmelding: Probeer dus bij het schrijven van uw programma na te denken of dit of dat gegevenstype voldoende voor u is. In het geval van het bovenstaande voorbeeld is int geschikt. U kunt ook een meer algemeen programma schrijven met gebruikersinvoer van twee cijfers:

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);
       }
   }

Hier is het resultaat: