## Slide 1.
**Le typage en Java**
---
## Slide 2.
**PLAN**
1. Qu'est-ce qu'un type ? Qu'est-ce qu'un langage fortement typé ? Quels sont les types existants en Java ?
2. Les types primitifs
3. Les objets
---
## Partie 1. Slide 3.
**Qu'est-ce qu'un type en informatique ?**
---
## Partie 1. Slide 4.
**Qu'est-ce qu'un type en informatique ?**
- Un type correspond à une catégorie de données que l’on attribue à une variable qui va stocker des valeurs
- Chaque type va permettre d’allouer une zone de mémoire prédéfinie
- Le typage est géré différemment d'un langage de programmation à un autre
---
## Partie 1. Slide 5.
**Typage statique et dynamique**
En informatique, on parle de typage statique et typage dynamique.
En typage statique : le type des variables vérifiées à la compilation
En typage dynamique : le type des variables sont déterminés au moment de l'exécution
---
## Partie 1. Slide 6.
**Typage statique : avantages, inconvénients, langages associés**
Avantages
- Détection précoce des erreurs : Les erreurs de type sont détectées au moment de la compilation, ce qui contribue à prévenir de nombreuses erreurs potentielles avant l'exécution du programme.
- Meilleure performance : Le typage statique permet souvent une exécution plus rapide du programme, car certaines optimisations peuvent être effectuées au moment de la compilation en raison de la connaissance préalable des types.
- Meilleure documentation du code : En spécifiant explicitement les types, le code devient plus lisible et documenté, facilitant la compréhension pour d'autres développeurs.
---
## Partie 1. Slide 7.
**Typage statique : avantages, inconvénients, langages associés**
Inconvénients
- Rigidité : La déclaration explicite des types peut rendre le code plus rigide et nécessiter plus de travail pour effectuer des changements.
- Plus de code à écrire : La nécessité de déclarer explicitement les types peut entraîner un code plus verbeux et plus long.
---
## Partie 1. Slide 8.
**Quels sont les langages qui utilisent un typage statique ?**
Java, C, C++, Swift
---
## Partie 1. Slide 9.
**Typage dynamique : avantages, inconvénients, langages associés**
Avantages
- Flexibilité : Les variables peuvent être redéfinies avec différents types de données, ce qui rend le code plus flexible et adaptable.
- Moins de code à écrire : En ne nécessitant pas de déclaration explicite des types, le code peut être plus concis et plus rapide à écrire.
- Facilité de prototypage : La nature flexible du typage dynamique est souvent appréciée lors du prototypage rapide ou de la programmation exploratoire.
---
## Partie 1. Slide 10.
**Typage dynamique : avantages, inconvénients, langages associés**
Inconvénients
- Erreurs à l'exécution : Les erreurs de type ne sont souvent détectées qu'au moment de l'exécution du programme, ce qui peut entraîner des bogues difficiles à repérer.
- Moins de documentation : En l'absence de déclarations explicites de types, la compréhension du code peut être plus difficile, surtout pour des projets complexes.
- Performance potentiellement réduite : Les langages à typage dynamique peuvent être moins performants car les vérifications de type sont effectuées à l'exécution, ajoutant un surcoût en termes de temps.
---
## Partie 1. Slide 11.
**Quels sont les langages qui utilisent un typage dynamique ?**
Python, JavaScript, Ruby et PHP
---
## Partie 1. Slide 12.
**Les types en Java**
Deux grandes catégories de types en Java
- Les types primitifs
- Les objets
---
## Partie 2. Slide 13.
**Les types primitifs**
---
## Partie 2. Slide 14.
**Qu'est ce qu'un type primitif ?**
En informatique, les types de données primitifs sont un ensemble de types de données de base.
En Java, il existe 8 types primitifs.
---
## Partie 2. Slide 15.
**Liste des types primitifs en Java**
*Types entiers :*
byte, short, int, long
*Types décimaux :*
float, double
*Type booléen :*
boolean
*Type caractère :*
char
---
## Partie 2. Slide 18.
**Est-ce que les primitifs existent seulement en Java ?**
Non, les types primitifs ne sont pas spécifiques à Java. Ils sont présents dans plusieurs langages de programmation.
- Utilisés en C, C++, C#
- Dans d'autres langages, même si la notion de types primitifs n'est pas explicite, on retrouve les mêmes notions (Python, JavaScript)
---
## Partie 2. Slide 19.
**Quels sont les avantages des types primitifs ?**
Efficacité : Les types primitifs sont plus efficaces en termes d'utilisation de la mémoire et de performances par rapport aux objets. Ils sont simples et prennent moins de place en mémoire.
Rapidité : Les opérations sur les types primitifs sont généralement plus rapides que sur les objets, car ils sont directement manipulés par le processeur.
Facilité d'utilisation : Ils sont faciles à utiliser et à comprendre car ce sont des valeurs simples sans complexité supplémentaire.
---
## Partie 2. Slide 20.
**Quels sont les inconvénients des types primitifs ?**
Manque de fonctionnalités : Les types primitifs ne possèdent pas de méthodes ou de fonctionnalités inhérentes à eux-mêmes. Par exemple, un entier (int) n'a pas de méthodes associées pour effectuer des opérations plus avancées.
Ils ne sont pas des objets : Les types primitifs ne peuvent pas être utilisés avec certaines fonctionnalités d'objet.
Impossibilité de définir des valeurs nulles : Les types primitifs ne peuvent pas avoir de valeur nulle (null). Par exemple, un int ne peut pas être null.
---
## Partie 2. Slide 21.
**De nombreuses questions en suspend**
Comment dépasser les limites des types primitifs ?
Peut-on transformer des types primitifs en objets ?
Quels sont les avantages des objets ?
---
## Partie 3 - Slide 23.
**Qu'est ce qu'un objet ?**
Il permet de modéliser des entités du monde réel de manière plus efficace en encapsulant des données et des comportements liés à ces entités.
---
## Partie 3 - Slide 24.
- Il s'agit d'une instance d'une classe
- Il contient des données
- Il contient des méthodes qui opèrent sur ses données
---
## Partie 3 - Slide 25.
Entité du monde réel :
exemple : Étudiant
- L'objet contient des données :
Son nom, prénom, date de naissance, etc...
```java=
public class Etudiant {
private String nom;
private String prenom;
private LocalDate dateDeNaissance;
private int numeroIdentification;
// ...
}
```
---
Entité du monde réel :
exemple : Étudiant
- L'objet contient des méthodes qui opèrent sur les données :
Comme :
* S'inscrire à un cours
* Obtenir sa moyenne
* Etc...
```java=
public class Etudiant {
// Attributs...
public void sInscrireACours(Cours cours) {
// Logique pour s'inscrire à un cours
}
public double obtenirMoyenne() {
// Calcul de la moyenne
return moyenne;
}
// ...
}
```
---
Entité du monde réel : Étudiant
On instancie un objet en utilisant son constructeur avec new.
- Instance d'une classe :
```java=
Etudiant etudiant1 = new Etudiant("Jean", "Dupont", dateDeNaissance, 12345);
Etudiant etudiant2 = new Etudiant("Marie", "Lambert", dateDeNaissance, 54321);
```
---
## Partie 3 - Slide 26.
On peut comparer la classe à un plan d'un architecte et l'objet aux batiments qui vont être construit à partir de ce plan.
L'architecte va définir des données comme les matériaux à utiliser, les outils et les ouvriers en fonction de leur quailifacation.
Puis il va établir les méthodes :
Quel ouvrier avec quel outils et la quantités de matériaux pour monter un mur.
---
## Partie 3 - Slide 27.
**Les Classes Wrappers**
Définition :
L’API standard de Java fournit des classes qui permettent d’envelopper la valeur d’un type primitif et de les convertir en objet : on parle de « classes wrapper ».
---
## Partie 3 - Slide 28.
Type primitif : Objet associé
int : Integer
char : Character
float : Float
double : Double
long : Long
boolean : Boolean
byte : Byte
short : Short
---
## Partie 3 - Slide 29.
### quels sont les avantages des wrappers (et éventuels inconvénients) ?
**Les avantages**
Les classes wrappers ont été introduites pour envelopper les types primitifs dans des objets, permettant ainsi leur utilisation dans des contextes qui requièrent des objets.
Cela permet d'appeler des méthodes sur l'objet, ce qui n'est pas possible avec les types primitifs.
---
## Partie 3 - Slide 30.
- Elles permettent une meilleure <i>interopérabilité</i>* avec des bibliothèques et des API Java qui attendent des objets plutôt que des types primitifs.
(* assurer la compatibilité et la collaboration)
- par exemple, lorsque l’on travaille avec des ArrayList
```java=
// error
ArrayList<int> list = new ArrayList<>();
```
```java=
// fonctionne parfaitement
ArrayList<Integer> list = new ArrayList<>();
```
---
## Partie 3 - Slide 31.
- Une variable de type classe wrapper est un objet donc elle peut avoir la valeur spéciale null. Ce cas permet de signifier l’absence de valeur et de la tester dans les conditions comme 'if else', les 'switch case' ou encore dans les boucles.
```java=
// Génère une erreur
int a = null;
```
```java=
// fonctionne parfaitement
Integer a = null;
```
---
## Partie 3 - Slide 32.
- Toutes les classes wrappers définissent une méthode de classe de la forme parseXXX qui permet de convertir une chaîne de caractères en un type primitif :
Exemple :
```java=
boolean b = Boolean.parseBoolean("true");
int i = Integer.parseInt("256");
long l = Long.parseLong("10000000000");
```
sauf Character qui n'a pas cette méthode
!!! Cette méthode est à manipuler avec précaution. Elle peut présenter une exception ou un résultat inattendu si la valeur n’est pas bien contrôlée.
---
## Partie 3 - Slide 33.
- Les classes wrappers contiennent des constantes pour donner des informations utiles.
Exemple:
la classe java.lang.Integer déclare les constantes MIN_VALUE et MAX_VALUE qui donnent respectivement la plus petite valeur et la plus grande valeur représentables par la primitive associée.
```java=
int minValue = Integer.MIN_VALUE // -2 milliard et quelque
int maxValue = Integer.MAX_VALUE;// 2 milliard et quelque
Boolean bool = Boolean.TRUE;
```
Cela permet d’éviter les erreurs de surcharges lors du traitement de l’information en type primitif.
Malgrés tout, ces surcharges peuvent provoquer des résultats inattendus et doivent être surveillées et traitées.
---
## Partie 3 - Slide 34.
La classe wrapper Boolean utilise les constantes 'FALSE' et 'TRUE' mais peut aussi interpréter toute chaine de charactère autre que 'true' comme un false, ce qui est impossible avec le type primitif.
```java=
Boolean = "This text is without interest!"
// return FALSE
```
---
## Partie 3 - Slide 38.
**Points de vigilances**
Les classes wrappers sont conçues pour être immuables. Cela signifie que l’on ne peut pas modifier la valeur qu’elles prennent après leur création.
Chaque changement d’une variable instancié recréer un nouvel objet donc une nouvelle adresse mémoire.
```
1. Integer x = 5 ; // Crée un emplacement mémoire
2. x = 1 ; // x a bien changé de valeur mais est créé comme un nouvel objet dans une autre adresse mémoire.
3. L’ancienne adresse devient inutilisable et sera vidé par le « ramasse-miettes » de java.
4. Si x est changé 20 fois, on crée 20 adresses mémoires.
```
**Les types primitifs sont plus efficaces que les objets correspondants car ils prennent moins de ressources mémoires. Par conséquent, lorsque l’efficacité est requise, les types primitifs sont toujours recommandés.**
---
## Partie 3 - Slide 39.
**Instancier un objet Wrapper**
Il est possible de créer une instance d’une classe wrapper
- soit en utilisant son constructeur (new)
- Fonctionne mais est déprécié
- soit en utilisant la méthode de classe valueOf
- Est fortement recommandé
```java=
Integer i = Integer.valueOf(2);
// i = "2"
```
On retrouve 2 fois 'Integer' dans cette exemple.
La raison de cette redondance est due à la nécessité de convertir un entier primitif en un objet Integer, nous effections les étapes suivantes :
Nous créons un entier primitif de valeur 2.
Nous utilisons Integer.valueOf(2) pour créer un objet Integer i.
Il est possible de simplifier l'écriture de cette commande.
---
**Package**
Les classes Wrappers font parties du package java.lang.
Comme ce package est importer automatiquement à chaque compilation, il n'est pas nécessaire d'utiliser un import.
---
## Partie 3 - Slide 40.
**Boxing et le Unboxing**
Le boxing est la conversion d'un type primitif en classe wrapper d'objet correspondantes.
Par exemple, convertir :
- un int en Integer ,
- un double en Double ,
- et ainsi de suite.
```java=
int primitiveInt = 42; // Un type primitif (int)
Integer boxedInt = Integer.valueOf(primitiveInt); // Boxing : Conversion en objet Integer
```
Le Unboxing est la même chose mais dans l'autre sens.
```java=
Integer boxedInt = Integer.valueOf(42); // Integer
int primitiveInt = boxedInt.intValue(); // Unboxing : Conversion en int primitif
```
Le boxing et l'unboxing permettent aux développeurs d'écrire du code plus propre, le rendant plus facile à lire.
---
## Partie 3 - Slide 41.
L'autoboxing est la conversion automatique effectuée par le compilateur Java entre les types primitifs et leurs classes wrapper d'objet correspondantes.
```java=
int primitiveInt = 42;
Integer boxedInt = primitiveInt; // Autoboxing implicite
int anotherPrimitiveInt = boxedInt; // Unboxing implicite
```
---
## Partie 3 - Slide 15
**Un mot sur String**
String est un objet et n'a pas d'équivalent en primitif.
String enregistre chaque caractère dans primitif 'char'.
C'est comme si, pour lire une phrase, on épellait chaque mot.
String possède donc des méthode pour rendre le texte accessible aux humains.
---
## SOURCE :
[Les classes enveloppantes (Wrapper classes)](https://koor.fr/Java/Tutorial/java_wrapper_classes.wp)
[Les types primitifs et les Wrappers](https://gayerie.dev/epsi-b3-java/langage_java/types_primitifs.html)
[Dépassement de capacité](https://www.ukonline.be/cours/java/apprendre-java/chapitre4-7)
[Autoboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)
Sign in with Wallet
Connect another wallet