இரண்டு எண்களைப் பெருக்க ஜாவா நிரல்

ஜாவாவில் எண்கணித செயல்பாடுகளுக்காக ஒதுக்கப்பட்ட சிறப்பு ஆபரேட்டர்கள் உள்ளனர், மேலும் அவை பொதுவாக கணினி அறிவியலில் ஏற்றுக்கொள்ளப்பட்டவர்களிடமிருந்து வேறுபடுவதில்லை. குறிப்பாக, * ஆபரேட்டர் இரண்டு எண்களைப் பெருக்கப் பயன்படுகிறது. ஜாவாவில் எண்களைக் குறிக்கும் பல பழமையான தரவு வகைகள் உள்ளன. அவை அளவு, அல்லது மாறாக, அவற்றுக்கு ஒதுக்கப்பட்ட நினைவகத்தின் அளவு, அத்துடன் அவை முழு எண்கள் (int, byte, short, long) அல்லது பின்னம் (இரட்டை, மிதவை) என்பதில் வேறுபடுகின்றன. இந்த பழமையான தரவு வகைகளில் ஏதேனும் இரண்டை நீங்கள் பெருக்கலாம், கணிதத்தைப் போலவே, பின்னம் மற்றும் பின்னம் அல்லாத வெவ்வேறு அளவுகளின் எந்த எண்களையும் நாம் ஒருவருக்கொருவர் பெருக்கலாம். ஜாவாவில் இரண்டு எண்களைப் பெருக்குவதற்கான சில எடுத்துக்காட்டுகளைப் பார்ப்போம். எடுத்துக்காட்டு 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);
   }
}

வெளியீடு: உண்மையில், நீங்கள் இரண்டு முழு எண்களை ஒரு மாறிக்கு அவற்றின் மதிப்புகளை ஒதுக்காமல் வெளிப்படையாகப் பெருக்கலாம், மேலும் செயலின் முடிவைத் திரையில் காண்பிக்கலாம் அல்லது எண்ணை மாறியால் பெருக்கலாம்: எடுத்துக்காட்டு 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);
   }
}

மற்றும் வெளியீடு இங்கே: நீங்கள் பின்ன எண்களை மற்ற பின்ன எண்களால் அல்லது பின்ன எண்களை முழு எண்களால் பெருக்கலாம். ஒரு பின்னத்தை ஒரு முழு எண்ணால் பெருக்கும் செயல்பாட்டின் விளைவு பின்ன வகையாக இருக்கும் என்பதை நினைவில் கொள்ளவும். இந்த வகையான பெருக்கத்தைச் செய்ய, ஜாவா ஒரு பழமையான முழு எண் வகையை அனுப்புகிறது, எடுத்துக்காட்டாக, முழு எண்ணாக, அது பெருக்கப்படும் பின்ன எண்ணின் வகைக்கு (உதாரணமாக, இரட்டிப்பாகும்), இதன் விளைவாகவும் இரட்டிப்பாகும்.

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 மாறி சிவப்பு நிறத்தில் வரையறுக்கப்பட்டுள்ள வரியை அடிக்கோடிடும் , ஆனால் நிரலை இயக்கினால், பின்வரும் பிழைச் செய்தியைப் பெறுவோம்: எனவே உங்கள் நிரலை எழுதும் போது, ​​இந்த அல்லது அந்த தரவு வகை உங்களுக்கு போதுமானதா என்பதைப் பற்றி சிந்திக்க முயற்சிக்கவும். மேலே உள்ள எடுத்துக்காட்டில், 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);
       }
   }

இதோ முடிவு: