Comment calculer les exposants en Java

Bien qu'il n'existe pas d'opérateur exponentiel simple en Java, vous pouvez facilement calculer un exposant en utilisant plusieurs méthodes. Cependant, l'utilisation de la puissance en Java (Math.pow) est l'approche la plus flexible et la plus directe. Vous devez importer la classe java.lang.Math avant de calculer l'exposant, mais c'est une simple ligne de code, et la fonction elle-même a une syntaxe facile à utiliser. Les méthodes alternatives utilisent une boucle for ou un appel récursif, mais elles ne fonctionnent que pour des puissances supérieures ou égales à 1, donc vous devriez essayer d'utiliser la première méthode lorsque c'est possible.

Math.pow en Java

Le cœur de la méthode pour calculer les 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 élever à la puissance où il est indiqué "base" et la puissance souhaitée où il est indiqué "exposant". Vous pouvez rendre le résultat entier en utilisant (int) avant la fonction, mais sans cela, elle renvoie automatiquement une valeur "double" et prend les paramètres comme "double" aussi.

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 de code, vous importez la classe avant d'effectuer le calcul, donc tapez "import java.lang.Math;" (sans guillemets) avant de passer au calcul. Sur la ligne suivante, tapez "class" et quelque chose de descriptif après un espace, comme "CalculPuissance {" avec l'accolade ouvrante à la fin pour préparer le reste du code.

Sur une nouvelle ligne indentée, écrivez "public static void main( String args[] ) {" (à nouveau sans guillemets), puis continuez avec le calcul. Selon le type que vous voulez retourner – valeurs entières ou doubles, par exemple – tapez soit "int" soit "double" au début d'une nouvelle ligne indentée. Ensuite, tapez quelque chose de descriptif pour la réponse comme "resultat", suivi de "= (int) Math.pow(base, exposant)" en notant que si vous utilisez des valeurs double, tapez "(double)" au lieu de "(int)" après le signe égal.

Enfin, tapez "System.out.println(+resultat)" sur une autre nouvelle ligne, puis exécutez la commande pour calculer l'exposant. Comme toujours, vous tapez les nombres que vous voulez utiliser à la place de "base" et "exposant". Donc si vous cherchez à calculer 5² en entier, votre code devrait dire :

import java.lang.Math;

public class CalculPuissance {

    public static void main( String args[] ) {
        int resultat = (int) Math.pow(5,2);
        System.out.println(+resultat);
    }
}

Autres méthodes : Boucle for

Vous ne pouvez utiliser les méthodes restantes que si l'exposant auquel vous élevez le nombre est 1 ou plus. 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 de tout écrire vous-même. En utilisant la méthode de la boucle for, copiez le code suivant dans votre IDE Java :

package exemple_exposant;

public class Exemple_exposant {
    public static void main(String[] args) {
        double nombre = 2;
        int exp = 3;
        double reponse = Puissance(nombre, exp);
        System.out.println(reponse);
    }

    public static double Puissance(double nombre, int exp){
        double resultat = 1;
        for (int i = 0; i < exp; i++) {
            resultat *= nombre;
        }
        return resultat;
    }
}

Les parties "nombre = 2" et "exp = 3" sont où vous entrez le nombre de base et la puissance respective. Notez que l'exposant doit être un entier (d'où le "int" avant sur la ligne), ce qui est une autre limitation de cette méthode (bien que cela ne se produise pas trop souvent). Pour utiliser ce code, changez ces nombres par ce que vous voulez calculer et exécutez-le.

Autres méthodes : Appel récursif

La dernière approche pour calculer les exposants en Java est un appel récursif. Comme la méthode de la boucle for, vous ne pouvez le faire que pour des exposants supérieurs ou égaux à 1 et pour des valeurs entières. Copiez le code suivant et utilisez-le de la même manière :

package exemple_exposant;

public class Exemple_exposant {
    public static void main(String[] args) {
        double nombre = 3;
        int exp = 2;
        double reponse = Puissance(nombre, exp);
        System.out.println(reponse);
    }

    public static double Puissance(double nombre, double exp) {
        if (exp <= 0)
            return 1;
        return nombre * Puissance(nombre, exp - 1);
    }
}