Le typage en Java

English version --- ### Java Typing: Primitive Types and Objects --- ### PLAN 1. What is a type? 2. Primitive Types 3. Objects --- ### Part 1 : What is a type? --- ### What is a type in computing? - A type is a category of data assigned to a variable that will store values. - Each type determines a predefined memory area. - Typing is handled differently from one programming language to another. --- ### Static and Dynamic Typing In computer science, we refer to static typing and dynamic typing. In static typing: the type of variables is checked at compile-time. In dynamic typing: the type of variables is determined at runtime. --- ### Static Typing: Advantages, Disadvantages, Associated Languages *Advantages:* - **Early Error Detection:** Type errors are detected at compile-time, helping to prevent many potential errors before program execution. - **Better Performance:** Static typing often allows for faster program execution, as certain optimizations can be made at compile-time due to prior knowledge of types. - **Improved Code Documentation:** By explicitly specifying types, the code becomes more readable and documented, making it easier for other developers to understand. *Disadvantages:* - **Rigidity:** The explicit declaration of types can make the code more rigid and require additional effort to make changes. - **More Code to Write:** The need to explicitly declare types can lead to longer blocs of code. *Which languages use static typing?* * Java, C, C++, Swift --- ### Dynamic Typing: Advantages, Disadvantages, Associated Languages *Advantages* - **Flexibility:** Variables can be redefined with different data types, making the code more flexible and adaptable. - **Less Code to Write:** By not requiring explicit type declarations, the code can be more concise and quicker to write. - **Ease of Prototyping:** The flexible nature of dynamic typing is often appreciated during rapid prototyping or exploratory programming. *Disadvantages* - **Runtime Errors:** Type errors are often only detected at the time of program execution, leading to bugs that can be challenging to identify. - **Less Documentation:** Without explicit type declarations, understanding the code can be more difficult, especially for complex projects. - **Potentially Reduced Performance:** Dynamically typed languages may be less performant as type checks are performed at runtime, adding an overhead in terms of time. *Which languages use dynamic typing?* * Python, JavaScript, Ruby et PHP --- ### Types in Java Two main categories of types in Java: 1. Primitive types 2. Objects --- ### Part 2 : Primitive types --- ### What is a primitive type? In computer science, primitive data types are a set of fundamental data types. In Java, there are 8 primitive types. --- ### List of Primitive Types in Java *Integer Types:* byte, short, int, long *Decimal Types:* float, double *Boolean Type:* boolean *Character Type:* char --- ### Is the concept of primitives unique to Java? No, primitive types are not specific to Java. They are present in several programming languages. * Used in C, C++, C# * In other languages, even if the concept of primitive types is not explicitly stated, similar notions exist (Python, JavaScript) --- ### What are the advantages of primitive types? - **Efficiency:** Primitive types are more efficient in terms of memory usage and performance compared to objects. They are straightforward and take up less memory space. - **Speed:** Operations on primitive types are generally faster than on objects because they are directly manipulated by the processor. - **Ease of Use:** They are easy to use and understand as they represent simple values without additional complexity. --- ### What are the disadvantages of primitive types? - **Lack of Features:** Primitive types do not have methods or features inherent to themselves. For example, an integer (int) does not have associated methods for performing more advanced operations. - **Not Objects:** Primitive types cannot be used with certain object features. - **Inability to Define Null Values:** Primitive types cannot have a null value. For example, an int cannot be null. --- ### Many Unanswered Questions - How to overcome the limitations of primitive types? - Can primitive types be transformed into objects? - What are the advantages of objects? --- ### Part 3 : What is an object? --- ### Definition An object offers a more efficient modeling of real-world entities by encapsulating data and behaviors related to these entities. * It is an instance of a class. * It contains data. * It contains methods that operate on its data. --- ### Real-world entity: Example: Student The object contains data: Name, first name, date of birth, etc... ```java= public class Student { private String name; private String firstName; private LocalDate dateOfBirth; private int identificationNumber; // ... } ``` **The object contains methods that operate on the data, such as:** * Enrolling in a course * Getting the average * Etc... ```java= public class Student { // Attributes... public void enrollInCourse(Course course) { // Logic for enrolling in a course } public double getAverage() { // Calculate the average return average; } // ... } ``` **An object is an instance usting its constructor with 'new.'** Creating an instance of a class: ```java= Student student1 = new Student("Wil", "Smith", dateOfBirth, 12345); Student student2 = new Student("Maria", "Carrey", dateOfBirth, 54321); ``` We can compare a class to an architect's blueprint and an object to a building that will be constructed based on its plan. The architect will define data such as materials to use, tools, and workers based on their qualifications. Then, he will establish methods: which worker with which tools and which quantity of materials are needed to build a wall. --- ### Wrapper Classes Since primitive types are not classes, the standard Java API also provides classes that allow you to wrap the value of a primitive type. These are called 'wrapper classes.' ``` Primitive Type: Associated Object int : Integer char : Character float : Float double : Double long : Long boolean : Boolean byte : Byte short : Short ``` --- ### What are the advantages of wrappers (and potential disadvantages)? Wrapper classes were created to wrap primitive types in objects, enabling their use in contexts that require objects. This allows methods to be called on the object, which is not possible with primitive types. - They enable better interoperability with Java libraries and APIs that expect objects rather than primitive types, ensuring compatibility and collaboration. - For example, when working with ArrayLists : ```java= // error ArrayList<int> list = new ArrayList<>(); ``` ```java= // works perfectly ArrayList<Integer> list = new ArrayList<>(); ``` - A variable of the wrapper class type is an object, so it can have the special value 'null'. This case allows you to signify the absence of a value and test it in conditions like 'if-else,' 'switch-case,' or loops. ```java= // it's impossible int a = null; ``` ```java= // works perfectly Integer a = null; ``` - All wrapper classes define a class method in the form of 'parseXXX' that allows converting a string into a primitive type: Example : ```java= boolean b = Boolean.parseBoolean("true"); int i = Integer.parseInt("256"); long l = Long.parseLong("10000000000"); ``` Except for Character, which lacks this method. **Be cautious when using this method, as it can result in an exception or unexpected output if the value is not well controlled.** - Wrapper classes contain constants to provide useful information. ***Example:*** The java.lang.Integer class declares the constants MIN_VALUE and MAX_VALUE, which respectively give the smallest and largest values representable by the associated primitive. ```java= int minValue = Integer.MIN_VALUE // -2 billion and counting; int maxValue = Integer.MAX_VALUE // 2 billion and counting; ``` This helps prevent overloading errors when processing information as primitive types. **However, these overloads can still lead to unexpected results and should be monitored and handled.** ***Other example :*** In primitive type, boolean = false takes 0 in memory. boolean = true takes 1 in memory. So, 1 bit. The wrapper class Boolean uses the constants 'FALSE' and 'TRUE,' but it can also interpret any string other than 'true' as false, which is not possible with the primitive type. ```java= Boolean = "This text is without interest!" // return FALSE ``` --- ### Instantiating a Wrapper Object It is possible to create an instance of a wrapper class: - By using its constructor (new) - Works but is deprecated - By using the class's valueOf class method - Highly recommended ```java= Integer i = Integer.valueOf(2); // i = "2" ``` In this example, we have 'Integer' appearing twice. The reason for this redundancy is the need to convert a primitive integer into an Integer object, which involves the following steps: 1. We create a primitive integer with a value of 2. 2. We use `Integer.valueOf(2)` to create an Integer object `i`. It is possible to simplify the writing of this command. This is called boxing. --- ### Package Wrapper classes are part of the **'java.lang'** package. Since this package is automatically imported during every compilation, there is no need to use an explicit import statement. --- ### The boxing and the unboxing. **Boxing** is the conversion of a primitive type into the corresponding object wrapper class. For example, converting: * int to Integer, * double to Double, * and so on. ```java= int primitiveInt = 42; // A primitive type (int) Integer boxedInt = Integer.valueOf(primitiveInt); // Boxing: Conversion to Integer object ``` **Unboxing** is the same thing but in the opposite direction. ```java= Integer boxedInt = Integer.valueOf(42); // Integer int primitiveInt = boxedInt.intValue(); // Unboxing: Conversion to primitive int ``` Boxing and unboxing allow developers to write a cleaner code, making it easier to read. **Autoboxing** is the automatic conversion performed by the Java compiler between primitive types and their corresponding object wrapper classes. ```java= int primitiveInt = 42; Integer boxedInt = primitiveInt; // Autoboxing implicite int anotherPrimitiveInt = boxedInt; // Unboxing implicite ``` --- ### A few words about String classes String is an object and has no primitive equivalent. String stores each character in the primitive 'char' type. It's like spelling out each word to read a sentence. String has methods to make the text accessible to humans. --- ### Conclusion - Primitive type or object type, which one to choose? If the variable you're declaring needs to be able to receive a null, then an object type will certainly be more appropriate. On the other hand, if the need for speed and performance is a priority, then a primitive type will certainly be preferred. - Learn to choose the right type: whether primitive or object, it's important to select the most appropriate type for your needs. - Typing and classes: when you create a class, you create a new type. --- Version en français --- ## Le typage en Java : types primitifs et objets --- ## 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 : qu'est-ce qu'un type ? --- ## Partie 1 : qu'est-ce qu'un type ? **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 : qu'est-ce qu'un type ? **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 : qu'est-ce qu'un type ? **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 : qu'est-ce qu'un type ? **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 : qu'est-ce qu'un type ? **Quels sont les langages qui utilisent un typage statique ?** Java, C, C++, Swift --- ## Partie 1 : qu'est-ce qu'un type ? **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 : qu'est-ce qu'un type ? **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 : qu'est-ce qu'un type ? **Quels sont les langages qui utilisent un typage dynamique ?** Python, JavaScript, Ruby et PHP --- ## Partie 1 : qu'est-ce qu'un type ? **Les types en Java** Deux grandes 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 ?** 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 : 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 **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 : les types primitifs **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 : les types primitifs **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 : les types primitifs **De nombreuses questions en suspens** Comment dépasser les limites des types primitifs ? Peut-on transformer des types primitifs en objets ? Quels sont les avantages des objets ? --- ## Partie 3 : les objets --- ## Partie 3 : les objets **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 : les objets - 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 : les objets 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 : les objets 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 : les objets **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 : les objets Type primitif : Objet associé 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 wrappers et les é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 : les objets - Elles permettent une meilleure interopérabilité* 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 : les objets - 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 : les objets - 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 : les objets - 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 : les objets 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 : les objets **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 : les objets **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 : les objets **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 : les objets 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 : les objets **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. --- ### Conclusion - Type primitif ou type objet, que choisir ? Si la variable que l'on déclare doit pouvoir recevoir un null, alors le choix d'un objet sera certainement plus pertinent. En revanche, si le besoin de rapidité et performance est prioritaire, alors un type primitif sera certainement privilégié. - Apprendre à choisir le bon type : qu'il s'agisse d'un primitif ou d'un objet, il est important de sélectionner le type le plus approprié à notre besoin. - Typage et classes : lorsque l'on créé une classe, on créé un nouveau type. --- **SOURCE** [Java](https://en.wikipedia.org/wiki/Java_(programming_language)) [Type system](https://en.wikipedia.org/wiki/Type_system) [Primitive data types](https://en.wikipedia.org/wiki/Primitive_data_type) [Primitive data types in Java](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html) [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)