Résultats de 1 à 8 sur 8

Sujet : [java] types primitifs

  1. #1
    Membre MP
    Inscrit
    août 2013
    Messages
    81

    [java] types primitifs

    Salut Zeb et le reste de la communauté Moteur Progienne,

    Je me suis plongé \"Au coeur de Java 2\" de Cay Hortsmann et Gary Cornell.

    Et déja a la page 61 je rencontre mon premier pb:

    Les types de variables int, short, long et byte.

    Le livre n\'explique pas concrètement qu\'elles sont leur fonction, et a quoi sert de préciser ces types devant les variables.

    Merci bcp à ceux qui pourront m\'aider!
    Webmaster de Webown Webdesigner et codeur web.

  2. #2
    Membre MP
    Inscrit
    août 2013
    Messages
    1 823
    Salut Tificombo,

    Les variables servent à modéliser des grandeurs du monde réel.

    Ses grandeurs ont des limites et aussi des formes différentes.

    Si tu dois compter un nombre de personne, tu utiliseras des grandeurs entières. (il ne viendrai pas a l\'esprit de couper une personne en deux, donc tu n\'utiliseras pas de nombre a virgule pour les compter)

    Inversement, si tu désire faire une moyenne, tu as de forte chance pour te retrouver avec des nombres qui comprenne une virgule, donc le Type sera donc différent.

    Pour ce qui est ensuite des limites, c\'est une question de place et de choix lié a la technologie.


    COMMENT LES NOMBRES SONT ILS REPRESENTES DANS L ORDINATEUR


    Un microprocesseur, ne comprend que deux valeurs 1 et 0 (cela tient au fait qu\'un transistor ne possède que deux états électriques facilement identifiables -> Conducteur ou Bloqué qui provoque une tension de sortie (voltage) nul ou proche de la tension d\'alimentation (par exemple 5 Volts pour les technologies TTL) ) Si nous utilisions ces deux états électriques pour représenter les nombres, nous ne pourrions écrire que 1 ou 0 et nous ne pourrions pas écrire 2.
    Afin de dépasser cette limite, l\'idée de regrouper plusieurs transistor pour former un nombre a été utilisé.
    Il faut comprendre pour la suite de cette explication qu\'un dispositif modélisant 0 ou 1 s\'appel un \'bit\'. Je dis bien BIT et non pas BYTE qui est autre chose que nous allons voir un peu plus loin.
    Le premier regroupement de BIT donc se nomme QUADRUPLET. Comme son nom l\'indique, il est composé de 4 bits. Le plus petit est donc :

    0000

    et le plus grand :

    1111

    Combien représente 0000 dans notre monde a-nous ?
    En fait il suffit de compter comme le font les mathématiciens pour le savoir.
    Chaque valeur d\'un élément est égal a la base (ici base 2 ou Binaire) élevé à la puissance de son rang, multiplié par l\'élément et additionné aux autres éléments pour donner la valeur dans notre base 10 (base décimale).

    0000 vaux donc 0 et 1111(en base 2) = (1x2^0) + (1x2^1) + (1x2^2) + (1x2^3) = 1 + 2 + 4 + 8 = 15

    Autrement dit on peut dire qu\'un Quadruplet se calcul comme suit. Soit le Quadruplet binaire [dcba] :

    dcba en décimal vaux : (ax2^0) + (bx2^1) + (cx2^2) + (dx2^3)

    les Quadruplet permettent donc de représenter des grandeurs de 0 a 15 (16 valeurs possibles) le nombre de valeurs possibles est important (16) car c\'est ce qui a donné l\'idée aux informaticiens d\'utiliser la base 16 pour les décrire (en base 10 tu mets un chiffre de plus a gauche dès que tu atteins le 10éme symbole, en Hexadécimal (base 16) tu fais de même en atteignant le 16éme symbole)

    exemple avec le Binaire - l\'Hexadécimal - Décimal

    0000 - 0 - 0
    0001 - 1 - 1
    0010 - 2 - 2
    0011 - 3 - 3
    0100 - 4 - 4
    0101 - 5 - 5
    0110 - 6 - 6
    0111 - 7 - 7
    1000 - 8 - 8
    1001 - 9 - 9
    1010 - A - 10
    1011 - B - 11
    1100 - C - 12
    1101 - D - 13
    1110 - E - 14
    1111 - F - 15

    Sur ce tableau tu voies notre quadruplet representé en Binaire avec a côté sa valeur Hexadécimale (base 16) et encore a côté sa base Décimale (base 10)

    L\'informaticien doit être a l\'aise avec ces trois bases pour savoir compter (tu verras ça viendra vite) cette table biens que pas utile tous les jours est a connaître par cœur ou du moins il est important de savoir la retrouver sans sortir sa calculatrice.
    Les notations Hexadécimales étant énormément utilisées en informatique.

    Reprenons notre notion de possibilité de représenter les nombres.
    Nous en étions au quadruplet qui nous permet de représenter 16 valeurs différentes entières (toujours pas de virgules dans tout ça)

    Le regroupement suivant qui a été imaginé, est l\'OCTET. L\'Octet (dont tu as sûrement déjà entendu parler est en fait un regroupement de deux Quadruplet. C\'EST AUSSI L\'OCTET QUI PROVOQUE LE PLUS DE CONFUSIONS car les Anglais (toujours eux) on décidé d\'appeler un Octet BYTE.

    On peut donc écrire que :

    Deux Quadruplets -> un Octet (français) -> un Byte (anglais) -> 8 bits (français) -> deux symboles Hexadécimaux

    Reprenons l\'analogie de tout à l\'heure pour les conversions :

    Le plus petit Octet en binaire s\'écrit : 0000 0000 (8 bits ou deux quadruplets)
    Le plus grand s\'écrira : 1111 1111

    Nous pouvons maintenant compteur un peut plus loin.
    Tu pourrais reprendre la formule de tout à l\'heure pour calculer les valeurs limites et tu trouveras que le mini reste 0 (ça s\'étais facile) et le maxi est 255 (essaie de vérifier).
    En utilisant la notation Hexadécimale (base 16), nos deux nouvelles limites s\'écrivent :

    Binaire - Hexadécimal - Décimal

    0000 0000 - 00 - 0
    1111 1111 - FF - 255

    Ce n\'est pas encore suffisant pour représenter la somme de tes notes a l\'école.
    Donc on va ensuite regrouper les Octets en nombre de plus en plus importants.

    on trouvera donc des \'paquets\' de 16 bits (2 Octets), 32 bits (4 Octets), 64 bits (8 Octets) et parfois plus encore...

    Les limites de l\'Octet pouvaient nous paraître faibles, mais les regroupements offrent déjà des possibilités beaucoup plus significatives.

    16 bits -> 11111111 11111111 -> 65535
    32 bits -> 11111111 11111111 11111111 11111111 -> 42 294 967 296

    etc. ...

    Pour nous faciliter la vie il faut aussi que nous puissions représenter des nombres Négatifs. Pour ce faire les concepteurs de microprocesseurs ont eu l\'idée d\'utiliser un des bits du nombre pour représenter le signe du nombre (généralement le plus a gauche)

    Cette astuce réduit donc les possibilité numérique (valeur absolue) mais augmente les capacités de modélisations possibles en mathématique.

    Nous devions en plus des chiffres positifs et négatifs se donner la possibilité de représenter des nombres comprenant une virgule.

    Pour faire cela, il existe différentes formules pour y arriver.
    Je ne te décrirai pas ces formules car elles sont complexes mais ce que nous allons retenir, c\'est que par un calcul interne elles te donneront l\'usage d\'un nombre positif ou négatif avec une précision fixée par avance (liée à la formule de calcul) et des décimales derrière la virgule.

    Les microprocesseurs n\'ont pas été capables tout de suite de faire un calcul avec des nombres a virgule, Cette fonctionnalité n\'est apparue que vers les années 90 (fin des années 80) et les premiers Processeurs 8 bits (génération Z80, 6800 etc. ...) n\'étaient capables que de faire des addition, des soustraction et parfois des multiplication (6809 Motorola par exemple).

    Nous avons regarder jusqu\'a présent les nombres sous un axe mathématique et vis à vis des microprocesseurs.

    Qu\'en est il pour les langages et plus particulièrement pour Java ?

    Le contexte et le problème, en fait, est assez identique. Java pour des raisons technologiques a repris les nombres que le processeur connais et les a baptisé Type primitifs.

    int, short, long et byte sont donc certains des types primitif Java.

    Regardons les en détails.


    LES TYPES JAVA


    Java fournit 4 types entiers de base qui sont :

    ([-i]tu utilisera ces types pour representer tous ce que tu peux compter et qui ne nécéssite pas de chiffre a virgule[/i])

    Type Taille Intervalle de valeur possibles

    byte 8 bits -128 à 127
    short 16 bits -32768 à 32767
    int 32 bits -2147483648 à 2147483647
    long 64 bits -9223372036854775808 à 9223372036854775807

    Tout les types numériques sont des types signés. (signé veux dire qu\'ils peuvent être positifs ou négatifs)
    Il n\'existe pas de type numérique non signé.

    Des valeurs spéciales sont définies pour représenter les valeurs extrèmes des nombres entiers :

    java.lang.Byte.MIN_VALUE
    java.lang.Byte.MAX_VALUE
    java.lang.Short.MIN_VALUE
    java.lang.Short.MAX_VALUE
    java.lang.Int.MIN_VALUE
    java.lang.Int.MAX_VALUE
    java.lang.Long.MIN_VALUE
    java.lang.Long.MAX_VALUE
    Les types réels :

    ([-i]tu utilisera ces types pour representer tout ce qui nécéssite une representation avec des chiffres derrière la virgule[/i])

    Pour représenter les types réels, Java utilise un sous ensemble la norme IEEE-754.

    Les deux types de réels implémentés en Java sont :

    Type Taille Intervalle
    float 32 bits 3.40282347E+28 à 1.40239846E-45
    double 64 bits 1.79769313486231570E+308 à 4.9406545841246544E-324


    Des valeurs spéciales sont définies pour représenter les valeurs extrèmes des nombres réels :

    java.lang.Float.MIN_VALUE
    java.lang.Float.MAX_VALUE
    java.lang.Float.POSITIVE_INFINITY
    java.lang.Float.NEGATIVE_INFINITY
    java.lang.Float.NaN : (Not An Number) n\'est pas un nombre.
    Certains calculs ne donnent pas un résultat numérique significatif, c\'est alors cette valeur spéciale qui est retournée.

    java.lang.Double.POSITIVE_INFINITY
    java.lang.Double.NEGATIVE_INFINITY
    java.lang.Double.NaN
    java.lang.Double.MIN_VALUE
    java.lang.Double.MAX_VALUE
    Le type caractère :

    ([-i]Tu utilise ce type pour les codes de caractères. Tu en vera l\'usage notament avec les flux[/i])

    Type Taille Intervalle
    char 16 bits 0 à 65535

    Le jeu de caractères Java est le jeu Unicode (16 bits non signé) permettant ainsi de coder les alphabets du monde entier.
    Les 128 premiers caractères sont les mêmes que ceux du code ASCII.

    Le type booléen :

    ([-i]Tu dois utiliser ce type pour representer tout ce qui est vrai ou faux[/i].)

    La comparaison entre 2 valeurs donne un résultat de type booléen (vrai / faux ou plutôt en Java true / false).

    Type Taille Intervalle

    boolean 1 bit true ou false

    Le type boolean ne peut recevoir que 2 valeurs : true ou false et n\'est pas compatible avec un type numérique.


    DECLARATION ASSIGNATION INITIALISATION


    Toutes les variables doivent être déclarées avant d\'être utilisées (sinon le compilateur te repondra qu\'il ne connais pas ta variable).
    Mais en plus, en Java, elles doivent être initialisées avant d\'être utilisées (une initialisation en fait est le fait d\'assigner une valeur a la variable).

    Si tu utilise une variable sans l\'avoir initialisée, le compilateur génère une erreur.

    La définition d\'une variable peut se faire en tout point du programme.(il sera bon par contre de le faire au debut d\'une methode ou fonction pour lors de la relecture, biens voir tout de suite les grandeurs qui vont être utilisées)

    Il n\'existe pas de variable globale en Java (variables visibles de tous les points d\'un programme et souvent sources d\'erreur).

    La définition d\'une variable et éventuellement son initialisation se fait de la façon suivante :

    Code:
    int i = 0;     // définition et initialisation de la variable de type int s\'appelant \'i\' et assignation d\'une valeur initiale de zero  
    
    int a, b;      // définition de 2 variables entières (une virgule entre deux variable DE MEME TYPE)
    
    a = 0;         // affectation  ou encore assignation
    b = 0;
    
    double d; 
    d = d + 1;     // Provoque une ERREUR : \'d\' n\'est pas initialisé (on ne lui a pas assigné de valeur)
    
    boolean find = true; 
    
    find = 0;      // Provoque une ERREUR : La valeur zero ne conviens pas a un type boolean
    Voila donc un \'petit\' topo sur les nombre, les microprocessuers et Java.

    Je t\'ai parlé des microprocesseurs car ils sont au coeur du langage et biens souvent, ils dirigent la façon dont les choses se font a un niveau plus élevé comme dans Java.

    A bientôt sur le forum :wink:

  3. #3
    Membre MP
    Inscrit
    août 2013
    Messages
    81
    Tout d\'abord GRAND merci pour cette excelente explication et bravo. Je trouve ca super d\'accepter de partager son savoir aussi facilement que ca.
    C\'était tellement bien expliqué que malgré la complexité (pour moi qui découvre ca pour la 1er fois) du sujet traité j\'ai compris.
    Mais il y a juste quelques points que je n\'ai pas saisi:

    1)
    exemple avec le
    Binaire - l\'Hexadécimal - Décimal
    0000 - 0 - 0
    0001 - 1 - 1
    0010 - 2 - 2
    0011 - 3 - 3
    0100 - 4 - 4
    0101 - 5 - 5
    0110 - 6 - 6
    0111 - 7 - 7
    1000 - 8 - 8
    1001 - 9 - 9
    1010 - A - 10
    1011 - B - 11
    1100 - C - 12
    1101 - D - 13
    1110 - E - 14
    1111 - F - 15
    Je n\'ai pas vraiment saisi ce que cette table représentait et comme elle fonctionnait. Enfin, j\'ai essayé de faire le calcul pour la 2ème ligne et ca ne collait pas:
    0001
    selon le calcul: (ax2^0) + (bx2^1) + (cx2^2) + (dx2^3)
    cela devrait donner:
    0 + 0 + 0 + (1 * 2 ^ 3) = 8
    Donc je pense que ca ne fonctionne pas comme ca, mais comment alors?

    2)
    Tu pourrais reprendre la formule de tout à l\'heure pour calculer les valeurs limites et tu trouveras que le mini reste 0 (ça s\'étais facile) et le maxi est 255 (essaie de vérifier).
    J\'ai tenté de vérifier mais je n\'ai pas compris la démarche a suivre, moi j\'ai trouvé 240: j\'ai multiplié le nombre maximum d\'un quadruplet (15) par 16 (hexadécimal) ce qui m\'a donné 15*16=240.
    Quelle la démarche a suivre?

    3)
    on trouvera donc des \'paquets\' de 16 bits (4 Octets), 32 bits (4 Octets), 64 bits (8 Octets) et parfois plus encore...
    Tu ne voulais pas plutot dire 32 bits : 8 octets et 64 bits : 16?

    Merci pour ta patiente et ta gentillesse Zeb!
    @ bientot!
    Webmaster de Webown Webdesigner et codeur web.

  4. #4
    Visiteur MP
    Visiteur MP
    Bravo zeb pour tout ton travail.

    Tificombo :

    Enfin, j\'ai essayé de faire le calcul pour la 2ème ligne et ca ne collait pas:
    0001
    En fait pour obtenir un nombre décimal depuis un binaire, tu procèdes ainsi :
    0001 <=> (0*2^3)+(0*2^2)+(0*2^1)+(1*2^0) = 0+0+0+1 = 1

    Pour :
    1011 <=>(1*2^3)+(0*2^2)+(1*2^1)+(1*2^0) = 8+0+2+1 = 11


    le maxi est 255
    Imagine un nombre :
    1111 1111 et tu appliques la règle :
    - le chiffre : 1 multiplié par 2 à la puissance sa_place.
    Or ici il n\'y a que des 1, donc:
    (1*2^7)+(1*2^6)+(1*2^5)...+(1*2^0) = 255


    on trouvera donc des \'paquets\' de 16 bits (4 Octets), 32 bits (4 Octets), 64 bits (8 Octets) et parfois plus encore...
    Tu ne voulais pas plutot dire 32 bits : 8 octets et 64 bits : 16?
    non en fait c\'est :
    16 bits (2 Octets), 32 bits (4 Octets), 64 bits (8 Octets)

    Un Octet vaut 8 bits...

    :
    ++


    [col=#FF0000]Caid2004, merci de créer un nouveau post si tu as un problèmè en java...[/col]

  5. #5
    Membre MP
    Inscrit
    août 2013
    Messages
    1 823
    Arg !!!!

    Mea Maxima culpa !

    Tout est de ma faute, j\'ai inversé l\'ordre des lettres dans mon message ! (j\'ai réédité le topic pour corriger cette erreur)

    En fait il falais lire :

    [col=#008000]dcba en décimal vaux : (ax2^0) + (bx2^1) + (cx2^2) + (dx2^3) [/col]

    a la place de ce que j\'avais ecris a savoir :

    [col=#FF0000]abcd en décimal vaux : (ax2^0) + (bx2^1) + (cx2^2) + (dx2^3) [/col]

    Heureusement que Gexti a rectifié le tir. Merci a lui :wink:

    En fait j\'avoue que je n\'ecris plus trop ce genre de calcul car j\'en fais une bonne partie de tête quand les chiffres ne sont pas trop gros et qu\'en plus malgrès ma relecture du sujet, je n\'ai rien vu ! Qui plus est, Java ofrant un niveau d\'abstraction telement important vis a vis des nombres, je ne suis pas souvent confronté a ce genre de calcul. Un developpeur en assembleur n\'aurais jamais fait une tel erreur.

    Toute mes excuses pour cette GROSSE erreur mathematique.

    re tifficombo oui 2 octets pour 16 bits (merci d\'avoir relu) je devais avoir la tête ailleurs ce jour la (ou alors c\'est la vache fole)

    nombre maximum d\'un quadruplet (15) par 16 (hexadécimal) ce qui m\'a donné 15*16=240.
    Je pense que l\'explication de Gexti est sufisante, mais je me permet d\'ajouter qu\'une chose aurais du attirer ton attention. (ou du moins qui l\'attirera surement la prochaine fois)
    En faisant 15 (Décimal) * 16 (héxadécimal) tu effectue une operation sur deux nombres de base différentes, donc tu ne peux de toute façon avoir un resulta corect. :wink:

  6. #6
    Membre MP
    Inscrit
    août 2013
    Messages
    81
    Ha oui ok cette fois j\'ai compris, il faut inverser l\'ordre des chiffres ):
    Et pour le nombre max, ce que je faisais, c\'est que je repartais a zero pour les places (3-2-1-0 puis 3-2-1-0) alors qu\'en fait c\'est 7-6-5-4-3-2-1-0 :
    En tout cas merci beaucoup a Zeb et Gexti! :
    Vous faites des études la dedans non, ou alors vous avez déja fait vos études?
    Webmaster de Webown Webdesigner et codeur web.

  7. #7
    Visiteur MP
    Visiteur MP
    C\'est pas vraiment le sujet du poste, alors on ne s\'étandera pas là dessus Tificombo, excuse nous.

    Mais si tu veux mieux connaitre la communauté MoteurProg, vas donc faire un tour sur les autres forum...
    Php, Java, C... Tous les langages info dès que tu as un soucis ou que tu souhaites aider qq\'un.
    Moteurprog pour tout ce qui concerne le site.
    Bavardages pour à peu près tout le reste.

    Bienvenue parmis nous,
    ++


    :wink:

  8. #8
    Membre MP
    Inscrit
    août 2013
    Messages
    81
    Pas grave je comprends.
    Je vais mettre le topic en statut \"résolu\".
    @ bientot!
    Webmaster de Webown Webdesigner et codeur web.

Informations du sujet

Utilisateur(s) parcourant ce sujet

il y a actuellement 1 utilisateur(s) parcourant ce sujet. (0 membre(s) et 1 visiteur(s))

Règles des messages

  • Vous ne pouvez pas créer de sujets
  • Vous ne pouvez pas répondre aux sujets
  • Vous ne pouvez pas importer de fichiers joints
  • Vous ne pouvez pas éditer vos messages
  •  
  • Les BB codes sont Activés
  • Les Smileys sont Activés
  • Le BB code [IMG] est Activé
  • Le code [VIDEO] est Activé
  • Le code HTML est Désactivé
Please disable Adblock!