Ce tuto vous aide découvrir les secrets de manipulation des types entiers en Java.

Les types entiers constituent une pierre angulaire de la programmation en Java, offrant une variété d’options pour représenter des nombres entiers. Plongeons dans les détails pour comprendre ces types, leurs caractéristiques et la manière de les manipuler efficacement.

accès rapide

• Quels sont les Types Entiers disponibles dans Java ?
• Operateurs arithmétiques et les opérations de comparaison sur entiers
• Conversion entre Types Entiers
• Les différentes bases numériques
• Exercices Pratiques
• Quiz de ce tuto

Quels sont les Types Entiers disponible dans Java ?

La démo

Java offre une variété de types entiers, chacun ayant une taille spécifique en bits et une plage de valeurs distincte. Comprendre ces types est essentiel pour manipuler efficacement les données entières dans vos programmes. Voici une exploration détaillée des principaux types entiers en Java :

1. byte (1 octet = 8 bits) : -2^7 (-128) à 2^7 – 1 (127) :

Le type byte est le plus petit des types entiers en Java. Il utilise 8 bits pour stocker les valeurs, offrant ainsi une plage de -128 à 127. Il est couramment utilisé pour économiser de l’espace mémoire lorsque la plage de valeurs est suffisante.

byte petitNombre = 42;

2. short (2 octets = 16 bits) : -2^15 (-32 768) à 2^15 – 1 (32 767):

Le type short utilise 16 bits et a une plage de -32,768 à 32,767. Bien que moins courant que les types int et long, il est utile dans des situations où l’économie d’espace est cruciale.

short nombreCourt = 32000;

3. int (4 octets = 32 bits) Plage de -2^31 à 2^31 – 1 :

L’élément de base pour les entiers en Java, le type int, utilise 32 bits pour stocker des valeurs allant de -2^31 à 2^31 – 1.

Cela représente une plage de valeurs allant de -2 147 483 648 à 2 147 483 647.

C’est le type entier le plus fréquemment utilisé dans les programmes Java.

int nombreEntier = 1000000;

4. long (8 octets = 64 bits) Plage de -2^63 à 2^63 – 1:

Le type long offre une large plage de valeurs, allant de -2^63 à 2^63 – 1.

Cela représente une plage de valeurs allant de -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807.

Il est utilisé lorsque des valeurs entières très grandes dépassent la plage des types int

long nombreLong = 1234567890123L; // Le suffixe "L" indique un littéral long

Ces types entiers sont cruciaux pour représenter des données entières dans vos programmes Java. Choisissez le type en fonction de la plage de valeurs dont vous avez besoin, en gardant à l’esprit que des types plus petits économisent de l’espace, tandis que des types plus grands offrent une plage de valeurs plus étendue.

Exemple de déclaration de variables de différents types entiers

ci-dessous un exemple contenant une déclaration des types entiers en Java :

public class Main {
    public static void main(String[] args) {
        // Déclaration et initialisation de variables entières
        byte petitNombre = 10;
        short distance = 20000;
        int age = 30;
        long population = 1000000000L;

        // Affichage des valeurs des variables
        System.out.println("Un petit nombre : " + petitNombre);
        System.out.println("Distance en mètres : " + distance);
        System.out.println("Age en années : " + age);
        System.out.println("Population : " + population);

    }
}

Explications :

1. Déclaration et initialisation des variables :
   • Nous avons déclaré et initialisé quatre variables entières : petitNombre de type byte, distance de type short, age de type int, et population de type long.
2. Affichage des valeurs des variables :
   • Nous avons utilisé System.out.println() pour afficher les valeurs des variables petitNombre, distance, age et population.

Opérateurs arithmétiques et opérations de comparaison sur entiers

La démo

1- Opérateurs arithmétiques

En Java, les opérateurs arithmétiques sont largement utilisés pour effectuer des opérations mathématiques sur les entiers. Voici une explication détaillée avec des exemples des principaux opérateurs arithmétiques :

1.1 : Addition (+) :

L’opérateur d’addition est utilisé pour ajouter deux valeurs. Par exemple :

int a = 5;
int b = 3;
int somme = a + b; // somme sera égale à 8

1.2 : Soustraction (-) :

L’opérateur de soustraction permet de soustraire une valeur d’une autre. Exemple :

int x = 10;
int y = 4;
int difference = x - y; // difference sera égale à 6

1.3 : Multiplication (*) :

L’opérateur de multiplication est utilisé pour multiplier deux valeurs. Exemple :

int p = 6;
int q = 7;
int produit = p * q; // produit sera égale à 42

1.4 : Division (/) :

L’opérateur de division divise la première valeur par la seconde. Exemple:

int m = 20;
int n = 5;
int quotient = m / n; // quotient sera égale à 4

1.5 : Modulo (%) :

L’opérateur modulo renvoie le reste de la division entre deux valeurs. Exemple :

int num1 = 17;
int num2 = 5;
int reste = num1 % num2; // reste sera égale à 2

1.6 : Opérateur d’incrémentation (++)

Préfixe (++variable) :

• Incrémente la valeur de la variable avant toute utilisation.
• Explication : L’opération d’incrémentation est effectuée avant que la valeur soit utilisée dans une expression ou assignée à une autre variable. Dans cet exemple, b prend la valeur de a après son incrémentation.

int a = 5;
int b = ++a;  // Après cette ligne, b est égal à 6, a est également égal à 6

Suffixe (variable++) :

• Utilise la valeur actuelle de la variable dans une expression, puis incrémente la variable.
• Explication : L’opération d’incrémentation est effectuée après que la valeur actuelle de la variable est utilisée dans l’expression. Dans cet exemple, c prend la valeur de a avant son incrémentation.

int a = 5;
int c = a++;  // Après cette ligne, c est égal à 5 (valeur avant l'incrémentation), a est maintenant égal à 6

1.7 : Opérateur de décrémentation (- -)

Préfixe (–variable) :

• Décrémente la valeur de la variable avant toute utilisation.
• Explication : L’opération de décrémentation est effectuée avant que la valeur soit utilisée dans une expression ou assignée à une autre variable. Dans cet exemple, y prend la valeur de x après sa décrémentation.

int x = 8;
int y = --x;  // Après cette ligne, y est égal à 7, x est également égal à 7

Suffixe (variable–) :

• Utilise la valeur actuelle de la variable dans une expression, puis décrémente la variable.
• Explication : L’opération de décrémentation est effectuée après que la valeur actuelle de la variable est utilisée dans l’expression. Dans cet exemple, z prend la valeur de x avant sa décrémentation.

int x = 8;
int z = x--;  // Après cette ligne, z est égal à 8 (valeur avant la décrémentation), x est maintenant égal à 7

Ces opérateurs arithmétiques sont fondamentaux pour effectuer des calculs mathématiques simples en Java, que ce soit pour des applications financières, des jeux ou d’autres domaines où des opérations arithmétiques sur les entiers sont nécessaires.

2- Opérateurs de comparaisons

Les opérateurs de comparaison en Java sont utilisés pour comparer des valeurs et produire un résultat booléen (true ou false) en fonction de la relation entre ces valeurs. Voici une explication détaillée des principaux opérateurs de comparaison pour le type entier :

2-1 : Égalité (==) :

L’opérateur d’égalité compare deux valeurs pour déterminer si elles sont égales. Par exemple :

int a = 5;
int b = 7;
boolean estEgal = (a == b); // estEgal sera false

2-2 : Inégalité (!=) :

L’opérateur d’inégalité teste si deux valeurs ne sont pas égales. Exemple :

int x = 10;
int y = 10;
boolean estDifferent = (x != y); // estDifferent sera false

2-3 : Supérieur (>) et Inférieur (<) :

Ces opérateurs comparent si une valeur est strictement supérieure ou inférieure à une autre. Exemple :

int p = 15;
int q = 12;
boolean estSuperieur = (p > q); // estSuperieur sera true

2-4 : Supérieur ou égal (>=) et Inférieur ou égal (<=) :

Ces opérateurs vérifient si une valeur est supérieure ou égale, ou inférieure ou égale à une autre. Exemple :

int m = 8;
int n = 8;
boolean estSuperieurOuEgal = (m >= n); // estSuperieurOuEgal sera true

2-5 : Comparaisons avec les opérateurs logiques :

Vous pouvez combiner des comparaisons à l’aide d’opérateurs logiques pour former des expressions logiques.

int age = 25;
boolean estDansLaTranche18a65 = (age >= 18 && age <= 65); // estDansLaTranche18a65 sera true

Il est important de noter que ces opérateurs de comparaison sur les entiers produisent un résultat de type boolean (true ou false), ce qui les rend particulièrement utiles dans les expressions conditionnelles et les structures de contrôle de flux.

Conversion entre Types Entiers

La démo

La conversion entre types entiers en Java peut être nécessaire dans certaines situations pour assurer la compatibilité des types. Explorons des exemples concrets de conversion entre types entiers, en se concentrant uniquement sur des entiers.

1. Conversion Implicite

La conversion implicite se produit automatiquement lorsque vous stockez une valeur d’un type dans une variable d’un autre type compatible. Aucune perte de données n’est possible dans ce cas. Exemple :

int entier = 42;
long longEntier = entier;  // Conversion implicite d'int à long

Ici, la valeur entière entier est automatiquement convertie en long sans risque de perte de données.

2. Conversion Explicite (Casting)

La conversion explicite, ou casting, se produit lorsque vous effectuez une conversion entre des types incompatibles. Vous devez informer explicitement le compilateur de votre intention. Cela peut entraîner une perte de données si la plage de valeurs du type source dépasse celle du type cible. Exemple :

int entier = 1000;
short petitEntier = (short) entier;  // Conversion explicite d'int à short

Dans cet exemple, la valeur entière entier est explicitement convertie en short à l’aide de (short). Cela pourrait entraîner une perte de données si la valeur dépasse la plage autorisée pour short.

Exemples Complets

Voici un exemple complet combinant les deux types de conversion :

Exemple de conversion sans perte de données

public class ConversionTypes {

    public static void main(String[] args) {
    
        // Conversion implicite
        int entier = 42;
        long longEntier = entier;  // Conversion implicite d'int à long
        
        // Conversion explicite (casting) avec perte de données
        int entierSource = 1000;
        short petitEntier = (short) entierSource;  // Conversion explicite d'int à short
        
        // Affichage des résultats
        System.out.println("Conversion implicite : " + longEntier);
        System.out.println("Conversion explicite : " + petitEntier);
        
        // Explications
        System.out.println("\nExplications :");
        System.out.println("1. Conversion implicite :");
        System.out.println("   - int à long : Aucune perte de données, la valeur reste la même.");
        System.out.println("\n2. Conversion explicite :");
        System.out.println("   - int à short : Perte de données possible si la valeur dépasse la plage autorisée pour short.");
        System.out.println("                  Dans cet exemple, la valeur initiale est 1000, qui est dans la plage autorisée pour short,");
        System.out.println("                  donc aucune perte de données n'a lieu.");

    }
}

Résultats d’affichage :

Conversion implicite : 42
Conversion explicite : 1000

Explications :
1. Conversion implicite :
   - int à long : Aucune perte de données, la valeur reste la même.

2. Conversion explicite :
   - int à short : Perte de données possible si la valeur dépasse la plage autorisée pour short.
                  Dans cet exemple, la valeur initiale est 1000, qui est dans la plage autorisée pour short,
                  donc aucune perte de données n'a lieu.

Dans cet exemple, la conversion implicite ne provoque aucune perte de données, car nous passons d’un type plus petit (int) à un type plus grand (long). La conversion explicite, de int à short, peut potentiellement entraîner une perte de données si la valeur initiale dépasse la plage autorisée pour short. Cependant, dans cet exemple, la valeur initiale est dans la plage autorisée, évitant ainsi toute perte de données.

Exemple de conversion avec perte de données

Dans l’exemple complet ci-dessous, la conversion explicite de int à short entraîne une perte de données, car la plage de valeurs autorisée pour le type short est plus restreinte que celle du type int.

public class ConversionTypes {

    public static void main(String[] args) {
    
        // Conversion explicite (casting) avec perte de données
        int entierSource = 150000;
        short petitEntier = (short) entierSource;  // Conversion explicite d'int à short
        
        // Affichage des résultats
        System.out.println("Conversion explicite avec perte de données : " + petitEntier);
        
        // Explication
        System.out.println("\nExplication :");
        System.out.println("La valeur initiale est " + entierSource + ", qui dépasse la plage autorisée pour short.");
        System.out.println("Lors de la conversion explicite (casting) de int à short, une perte de données se produit,");
        System.out.println("car le type short peut uniquement stocker des valeurs dans la plage de -32768 à 32767.");
        System.out.println("La valeur résultante est tronquée pour s'adapter à la plage de short, entraînant la perte de données.");
    }
}

Résultat d’affichage avec perte de données :

Conversion explicite avec perte de données : 18928

Explication :
La valeur initiale est 150000, qui dépasse la plage autorisée pour short.
Lors de la conversion explicite (casting) de int à short, une perte de données se produit,
car le type short peut uniquement stocker des valeurs dans la plage de -32768 à 32767.
La valeur résultante est tronquée pour s'adapter à la plage de short, entraînant la perte de données.

Dans cet exemple, la valeur initiale 150000 excède la plage autorisée pour le type short, qui est de -32768 à 32767. Lors de la conversion explicite de int à short, la valeur est tronquée pour s’adapter à la plage de short, entraînant ainsi une perte de données. La valeur résultante est 18928 , qui est le résultat de la troncature de la valeur initiale.

3. Dépassement de capacité (Overflow et Underflow)

Le dépassement de capacité (ou overflow) et le dépassement de capacité négative (ou underflow) se produisent lorsque le résultat d’une opération dépasse la plage de valeurs pouvant être représentées par un type de données particulier. Cela se produit souvent avec les types entiers lorsque le résultat de l’opération est plus grand que la valeur maximale positive ou plus petit que la valeur minimale négative que le type de données peut représenter.

Voici un exemple d’overflow en Java :

public class Main {
    public static void main(String[] args) {
        int nombre = Integer.MAX_VALUE; // Valeur maximale d'un int
        System.out.println("Valeur initiale : " + nombre);
        
        nombre = nombre + 1; // Tentative d'augmenter la valeur au-delà de la plage autorisée
        System.out.println("Valeur après l'opération : " + nombre);
    }
}

Dans cet exemple, nous essayons d’incrémenter une variable nombre contenant la valeur maximale possible pour un entier en Java (Integer.MAX_VALUE). Cependant, lorsque nous ajoutons 1 à cette valeur, cela dépasse la plage de valeurs autorisée pour un int, ce qui entraîne un overflow. En conséquence, la valeur de nombre devient la plus petite valeur négative possible pour un int (Integer.MIN_VALUE), créant un comportement imprévu dans le programme.

Voici un exemple d’underflow en Java :

public class Main {
    public static void main(String[] args) {
        int nombre = Integer.MIN_VALUE; // Valeur minimale d'un int
        System.out.println("Valeur initiale : " + nombre);
        
        nombre = nombre - 1; // Tentative de diminuer la valeur en dessous de la plage autorisée
        System.out.println("Valeur après l'opération : " + nombre);
    }
}

Dans cet exemple, nous essayons de décrémenter une variable nombre contenant la valeur minimale possible pour un entier en Java (Integer.MIN_VALUE). Cependant, lorsque nous soustrayons 1 de cette valeur, cela dépasse la plage de valeurs autorisée pour un int du côté négatif, ce qui entraîne un underflow. En conséquence, la valeur de nombre devient la plus grande valeur positive possible pour un int (Integer.MAX_VALUE), créant un comportement imprévu dans le programme.

Il est important de prendre en compte ces scénarios lors de la manipulation des types entiers en Java pour éviter les erreurs potentielles dans le programme.

Les différentes bases numériques

La démo

Binaire (Base 2)

En Java, pour représenter un nombre en base 2 (binaire), vous pouvez préfixer le nombre avec 0b ou 0B. Exemple :

public class BinaireExample {

    public static void main(String[] args) {
        int binaire = 0b101010;  // Représentation binaire du nombre 42
        System.out.println("En binaire : " + binaire);
    }
}

Dans cet exemple, 0b101010 représente le nombre 42 en base 10 (décimal).

0b101010 représente le nombre binaire où chaque chiffre est une puissance de 2. En décimal, cela équivaut à 1*2^5 + 0*2^4 + 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 42.

Octal (Base 8)

Pour représenter un nombre en base 8 (octal) en Java, vous pouvez le préfixer avec un zéro. Exemple :

public class OctalExample {

    public static void main(String[] args) {
        int octal = 052;  // Représentation octale du nombre 42
        System.out.println("En octal : " + octal);
    }
}

Dans cet exemple, 052 représente le nombre 42 en base 10 (décimal).

052 représente le nombre octal où chaque chiffre est une puissance de 8. En décimal, cela équivaut à 5*8^1 + 2*8^0 = 42.

Décimale

En Java, la base décimale est la base par défaut, et les nombres sont généralement représentés sans préfixe. Voici un exemple pour illustrer la représentation d’un nombre en base décimale :

public class DecimalExample {

    public static void main(String[] args) {
        int decimal = 42;  // Représentation décimale du nombre 42
        System.out.println("En décimal : " + decimal);
    }
}

Dans cet exemple, 42 est représenté en base décimale. C’est le format standard pour les nombres entiers en Java. La base décimale est implicite et ne nécessite aucun préfixe particulier.

La base décimale est celle que nous utilisons couramment au quotidien. Chaque chiffre d’un nombre en base 10 représente une puissance de 10. En décimal, 42 équivaut à 4*10^1 + 2*10^0 = 40 + 2 = 42.

Hexadécimal (Base 16)

Pour représenter un nombre en base 16 (hexadécimal) en Java, vous pouvez le préfixer avec 0x ou 0X. Exemple :

public class HexadecimalExample {

    public static void main(String[] args) {
        int hexa = 0x2A;  // Représentation hexadécimale du nombre 42
        System.out.println("En hexadécimal : " + hexa);
    }
}

Dans cet exemple, 0x2A représente le nombre 42 en base 10 (décimal).

0x2A représente le nombre hexadécimal où chaque chiffre est une puissance de 16. En décimal, cela équivaut à 2*16^1 + 10*16^0 = 42.

Dans ce tuto , nous avons connu et manipuler les types entiers en Java.

Espérons bien que ce tuto vous a plu. Dans le tuto suivant nous allons découvrir le type flottant en Java

1. Conversion de Décimal vers les Autres Bases

• En Java, vous pouvez convertir un nombre décimal en binaire, octal et hexadécimal à l’aide des méthodes prédéfinies de la classe Integer.
• toBinaryString(int n) : Convertit un nombre décimal en une chaîne représentant sa valeur en binaire.
• toOctalString(int n) : Convertit un nombre décimal en une chaîne représentant sa valeur en octal.
• toHexString(int n) : Convertit un nombre décimal en une chaîne représentant sa valeur en hexadécimal.

Exemple :

int decimalNumber = 42;

String binaryNumber = Integer.toBinaryString(decimalNumber);
String octalNumber = Integer.toOctalString(decimalNumber);
String hexadecimalNumber = Integer.toHexString(decimalNumber);

System.out.println("Binaire : " + binaryNumber);
System.out.println("Octal : " + octalNumber);
System.out.println("Hexadécimal : " + hexadecimalNumber);

2. Conversion des Autres Bases vers Décimal

• Pour convertir un nombre d’une autre base vers décimal, vous pouvez utiliser la méthode parseInt() de la classe Integer.
• Cette méthode prend en paramètre la chaîne représentant le nombre dans la base spécifiée et la base de ce nombre.

Exemple :

String binaryNumber = "101010";
String octalNumber = "52";
String hexadecimalNumber = "2a";

int decimalFromBinary = Integer.parseInt(binaryNumber, 2);
int decimalFromOctal = Integer.parseInt(octalNumber, 8);
int decimalFromHexadecimal = Integer.parseInt(hexadecimalNumber, 16);

System.out.println("Décimal depuis binaire : " + decimalFromBinary);
System.out.println("Décimal depuis octal : " + decimalFromOctal);
System.out.println("Décimal depuis hexadécimal : " + decimalFromHexadecimal);

La conversion entre différentes bases numériques est une compétence importante en programmation. En Java, vous pouvez effectuer ces conversions facilement en utilisant les méthodes prédéfinies de la classe Integer. En comprenant comment ces conversions fonctionnent, vous pouvez manipuler efficacement les nombres dans différentes bases pour répondre aux besoins de votre application.

Exercices Pratiques

La démo

1. Addition et Soustraction :

Écrivez un programme Java qui demande à l’utilisateur d’entrer deux nombres entiers, puis affiche la somme et la différence de ces deux nombres.

Correction

import java.util.Scanner;

public class AdditionSoustraction{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Demander à l'utilisateur d'entrer les deux nombres
        System.out.print("Entrez le premier nombre : ");
        int num1 = scanner.nextInt();
        
        System.out.print("Entrez le deuxième nombre : ");
        int num2 = scanner.nextInt();
        
        // Calculer la somme et la différence
        int sum = num1 + num2;
        int difference = num1 - num2;
        
        // Afficher les résultats
        System.out.println("La somme est : " + sum);
        System.out.println("La différence est : " + difference);
        
        scanner.close();
    }
}

Entrez le premier nombre : 10
Entrez le deuxième nombre : 5
La somme est : 15
La différence est : 5

2. Multiplication et Division :

Écrivez un programme Java qui demande à l’utilisateur d’entrer deux nombres entiers, puis affiche leur produit et le résultat de leur division.

Correction

import java.util.Scanner;

public class MultiplicationDivision{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Demander à l'utilisateur d'entrer les deux nombres
        System.out.print("Entrez le premier nombre : ");
        int num1 = scanner.nextInt();
        
        System.out.print("Entrez le deuxième nombre : ");
        int num2 = scanner.nextInt();
        
        // Calculer le produit et la division
        int product = num1 * num2;
        int division = num1 / num2; // Division entière
        
        // Afficher les résultats
        System.out.println("Le produit est : " + product);
        System.out.println("Le résultat de la division est : " + division);
        
        scanner.close();
    }
}

Entrez le premier nombre : 10
Entrez le deuxième nombre : 2
Le produit est : 20
Le résultat de la division est : 5

3. Conversion de Température :

Écrivez un programme Java qui demande à l’utilisateur d’entrer une température en degrés Celsius, puis convertit cette température en degrés Fahrenheit et l’affiche.

Correction

import java.util.Scanner;

public class ConversionTemperature{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Demander à l'utilisateur d'entrer la température en Celsius
        System.out.print("Entrez la température en degrés Celsius : ");
        double celsius = scanner.nextDouble();
        
        // Convertir la température en Fahrenheit
        double fahrenheit = (celsius * 9 / 5) + 32;
        
        // Afficher la température en Fahrenheit
        System.out.println("La température en Fahrenheit est : " + fahrenheit);
        
        scanner.close();
    }
}

Entrez la température en degrés Celsius : 20
La température en Fahrenheit est : 68.0

4. Vérification de Parité :

Écrivez un programme Java qui demande à l’utilisateur d’entrer un nombre entier, puis vérifie si ce nombre est pair ou impair et affiche le résultat.

Correction

import java.util.Scanner;

public class VerifParite{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Demander à l'utilisateur d'entrer un nombre entier
        System.out.print("Entrez un nombre entier : ");
        int number = scanner.nextInt();
        
        // Vérifier si le nombre est pair ou impair
        if (number % 2 == 0) {
            System.out.println(number + " est un nombre pair.");
        } else {
            System.out.println(number + " est un nombre impair.");
        }
        
        scanner.close();
    }
}

Entrez un nombre entier : 7
7 est un nombre impair.

5. Conversion de Bases Numériques :

Écrivez un programme Java qui demande à l’utilisateur d’entrer un nombre entier en base 10, puis convertit ce nombre en binaire, octal et hexadécimal, et affiche les résultats.

Correction

import java.util.Scanner;

public class ConversionBaseNumerique{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Demander à l'utilisateur d'entrer un nombre entier en base 10
        System.out.print("Entrez un nombre entier en base 10 : ");
        int decimalNumber = scanner.nextInt();
        
        // Convertir en binaire, octal et hexadécimal
        String binaryNumber = Integer.toBinaryString(decimalNumber);
        String octalNumber = Integer.toOctalString(decimalNumber);
        String hexadecimalNumber = Integer.toHexString(decimalNumber);
        
        // Afficher les résultats
        System.out.println("Le nombre en binaire est : " + binaryNumber);
        System.out.println("Le nombre en octal est : " + octalNumber);
        System.out.println("Le nombre en hexadécimal est : " + hexadecimalNumber);
        
        scanner.close();
    }
}

Entrez un nombre entier en base 10 : 42
Le nombre en binaire est : 101010
Le nombre en octal est : 52
Le nombre en hexadécimal est : 2a

Quiz de ce tuto

Vous pouvez tester que vous avez bien assimiler tous ce que nous avons appris ensemble via ce quiz 🙂 🙂 amusez vous bien.

/13

1 votes, 4 avg

60

Créé le février 04, 2024

Quiz JAVA SE : MANIPULATION DES TYPES ENTIERS

Ce quiz vous aide à améliorer vos connaissances en Java SE 🙂 🙂 

1 / 13

1. Quel est le résultat de l'expression 10 % 3 en Java ?

a) 1

b) 3

c) 0

d) 0.333

2 / 13

2. Quelle est la plage de valeurs d'un type de données int en Java ?

a) -128 à 127

b) -32768 à 32767

c) -2^31 à 2^31-1

d) -2^63 à 2^63-1

3 / 13

3. Quelle est la syntaxe correcte pour déclarer une variable numEntier de type entier en Java ?

a) int numEntier;

b) numEntier int;

c) entier numEntier;

d) variable numEntier = int;

4 / 13

4. Comment déclarer une variable de type short avec une valeur initiale de 50 en Java ?

a) short num = 50;

b) short num = 50.0;

c) short num = (short) 50;

d) short num = "50";

5 / 13

5. Quelle est la valeur maximale d'un type de données byte en Java ?

a) 127

b) 255

c) 32767

d) 128

6 / 13

6. Quels sont les types de données entiers primitifs en Java ?

a) int, double, long, byte

b) int, short, float, char

c) int, long, short, byte

d) float, double, char, byte

7 / 13

7.

19. Comment déclarer une variable x de type byte et lui attribuer la valeur 128 ?

a) byte x = 128;

b) byte x = (byte) 128;

c) byte x = 128B;

d) byte x = (byte) 128B;

8 / 13

8. Quelle est la différence entre les déclarations int num1, num2; et int num1; int num2; en Java ?

a) Aucune différence, les deux déclarations sont équivalentes.

b) La première déclaration initialise les variables à zéro, tandis que la seconde ne les initialise pas.

c) La première déclaration initialise les variables à null, tandis que la seconde ne les initialise pas.

d) La première déclaration est invalide en Java.

9 / 13

9. Quelle est la valeur par défaut d'une variable entière déclarée en Java sans initialisation explicite ?

a) La valeur null.

b) La valeur 0.

b) La valeur 1.

d) La valeur false.

10 / 13

10. Quelle est la représentation en base 16 (hexadécimale) de l'entier 42 en Java ?

a) 42

b) 2A

c) 101010

d) 52

11 / 13

11. Quel est le résultat de l'expression 5 / 2 en Java si les opérandes sont de type int ?

a) 2.5

b) 2

c) 2.0

d) 2.5 avec une exception

12 / 13

12. Peut-on déclarer une variable int et lui attribuer une valeur 3.14 en Java ?

a) Oui

b) Non

13 / 13

13. Quelle est la sortie de l'expression 5 == 5 en Java ?

a) true

b) false

Votre note est de

LinkedIn Facebook Twitter VKontakte

0%

Relancer le quiz

Veuillez évaluer ce quiz

Envoyer les commentaires