Exercices sur les classes, les variables, les types et les opérateurs #

En Java, les entiers sont représentés en binaire selon le format « complément à deux ». Ainsi, -1 est représenté par une suite de bits où tous les bits sont à 1. Par exemple, pour un int (32 bits), -1 correspond à 0xFFFFFFFF en hexadécimal, soit 32 bits à 1.

En Java, -0.0 == 0.0 retourne true car la comparaison d’égalité (==) considère ces deux valeurs comme égales selon la norme IEEE 754. Cependant, il existe une différence binaire entre -0.0 et 0.0 (le signe du zéro), ce qui peut être détecté avec certaines méthodes comme Double.doubleToRawLongBits() ou en utilisant 1.0 / -0.0 (qui donne -Infinity), alors que 1.0 / 0.0 donne Infinity.

0xA représente 10 en décimal, donc 0xA + 10 vaut 20.

Un débordement se produit lorsqu’une opération arithmétique dépasse la valeur maximale ou minimale qu’un type peut représenter. Par exemple, un int en Java varie de -2 147 483 648 à 2 147 483 647. Si on additionne 1 à la valeur maximale, on « retourne » à la valeur minimale.

int max = Integer.MAX_VALUE;
System.out.println(max);         // 2147483647
System.out.println(max + 1);     // -2147483648 (débordement)

Nom corrects : 1, 2, 4, 5, 6. En effet, vous pouvez utiliser var comme nom de variable.

Nom conseillé : 6. En effet à moins d’avoir de sérieuses raisons de faire autrement, il faut utiliser les minuscules pour les noms de variables simples en java, et les majuscules pour articuler les noms de variables composés comme monEntier. Le mot var est déconseillé puisque c'est un mot-clé contextuel.

On utilise le préfixe 0x pour écrire un nombre en hexadécimal. Exemple :

int x = 0xFF; // 255 en décimal
System.out.println(x); // Affiche 255

La notation hexadécimale est utile pour manipuler des valeurs binaires, des couleurs, des adresses mémoire, etc.

Bonne réponse : 2.

Explication : (i=5) est une expression dont la résultat est la valeur affectée à i, c’est-à-dire 5. Ce résultat est multiplié par deux et affecté à k, puis affecté à myInt.

La fonction retourne la valeur qui était contenue dans la variable x au début de la fonction. Voir l'article wikipédia sur les techniques de permutation en informatique.

-1 et 268435455.

La fonction retourne la valeur vraie si et seulement si un seul des deux paramètres est négatif. Par exemple, f(-1,1) est vrai, f(2,2) et f(-1,-3) sont faux.

Faux. Définissez int x = -2147483648. Vous trouvez alors que -x == x.

L'expression 2083697005*101 est égale à 1. Cela s'explique par le fait que les entiers sont stockés avec 32 bits seulement et que la véritable valeur (210453397505) ne peut pas être représentée. Java tronque le résultat.

On peut la calculer avec l'expression y+(x - y)/2. Il pourrait être tentant d'utiliser l'expression (x + y)/2, mais cette dernière est incorrecte comme vous pouvez le vérifier avec ce programme:

class Main {
  public static void main(String[] args) {
    int x = 2147483647;
    int y = 2147483645;

    System.out.println((x+y)/2);
    System.out.println(y+(x - y)/2);
  }
}

En Java, les chaînes de caractères sont immutables, elles ne peuvent être modifiées. On ne peut donc pas modifier la valeur assigné à s. Par contre, on peut créer une nouvelle chaîne de caractères et réassigner la variable à cette nouvelle valeur (s = "1234";).

En informatique, on définit l’ensemble des nombres positifs comme étant les nombres plus grands que zéro. Les nombres négatifs sont les nombres plus petits que zéro. Les nombres non négatifs sont donc les nombres positifs ou nuls.

Dans le cas qui nous concerne, il n'est pas possible de distinguer 0.8825149536132812 et 0.8825149536132813, des nombres à 16 chiffres significatifs. En général, il est possible de représenter l'ensemble des nombres entre -10 à la puissance 308 et 10 à la puissance 308 avec 15 chiffres de précision, mais pas 16 chiffres de précision. Les nombres 0.8825149536132812 et 0.8825149536132813 sont représentés en nombre à virgule flottante comme étant 115673 fois 2 à la puissance -17 ce qui est le nombre 0.88251495361328125.

for (int i = 0; i <= 20; i += 2) {
    System.out.println(i);
}

En Java, l'expression 1.0 / 0.0 retourne Infinity (l'infini positif), car la division par zéro avec des nombres à virgule flottante (double) ne provoque pas d'exception, mais retourne une valeur spéciale représentant l'infini.

En Java, l'expression 1 / 0 provoque une erreur de type division par zéro, car la division entière par zéro n'est pas définie.

== compare les références (adresses en mémoire), alors que equals() compare le contenu des chaînes. Il faut utiliser equals() pour vérifier si deux chaînes ont le même texte.

L’opérateur + concatène les chaînes et convertit automatiquement les nombres en chaînes si l’un des opérandes est une chaîne.

Exemple :

String s = "Valeur : " + 10 + 5; // "Valeur : 105"

L’expression s’évalue de gauche à droite : 1 + 2 donne 3, puis 3 + "3" donne "33" (concaténation), puis "33" + 4 donne "334", puis "334" + 5 donne "3345". La valeur finale est "3345".

On utilise la méthode substring(debut, fin) pour obtenir une sous-chaîne allant de l’indice debut (inclus) à fin (exclu).

Exemple :

String texte = "Bonjour";
String sous = texte.substring(0, 3); // "Bon"

On utilise startsWith() pour vérifier le début, et endsWith() pour la fin.

Exemple :

String phrase = "Bonjour le monde";
System.out.println(phrase.startsWith("Bon")); // true
System.out.println(phrase.endsWith("monde")); // true

Une classe enveloppe permet de manipuler un type primitif comme un objet. Exemple :

String s = "123";
int n = Integer.parseInt(s); // n vaut 123

int est un type primitif, alors que Integer est une classe objet qui encapsule un int. /p>

L’expression retourne false. Chaque appel à new Integer(3) crée un nouvel objet distinct en mémoire : les deux objets ont la même valeur mais ne sont pas le même objet. L’opérateur == compare les références (adresses) des objets, pas leur contenu. Pour comparer la valeur, il faut utiliser equals() :

System.out.println(new Integer(3).equals(new Integer(3))); // true

Avantages : portabilité, gestion automatique de la mémoire (garbage collector), vaste écosystème de bibliothèques et frameworks, documentation abondante.

Inconvénients : performances parfois inférieures au code natif (C/C++), syntaxe parfois verbeuse, nécessité d’installer la JVM.

Dans le contexte de Java, les expressions A & B et A && B sont toutes deux des opérateurs de type “et logique” (AND) appliqués à des opérandes booléens A et B, mais elles diffèrent fondamentalement par leur comportement d’évaluation.

L’opérateur && est l’opérateur AND logique à court-circuit. Il évalue d’abord A : si A est faux, l’expression entière retourne immédiatement faux sans évaluer B, ce qui optimise les performances et évite des calculs inutiles (ou potentiellement dangereux, comme une division par zéro dans B). Par exemple, dans if (x > 0 && 10 / x > 1), si x vaut zéro, B ne sera pas évalué, évitant une exception.

En revanche, l’opérateur & est un AND logique non court-circuit : il évalue toujours A et B, quel que soit le résultat de A, avant de retourner le résultat logique (vrai si les deux sont vrais, faux sinon). Cela peut être utile dans des contextes où les effets secondaires de B doivent toujours se produire, mais cela rend le code moins efficace et plus risqué si B dépend de A.

Notez que & peut aussi servir d’opérateur bit à bit pour des entiers, alors que && est exclusivement logique pour les booléens. En pratique, pour les conditions booléennes, && est préféré pour sa sémantique plus sûre.

Voici une solution possible.

public static int safeAverageWithBranch(int a, int b) {
    // Cas 1 : signes différents (un positif, un négatif ou l’un des deux est zéro)
    // → a + b ne peut pas déborder car la somme reste dans les limites d’un int
    if ((a < 0) != (b < 0)) {
        return (a + b) / 2;
    }

    // Cas 2 : même signe (les deux positifs ou les deux négatifs)
    // → on utilise la formule sans risque de débordement : a + (b - a)/2
    // La soustraction b - a ne déborde jamais quand a et b ont le même signe
    return a + (b - a) / 2;
}

Voici pourquoi cette fonction est correcte.

• Quand les signes sont différents → la somme a + b est mathématiquement comprise entre Integer.MIN_VALUE et Integer.MAX_VALUE, donc aucun overflow possible en Java (même avec MIN_VALUE et MAX_VALUE).
• Quand les signes sont identiques → b - a a une valeur absolue plus petite que chacun des deux nombres, donc la soustraction reste dans les limites d’un int, puis on divise par 2 et on ajoute à a : aucun débordement.