Les types primitifs scalaires et opérations associées

Pour le moment les exercices seront réalisés sur JSHELL.

Vous avez la possibilité de l’utiliser ligne à ligne ou en mode édition/exécution.

Exercices

Types entiers et opérations

écrire du code pour déclarer, initialiser :
- un int avec une valeur négative
- un int avec une valeur positive
- un int valant 0xFFFF
- un int valant 0xFFFFFFFF
- un int valant 107374757677
Vos conclusions?
Faites des expériences sur les opérations entières: tentez de manière systématique des valeurs simples et des valeurs extrèmes (et imprimez le résultat).

voir quelques suggestions (chapitre: Exemples/opérations sur les types entiers)

Il est important d’avoir de l’imagination pour tester des valeurs. Ceci devient très utile quand on doit tester systématiquement des applications.

virgule flottante: types et opérations

Faites des expériences avec des nombres flottants (float ou double) et leurs opérations.

Essayer avec des nombres très grands, des nombres très petits. Faire des divisions par zéro.

quelques exemples (chapitre: Exemples/virgule flottante: types et opérations)

operations impliquant des types différents

      double montant = 22.1;
      int taux = 10 ;
      double resultat ;

      resultat= // VOTRE CODE ICI

Votre code :

Calculer en appliquant cette formule (attention: ceci n’est pas du code java mais une description "classique" de formule mathématiques):
```
resultat = montant ÷  (1 + ((50 - taux) ÷ 1000))
```

Warning

Le programme doit afficher: 21.25

une solution ici

autres exercices sur des entiers

Faites des expériences avec la pre-incrémentation et la post-incrémentation et les opérations composites comme *= += … (plus tard faire expérimenter les opérations comme: &= <⇐ >>>= )

Utiliser également les types byte et short.

quelques exemples ici

type booléen et opérations rendant des booléens.

Faites des expériences avec des comparaisons et autres opérations qui rendent des valeurs booléenes.

Par exemple partez de :

public class TestCompare {
      public static void main(String[] args) {

        int x = 10 ;
        int y = -1 ;
        double valx = 10. ;
        double valy = -1;
        // VOTRE CODE
     }
}

quelques exemples ICI

opérations "bit à bit" sur des entiers

(Pour révisions et approfondissements)

Ce point n'étant pas essentiel vous pouvez faire cet exercice plus tard dans le cadre de révisions:

faites des expériences avec la représentation binaire d’un entier int ix en invoquant Integer.toBinaryString(ix). (comme il n’y a pas d’alignement avec des zéros à gauche il faudra faire quelques efforts pour "visualiser" ces zéros).
faites des expériences avec les opérations "bit à bit": & | ~

quelques exemples ici

compatibilités entre types

(Pour révisions et approfondissements)

Dans le code suivant :

int x;
short y = 0x7FF;
       // VOTRE CODE ICI

affecter y à x.
déclarer une valeur de type char et de nom car et l’initialiser avec une valeur quelconque.
affecter car à x.
essayer d’affecter car à y : expliquer ce qui arrive.

une solution ICI

Exemples

opérations sur les types entiers

 int ix ;
//un "int" avec valeur négative
ix = -128 ;

//un "int" avec valeur positive
ix = 128 ;

//un "int" et valeur en hexadécimal 0xFFFF
ix = 0xFFFF ;

//idem et valeur 0xFFFFFFFF
ix = 0XFFFFFFFF ;

//un "int" avec valeur 107374757677
// ix = 107473757677 ; ne s'exécute pas
ix = 1074737576 ;

// experimentations sur des opérations
// Essayons des tests très divers

-ix ;

ix + 1  ;

ix + ix ;

ix * 2  ;

ix-12345 ;

// multiplication
1223456 * 2 ;

1223456 * -2 ;

-1223456 * -2 ;

// modulo
13%7;

-13%7;

13 % -7;

-13 % -7;

// division
13/7;

ix/-1;

0/ix;

int iy = 0 ;
ix/iy;