Exercices sur la Conversion de Types en Java

1. Qu'est-ce qu'une conversion élargissante et comment se produit-elle en Java ?
2. Donnez un exemple de code java où une conversion élargissante se produit automatiquement. Expliquez le résultat.
3. Quels sont les risques associés à une conversion restrictive ? Donnez un exemple.
4.  Pourquoi est-il nécessaire d'utiliser un transtypage explicite pour une conversion restrictive ?
5.  Quelles conditions doivent être remplies pour qu'une conversion implicite soit autorisée ?
6. Comment la conversion entre des types numériques affecte-t-elle la précision des valeurs ? Donnez un exemple.

        
public class Genius1 {
    public static void main(String[] args) {
        int val = 150;
        byte val2 = (byte) val; 
        System.out.println("Valeur : " + val);
        System.out.println("Valeur  : " + val2);
    }
}
        
    

1. Quel est le type de la variable `val` et quelle valeur a-t-elle ?
2. Que se passe-t-il lors de l'assignation de `val` à `val2` ? Y a-t-il une perte de données ?
3. Quelle valeur sera affichée pour `val2` et pourquoi ?
4. Que se passerait-il si `val` avait la valeur `300` ? Quel serait le résultat pour `val2` ?
5. Modifiez le code pour que `val2` soit assigné directement à partir d'une opération qui retourne un `int`, sans transtypage explicite.
6. Expliquez pourquoi il est souvent préférable d'utiliser un transtypage explicite lorsque vous travaillez avec des types plus petits comme `byte` ou `short`.

        
public class Genius2 {
    public static void main(String[] args) {
        double montantD = 123.456;
        int montantE = (int) montantD; 
        short compteur = 12 * 34;  

        System.out.println("Montant : " + montantD);
        System.out.println("Montant : " + montantE);
        System.out.println("Compteur : " + compteur);

        long montantG = 50000L;
        byte montantP = (byte) montantG; 
        System.out.println("Montant petit : " + montantP);
    }
}
        
    

1. Quels sont les types des variables `montantD`, `montantE`, `compteur`, `montantG`, et `montantP` ?
2. Quel sera le résultat de la conversion de `montantD` en `int` ? Pourquoi ?
3. Quelle valeur sera affichée pour `compteur` ? Justifiez votre réponse.
4. Que se passe-t-il lors de l'assignation de `montantG` à `montantP` ? Y a-t-il une perte de données ?
5. Que se passerait-il si `montantG` avait une valeur supérieure à 255 ? Quelle serait la valeur de `montantP` ?
6. Discutez des implications de la conversion entre différents types numériques. Pourquoi est-il important de comprendre ces conversions en programmation ?

Instructions : Le chef de Département de Maths-Info curieux aimerais connaitre le niveaux des étudiants du Groupe Genius a cet effet il demande a Bob d'écrire un programme Java qui crée et manipule plusieurs variables de différents types. Utilisez les types suivants : int, byte, short, et double. Ensuite, effectuez des conversions entre ces types.

Détails du Problème :

1. Créez une variable int nommée salaire et assignez-lui une valeur de votre choix.
2. Créez une variable double nommée tauxImpot et assignez-lui un taux (par exemple, 0.25).
3. Calculez le montant d'impôt à payer en multipliant salaire par tauxImpot et assignez-le à une variable double nommée montantImpot.
4. Convertissez montantImpot en byte et assignez-le à une variable byte nommée impotPetit.
5. Affichez toutes les variables et expliquez toute perte de données due à des conversions.

A vous de jouez !