Vous pouvez faire des exposants en Java.
Crédit d'image : scyther5/iStock/GettyImages
Bien qu'il n'y ait pas d'opérateur exponentiel Java simple, vous pouvez facilement calculer un exposant en utilisant quelques méthodes différentes. Cependant, l'utilisation de la puissance en Java (Math.pow) est l'approche la plus flexible et la plus simple. Vous devez importer la classe java.lang.math avant de calculer l'exposant, mais il s'agit d'une simple ligne de code et la fonction elle-même a une syntaxe facile à utiliser. Les méthodes alternatives utilisent un pour boucle ou un appel récursif, mais ils ne fonctionnent que pour des puissances supérieures ou égales à 1, vous devriez donc essayer d'utiliser la première lorsque cela est possible.
Math.pow en Java
Le cœur de la méthode de calcul des exposants en Java est la fonction math.pow(), qui prend deux valeurs et calcule l'une à la puissance de l'autre. La syntaxe est "math.pow (base, exposant)" avec le nombre que vous voulez augmenter à la puissance où il est écrit "base" et la puissance que vous voulez qu'il augmente où il est écrit "puissance". Vous pouvez faire du résultat un entier en utilisant (int) avant la fonction, mais sans cela, il renvoie automatiquement une valeur "double" et prend les paramètres comme "double" trop.
Vidéo du jour
Calcul de l'exposant
Le processus de calcul d'un exposant Java implique essentiellement l'utilisation de cette fonction. Ouvrez votre IDE Java – Netbeans, par exemple. Pour la première ligne du code, vous importez la classe avant d'effectuer le calcul, alors tapez "import java.lang.math;" (sans les guillemets) avant de passer au calcul. Sur la ligne suivante, tapez "class" et quelque chose de descriptif après un espace, tel que "CalculatePower {" avec le crochet ouvert à la fin pour préparer le reste du code.
Sur une nouvelle ligne en retrait, écrivez "public static void main( String args[] ) {" (encore une fois sans guillemets), puis continuez le calcul. Selon le type que vous souhaitez renvoyer - soit des valeurs entières, soit des valeurs doubles, par exemple - tapez "int" ou "double" au début d'une nouvelle ligne en retrait. Tapez ensuite quelque chose de descriptif pour la réponse, comme "ans", suivi de "= (int) Math.pow (base, exposant)" en notant que si vous utilisez des valeurs doubles, tapez "(double)" au lieu de "(int)" après l'égalité signe.
Enfin, tapez "System.out.println(+ans)" sur une autre nouvelle ligne, puis exécutez la commande pour calculer l'exposant. Comme toujours, vous tapez les nombres que vous souhaitez utiliser à la place de "base" et "exposant". Donc si vous cherchez à calculer 52 sous forme d'entier, alors votre code devrait dire :
importer java.lang. Math;
classe publique CalculatePower {
public static void main( String args[] ) {
int ans = (int) Math.pow (5,2);
System.out.println(+ans);
}
}
Autres méthodes: boucle For
Vous ne pouvez utiliser les méthodes restantes que si l'exposant auquel vous augmentez le nombre est égal ou supérieur à 1. Celles-ci impliquent l'utilisation d'une boucle for et d'un appel récursif. Ces deux méthodes sont raisonnablement longues, mais vous pouvez copier du code existant plutôt que d'avoir à tout écrire vous-même. À l'aide de la méthode de boucle for, copiez le code suivant dans votre IDE Java :
package exponent_example;
classe publique Exponent_example {
public static void main (String[] args) {
nombre double = 2 ;
int exp = 3;
double réponse = Pow (num, exp);
System.out.println (réponse);
}
public statique double Pow (double num, int exp){
résultat double =1;
pour (entier i = 0; je < exp; i++) {
résultat *= num;
}
renvoyer le résultat ;
}}
Les parties "num = 2" et "exp = 3" sont celles où vous entrez le nombre de base et la puissance à laquelle vous l'augmentez, respectivement. Notez que l'exposant doit être un entier (d'où le "int" qui le précède sur la ligne), ce qui est une autre limitation de cette méthode (bien que cela ne revienne pas trop souvent). Pour utiliser ce code, remplacez ces nombres par ce que vous voulez calculer et exécutez-le.
Autres méthodes: appel récursif
L'approche finale que vous pouvez utiliser pour calculer les exposants en Java est un appel récursif. Comme pour la méthode de boucle for, vous ne pouvez le faire que pour les exposants supérieurs ou égaux à 1 et pour les valeurs entières. Copiez le code suivant et utilisez-le de la même manière :
package exponent_example;
classe publique Exponent_example {
public static void main (String[] args) {
nombre double = 3 ;
int exp = 2;
double réponse = Pow (num, exp);
System.out.println (réponse);
}
public statique double Pow (double num, double exp) {
si (exp <= 0)
retour 1 ;
return num * Pow (num, exp - 1);
}
}
