**Le typage en Java : types primitifs et objets**
---
**Plan**
1. Qu’est-ce qu’un type ?
2. Les types primitifs
3. Les objets
---
**Partie 1 : Qu’est-ce qu’un type ?**
---
**Partie 1 : Qu'est-ce qu'un type ?**
Définition
* Stocke une catégorie de données
* Permet de définir une zone de mémoire
* Est géré différemment suivant les langages de programmation
---
**Partie 1 : Qu'est-ce qu'un type ?**
Deux grands types de typage
* Le typage statique : le type des variables vérifiées à la compilation
* Le typage dynamique : le type des variables sont déterminés au moment de l'exécution
---
**Partie 1 : Qu'est-ce qu'un type ?**
Quels sont les avantages du typage statique ?
* Détection précoce des erreurs
* Meilleure performance
* Meilleure documentation du code
---
**Partie 1 : Qu'est-ce qu'un type ?**
Quels sont les inconvénients du typage statique ?
* Rigidité
* Plus de code à écrire
---
**Partie 1 : Qu'est-ce qu'un type ?**
Quels sont les langages de programmation qui utilisent le typage statique ?
* Java, C, C++, Swift
---
**Partie 1 : Qu'est-ce qu'un type ?**
Quels sont les avantages du typage dynamique ?
* Flexibilité
* Moins de code à écrire
* Facilité de prototypage
---
**Partie 1 : Qu'est-ce qu'un type ?**
Quels sont les inconvénients du typage dynamique ?
* Erreurs à l'exécution
* Moins de documentation
* Performance potentiellement réduite
---
**Partie 1 : Qu'est-ce qu'un type ?**
Quels sont les langages de programmation qui utilisent le typage dynamique ?
* Python, JavaScript, Ruby et PHP
---
**Partie 1. Qu’est-ce qu’un type ?**
Deux grands catégories de types en Java :
* Les types primitifs
* Les objets
---
**Partie 2 : Les types primitifs**
---
**Partie 2 : Les types primitifs**
Qu’est-ce qu’un type primitif ?
* Des types qui correspondent à des types de données de base
* En Java, 8 types primitifs
---
**Partie 2 : Les types primitifs**
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 : Les types primitifs**
Atelier 1
1. Crée une variable 'humanity' de manière à être compatible avec ce code et lui mettre la valeur de 8 000 000 000.
2. Réflexion : quel type as-tu choisis et pourquoi ?
```java=
public class Atelier {
public static void main(String[] args) {
// Créer la variable 'humanity' avec la valeur de 8 000 000 000.
System.out.println(humanity);
}
}
```
---
**Partie 2 : Les types primitifs**
Atelier 2
- Est-ce que le résultat obtenu est correct ?
- Comment corriger le code ?
```java=
public class Atelier {
public static void main(String[] args) {
int a = 10;
int b = 3;
int c = a / b;
System.out.println("Résultat : " + c);
}
}
```
---
**Partie 2 : Les types primitifs**
Les types primitifs ne sont pas spécifiques à Java :
* Utilisés en C, C++, C#
* De façon moins explicite, on retrouve les mêmes notions en Python, JavaScript
---
**Partie 2 : Les types primitifs**
Quels sont les avantages des types primitifs ?
* Efficacité
* Rapidité
* Facilité d'utilisation
---
**Partie 2 : Les types primitifs**
Quels sont les inconvénients des types primitifs ?
* Manques de fonctionnalités
* Ils ne sont pas des objets
* Impossibilité de définir des valeurs nulles
---
**Partie 2 : Les types primitifs**
Des questions en suspend...
---
**Partie 3. Les objets**
---
**Partie 3. Les objets**
Qu’est-ce qu’un objet ?
* Un type qui permet de modéliser des entités du monde réel
---
**Partie 3. Les objets**
Comment est-ce modélisé ?
* Une instance de classe
* Contient des données
* Contient des méthodes
---
**Partie 3. Les objets**
Exemple avec les données :
```java=
public class Student {
private String name;
private String firstName;
private LocalDate dateOfBirth;
private int identificationNumber;
// ...
}
```
Exemple avec les méthodes :
```java=
public class Student {
// Attributes...
public void enrollInCourse(Course course) {
// Logic for enrolling in a course
}
public double getAverage() {
// Calculate the average
return average;
}
// ...
}
```
Exemple avec les méthodes qui opèrent sur les données :
```java=
Student student1 = new Student("Wil", "Smith", dateOfBirth, 12345);
Student student2 = new Student("Maria", "Carrey", dateOfBirth, 54321);
```
---
**Partie 3. Les objets**
Comment transformer un type primitif en classe ?
* On utilise des wrappers
---
**Partie 3. Les objets**
Les classes wrappers
* int : Integer
* char : Character
* float : Float
* double : Double
* long : Long
* boolean : Boolean
* byte : Byte
* short : Short
---
**Partie 3. Les objets**
Quels sont les avantages des classes Wrappers ?
* Compatibilité et la collaboration
* Gestion du null
* Utilisation de parseXXX
* Constantes intégrées aux objets
* Utilisation des Booleans
---
**Partie 3. Les objets**
* Compatibilité et la collaboration
Exemple, lorsque l’on travaille avec des ArrayList :
```java=
// error
ArrayList<int> list = new ArrayList<>();
```
```java=
// fonctionne parfaitement
ArrayList<Integer> list = new ArrayList<>();
```
* Gestion du null
Exemple :
```java=
// Génère une erreur
int a = null;
```
```java=
// fonctionne parfaitement
Integer a = null;
```
* Utilisation de parseXXX
Exemple :
```java=
boolean b = Boolean.parseBoolean("true");
int i = Integer.parseInt("256");
long l = Long.parseLong("10000000000");
```
* Constantes intégrées aux objets
Exemple:
la classe java.lang.Integer déclare les constantes MIN_VALUE et MAX_VALUE
```java=
int minValue = Integer.MIN_VALUE // -2 milliard et quelque
int maxValue = Integer.MAX_VALUE;// 2 milliard et quelque
```
* Utilisation des Booleans
Exemple :
```java=
Boolean = "This text is without interest!"
// return FALSE
```
---
**Partie 3. Les objets**
Atelier 3
1. Modifie le code ci-dessous pour le rendre fonctionnelle.
2. Test le sans valeur, avec un null puis avec un nombre.
3. Quelle est l'intérêt de 'Integer' par rapport à 'int' dans cette exemple ?
```java=
public class Atelier {
public static void main(String[] args) {
int adressNumber;
if (adressNumber == null) {
System.out.println("This client has no number.");
} else {
System.out.println("The client lives at number " + adressNumber);
}
}
}
```
---
**Partie 3. Les objets**
Atelier 4
1. Quelle est la particularité du nombre "1 000" ?
2. Quelle est l'une des limites de parseXxx ?
3. Réflexion : que peux tu faire pour gérer le risque d'erreur ?
```java=
public class Atelier {
public static void main(String[] args) {
int l = Integer.parseInt("1 000");
System.out.println(l);
}
}
```
---
**Partie 3. Les objets**
Atelier 5
1. Que ce passe t'il avec ce code ?
2. Quelle est la leçon a en tirer ?
```java=
public class Atelier {
public static void main(String[] args) {
int counter = Integer.MAX_VALUE;
System.out.println(counter);
counter++;
System.out.println(counter);
}
}
```
---
**Partie 3. Les objets**
Les points de vigilance
* Les classes wrappers sont « immutables »
* Préférer les types primitifs quand l’efficacité est requise
---
**Partie 3. Les objets**
Instancier un objet Wrapper
* New ou valueOf
* Le package java.lang
---
**Partie 3. Les objets**
Boxing et Unboxing
* Boxing : conversion d’un type primitif en classe objet
* Unboxing : processus inverse du boxing
* Autoboxing : conversion automatique
---
**Partie 3. Les objets**
Atelier 6
1. Modifie ce code pour utiliser le boxing et l'unboxing ?
2. Modifie le code pour faire de l'auto-boxing et du unboxing automatique ?
```java=
class Atelier {
public static void main(String[] args) {
Integer i = Integer.valueOf("10");
System.out.println("Value of i: " + i);
int j = Integer.valueOf(i);
System.out.println("Value of j: " + j);
}
}
```
---
**Partie 3. Les objets**
String
* String est un objet, pas d’équivalent primitif
* String enregistre chaque caractère dans un primitif char
---
**Conclusion**
* Type primitif ou type objet, que choisir ?
* Apprendre à choisir le bon type
* Typage et classes
Sign in with Wallet
Connect another wallet