3. Types de base, classes et objets

3.1. Types de base

Il existe huit types de base en Java :
  • des types entier : byte, short, int, long ;
  • un type caractère : char ;
  • un type booléen : boolean ;
  • deux types flottants : float et double.
Les types de base ne définissent pas d’objet. Quand on déclare une variable de type int, la machine Java nous donne en retour une zone mémoire de 4 octets, qui peut contenir un int. L’opérateur d’affectation recopie la valeur de la variable cible dans la variable destination. Prenons un exemple :
  int i, j ;
 i =  0 ;  
 j = i ;   
 i =  1 ;
On a bien, à l’issue de cette série d’instructions j = 0 et i = 1. Les caractéristiques des types de base sont résumées dans le tableau suivant.

Tableau 1. Types de base en Java

Type de base Type Nombre de bits Valeurs possibles
boolean booléen 32 (effectifs) true et false
byte entier 8 signées
short entier 16 signées
int entier 32 signées
long entier 64 signées
float virgule flottante 32 IEEE 754
double virgule flottante 64 IEEE 754
char caractère 16 Unicode

Nous verrons en détail plus loin ce que fait exactement la machine Java lorsqu'elle exécute un programme. Disons pour le moment que, à la différence du langage C par exemple, Java se charge de l'initialisation des variables avant que l'on puisse les utiliser. Ainsi, les nombres sont mis à 0, les booléens à false et les caractères à '\0' avant d'être utilisés par une application. Par conséquent, le programme suivant affichera toujours 1.
public  class Main {  
  
     private  static  int i ;  
      
     public  static  void main(String [] args) {  
        System.out.println("i + 1 = " + (i +  1)) ;  
          
    }  
}

3.2.  Classes et objets

Définir la notion classe serait complexe et fastidieux, surtout à ce stade. En première approche, disons qu'une classe est une structure qui regroupe des champs et des méthodes. Si on a regroupé ensemble ces champs et ces méthodes, c'est parce qu'ils forment un tout cohérent, probablement au sens de l'application que l'on est en train de développer. Nous verrons qu'il existe des techniques assez rigoureuses afin de créer des classes, des erreurs qu'il est bon d'éviter, et des principes qu'il n'est pas plus mauvais de respecter. Une classe est un modèle, qui ne fait rien en lui-même. On définit un objet comme l'instance d'une classe. Il s'agit d'une variable, construite sur le modèle d'une classe. On dira, indifféremment, qu'un objet est une instance d'une classe, qu'un objet est "de type" la classe dont il est l'instance, ou encore qu'il appartient à cette classe. Ce sont donc les objets qui font le travail, suivant le modèle imposé par les classes auxquelles ils appartiennent. Nous venons de voir au début de cette partie les types de base . Il existe de nombreuses différences entre les types de base et les objets. La première est qu'un type de base n'appartient à aucune classe. Voyons immédiatement d'autres différences fondamentales. Lorsque l'on déclare un type de base, par exemple int i ;, la machine Java nous donne une zone mémoire, en l'occurrence de 4 octets, capable de contenir un entier sur 32 bits. Cette zone mémoire existe, et elle est à nous. En revanche, lorsque l'on écrit String s ;, la machine Java nous donne une variable, s, qui peut porter une référence vers une zone mémoire capable de contenir une instance de la classe String, classe standard qui permet de gérer les chaînes de caractères. Mais au moment où nous obtenons cette variable, cette zone mémoire n'existe pas, elle n'a pas été réservée. C'est à nous de le faire "à la main". Si l'on tente d'utiliser immédiatement cette variable :
String s ;
 int length = s.length() ;  // NullPointerException !!!
On obtient un message d'erreur bien connu : l'ignoble NullPointerException, aussi appelée par les programmeurs chevronnés NPE (c'est même à ça que l'on reconnaît un développeur chevronné, au fait qu'il parle de NPE plutôt que de NullPointerException).
Java langage & API
Retour au blog Java le soir
Cours & Tutoriaux
Table des matières
Introduction : un peu d'histoire
1. Java : genèse d'un nouveau langage
Programmer en Java
1. Un premier exemple
1.1. Aperçu général, cycle de vie
1.2. Un premier programme
1.3. Programmes, applets, servlets, etc...
2. Une première classe
2.1. Écriture d'une classe
2.2. Instanciation de cette classe
3. Types de base, classes et objets
3.1. Types de base
3.2. Classes et objets
Classes Object et String
1. Introduction
2. La classe Object
2.1. La méthode toString()
2.2. La méthode clone()
2.3. La méthode equals()
2.4. La méthode hashCode()
2.5. La méthode finalize()
2.6. La méthode getClass()
3. La classe String
3.1. Introduction
3.2. Construction d'un objet de type String
3.3. Concaténation, StringBuffer et StringBuilder
3.4. Concaténations de chaînes de caractères depuis Java 8
3.5. Concaténations de chaînes de caractères depuis Java 11
3.6. Extraction d'une sous-chaîne de caractères
3.7. Comparaison de deux chaînes de caractères
3.8. Méthodes de comparaisons lexicographiques
3.9. Méthode de recherche de caractères
3.10. Méthode de modification de chaîne
3.11. Méthode de duplication
3.12. Support de l'unicode, internationalisation
Structure d'une classe
1. Introduction
2. Classes
2.1. Classes publiques
2.2. Classes internes
2.3. Classe membre
2.4. Classes locales
2.5. Classes anonymes
2.6. Le mot-clé this
3. Éléments statiques
3.1. Champ statique
3.2. Cas des constantes
3.3. Bloc statique
3.4. Classe membre statique
4. Membres d'une classe, visibilité
4.1. Bloc non statique
4.2. Accès à un membre, visibilité
4.3. Les champs
4.4. Signature d'une méthode
4.5. Les méthodes
4.6. Getters et Setters
5. Constructeur, instanciation
5.1. Chargement d'une classe
5.2. Constructeurs d'une classe
5.3. Instanciation d'un objet
5.4. Destruction d'objets
5.5. Le mot-clé final
6. Énumérations
6.1. Déclaration d'une énumération
6.2. Classe énumération
6.3. Méthode toString()
6.4. Méthode valueOf()
6.5. Méthode values()
6.6. Méthode ordinal()
6.7. Méthode compareTo()
6.8. Constructeurs privés
6.9. Classe utilitaire : EnumSet
Noms, opérateurs, tableaux
1. Introduction
2. Identificateurs, noms et expressions
2.1. Identificateurs et noms
2.2. Expressions
3. Opérateurs, ordre d'exécution
3.1. Ordre d'exécution
3.2. Les opérateurs
3.3. Les opérateurs ++ et --
3.4. Les opérateurs % et /
3.5. Les opérateurs <<, >> et >>>
3.6. L'opérateur instanceof
3.7. Les opérateurs &, | et ^
3.8. Les opérateurs && et ||
3.9. L'opérateur ? ... :
3.10. Les opérateurs d'affectation
4. Tableaux
4.1. Création d'un tableau
4.2. Initialisation d'un tableau
4.3. Utilisation d'un tableau comme un Object
4.4. Tableaux de tableaux
4.5. Copie de tableaux
5. Blocs, boucles et contrôles
5.1. Blocs
5.2. Mots-clés réservés
5.3. Tests : if et switch
5.4. Boucles : for, while, do ... while
5.5. Commandes continue et break
5.6. Commandes return et goto
Nombres, précision, calculs
1. Introduction
2. Calculs
2.1. Précision
2.2. Codage des nombres flottants
2.3. Le mot-clé strictfp
2.4. Conversion de types
3. Dépassements de capacité
3.1. Cas des entiers
3.2. Cas des flottants
3.3. Bibliothèques BigInteger et BigDecimal
4. Fonctions mathématiques
4.1. Fonctions usuelles
4.2. Générateurs aléatoires
5. Classes enveloppe
5.1. Associer les types de base à des objets
5.2. Auto-boxing
Héritage, abstraction, interfaces
1. Introduction
2. Abstraction et encapsulation
2.1. Abstraction
2.2. Encapsulation
3. Héritage
3.1. Définition de l'héritage
3.2. Conséquences pour les membres
3.3. Polymorphisme
3.4. Empêcher l'héritage
4. Classes abstraites
5. Interfaces
5.1. Introduction
5.2. Définition
5.3. Java 8 et les interfaces
5.4. Utilisation des interfaces
5.5. Définition de constantes dans les interfaces
5.6. Utilité des interfaces
Packages
1. Introduction
2. Notion de paquet
2.1. Déclaration d’appartenance à un paquet
2.2. Chargement d’une classe
2.3. Choix de nom
3. Archives, chemin de recherche, classpath
3.1. Archives
3.2. Variable CLASSPATH
3.3. Notion de classloader
3.4. Bilan sur les classes chargées
3.5. Visibilité
3.6. Conseils d'écriture, bibliothèque standard
Exceptions
1. Introduction
2. Erreurs et Exceptions
2.1. Classe Throwable, notion de stack trace
2.2. Classe Error
2.3. Classe RuntimException
2.4. Classe Exception
3. Déclenchement d'une exception
3.1. Exceptions déclenchées par la JVM
3.2. Exceptions déclenchées par l'application
4. Capter une exception
4.1. Traiter une exception localement
4.2. Code de captage
5. Créer ses propres exceptions
Entrées / sorties
1. Introduction
2. Notion de fichier
2.1. Introduction
2.2. La classe File
2.3. Construction d'une instance de File
2.4. Méthodes exposées
3. Flux de sortie
3.1. Introduction, notion de flux
3.2. Écriture de caractères, classe Writer
3.3. Bufferisation, construction d'un flux sur un autre
3.4. Utilisation de PrintWriter
3.5. Écriture d'octets, OuputStream
3.6. Écriture de types primitifs : DataOutputStream
3.7. Écriture d'objets : ObjectOutputStream
4. Flux d'entrée
4.1. Introduction
4.2. Lecture de caractères, classe Reader
4.3. Bufferisation, lecture ligne par ligne
4.4. Lecture d'octets : InputStream
4.5. Lecture de types primitifs : DataInputStream
4.6. Lecture d'objets : ObjectInputStream
5. Lecture et écriture de flux croisés
5.1. Introduction
5.2. Lire des caractères sur un flux binaire : classe InputStreamReader
5.3. Écrire des caractères sur un flux binaire : classe OutputStreamWriter
5.4. Remarque sur les jeux de caractères
6. Serialization d'objets
6.1. Enjeu de la sérialization d'objets
6.2. Serialization d'un objet
6.3. Sérialization d'une grappe d'objets
6.4. Première surcharge : méthode writeObject() readObject()
6.5. Deuxième surcharge : utilisation d'un externalizer
6.6. Troisième surcharge : utilisation d'un objet proxy
7. Flux compressés
7.1. Introduction
7.2. Flux de type gzip
7.3. Flux de type zip