01-bases-java.Rmd

# (PART) JAVA {-} 

# Les bases de java

Cette partie comporte principalement des rappels de l'initiation à Java. Les notions sont donc peu détaillées.

> Des cheatsheets pratiques [ici](https://www.codecademy.com/resources/cheatsheets/language/java)

## Le langage Java

Java est un langage qui doit être compilé puis exécuté.  

> Plus de détails sur l'installation de Java et les IDE disponibles (\@ref(annexe))

On travaille dans un projet Java, à l'intérieur duquel on organise les fichiers dans des packages.  
Un **package** est représenté par des dossiers successifs situés dans le *source folder* ou *src*.  

> Par convention, on appelle un package que l'on crée soi-même avec la langue, l'auteur ou groupe d'auteurs, le nom du projet, un mot-clé pour décrire le but du package : `fr.eni.ecole.tp2.metier`, `fr.lsarribouette.monprojetdejeu.test`

Un fichier .java porte le nom de la classe qu'il définit : `MaPremiereClasse.java`

> Par convention, le nom d'une classe est en UpperCamelCase.

La méthode `main` d'une classe est la première ligne qui s'exécute. C'est à l'intérieur de cette classe que s'écrivent les lignes de code à exécuter.

> Les instructions du module peuvent être testées à cet endroit.

Pour bien commencer :

  - on crée un projet : `MonPremierProjet`
  - on crée un package : `fr.lsarribouette.monpremierprojet`
  - on crée un fichier : `MaPremiereClasse.java`
  - on complète le fichier avec la classe et la méthode `main` :
  
```{java, eval=FALSE}
package fr.lsarribouette.monpremierprojet.mapremiereclasse

public class MaPremiereClasse {
  public static void main(String[] args) {
    // instructions
  }
}
```

## Affichage sur la console

Sortie standard et sortie des messages d'erreur :
```{java, eval=FALSE}
System.out.println()
System.err.println()
```

> `ln` permet le retour à la ligne après le message.

> Ce sont deux flux distincts : il peut y avoir concurrence de flux (et ainsi un affichage console dans un ordre surprenant)

Formatage des messages possible avec `System.out.printf()` ou `String.format()`, dont les paramètres sont :

  - une String avec autant d'indicateurs que nécesaires,
  - un paramètre supplémentaire pour chaque indicateur appelé.

Les principaux indicateurs sont `%d` (nombre entier), `%f` (nombre décimal), `%s` (chaîne de caractères), `%n` (retour à la ligne).

```{java, eval=FALSE}
System.out.printf('Nom: %s, prénom; %s, âge: %d ans, taille: %.2fm',
                  nom, prenom, age, taille)
  // Nom: Lebonvieux, prénom: Bob, âge: 64 ans, taille: 1.73m 
```

> `%.2f` permet de limiter le nombre à deux chiffres après la virgule.

> `%-75s` permet d'obtenir un chaîne de caractère de 75 caractères de long : elle sera complétée par des espaces si besoin.

## Déclaration de variables

Une variable : `type variable = valeur`  
Une constante : `type final CONSTANTE = valeur`

On remplace, bien sûr, par le type voulu (`int, float, long, double, char, boolean, String,`...).

> On précise : `float varFloat = 65f` et `long varLong = 15648979L` car ?????

> On peut déclarer une constante en dehors du `main` pour qu'elle soit accessible dans tout le package : `public static final type NOM_CONSTANTE = valeur`

## Tableaux

Les tableaux ne prennent qu'un seul type de donnée, ils sont déclarés avec des crochets et ont une taille fixe, précisée entre les crochets : `type[] tab = new type[dimension]`.  
Ils sont un type de référence : ils sont instanciés sur le tas (*càd* appelés via une adresse mémoire).  
  
On accède aux cases d'un tableau avec leurs indices (qui commencent à zéro) : `tab[i]`.

> Une case vide d'un tableau prend la valeur par défaut de son type (ex: zéro pour un int).

## Saisies utilisateur

Méthodologie :

  - on utilise le package `Scanner`, qu'il faut importer
  - on instancie un nouveau Scanner `scan` en lui donnant `System.in` en paramètre
  - on affiche un message à l'utilisateur
  - on stocke la saisie dans une variable du type attendu grâce aux méthodes `next*()` de `Scanner` (`nextInt(), nextFloat(), nextLine(),`...)
  - on ferme le Scanner à la fin des saisies

```{java, eval=FALSE}
import java.util.Scanner;
Scanner scan = new Scanner(System.in);
System.out.println('Comment allez-vous ?');
String saisie = scan.nextLine();
System.out.println('Combien font 2+2 ?');
int reponse = scan.nextInt();
scan.nextLine();
scan.close();
```

> Les méthodes `next*()` ne prennent pas en compte le retour à la ligne, sauf `nextLine()`. Si un `nextLine()` suit un  `next*()`, il va prendre en compte son retour à la ligne et ne rien afficher. Pour éviter toute confusion, on fait suivre un `next*()` par un `nextLine()` vide.

## Conditionnelles

Instruction `if` :
```{java, eval=FALSE}
if (condition booleenne) {
  instructions;
} else if (autres condition booleenne) {
  autres instructions;
} else {
  autres instructions;
}
```

> Ne pas confondre affectation (`=`) et comparaison (`==`).

> Deux Strings se comparent avec `equals()` : `maString1.equals(maString2)`


Instruction `switch` :
```{java, eval=FALSE}
switch (variable) {
case valeur1:
    instructions;
    break;
case valeur2:
case valeur3:
    instructions;
    break;
default:
    instructions;
    break;
}
```

> On peut associer plusieurs valeurs à une instruction : c'est le `break` qui indique la limite d'action des instructions.

## Boucles

Boucle `for` :  
On connait le nombre d'itérations en avance.
```{java, eval=FALSE}
for (int i=0; i<valeur; i++) {
  instructions;
}
```

> Une boucle peut utiliser la taille d'un tableau avec `tab.length`.

Boucle `foreach` :  
On lit un à un chaque élément d'un tableau.
```{java, eval=FALSE}
type[] tab = new type[dimension];
for(type element: tab) {
  instructions;
}
```

Boucle `while` :  
On ne connait pas le nombre d'itérations en avance et on ne veut pas forcément rentrer dans le boucle.  
On reste dans la boucle *tant que* la condition est **vraie**.
```{java, eval=FALSE}
while(condition booleenne) {
  instructions;
}
```

Boucle `do while` :  
On ne connait pas le nombre d'itérations en avance mais on veut forcément rentrer dans la boucle au moins une fois.  
On reste dans la boucle *tant que* la condition est **vraie**.
```{java, eval=FALSE}
do {
  instructions;
} while (condition booleenne);
```

> On déclare les variables en dehors des boucles si on a besoin qu'elles soient accessibles. Il faut souvent les initialiser dès la déclaration (par exemple à zéro ou `null`). 

## Fonctions et procédures 

Ce sont des méthodes paramétrables: 

  - les procédures ne renvoient rien : `void`
  - les fonctions renvoient une et une seule valeur, avec `return`
```{java, eval=FALSE}
void nomProcedure(parametres potentiels) { 
  instructions; 
}

type nomFonction(parametres potentiels) { 
  instructions;
  return variableDuBonType;
  }
```

> La variable retournée doit être du même type qu'annoncé dans le signature de la fonction.

## Visiblité et encapsulation {#visibilite-encapsulation}

La visibilité représente l'accessibilité d'un objet (classes, variables, attributs, méthodes...) :

  - par défaut : limitée au package
  - `public` : sans limite (n'importe où)
  - `private` : limitée à la classe
  - `protected` : limitée à la classe et ses héritières

L'encapsulation détermine la portée d'une variable : elle est plus ou accessible selon le bloc dans lequel elle est déclarée.  
Par exemple :   
Une variable déclarée dans une boucle sera uniquement accessible à l'intérieur de celle-ci.
Une variable déclarée dans une fonction sera uniquement accessible à l'intérieur de celle-ci.  
Une variable déclarée dans le `main`, quant à elle, sera accessible aux méthodes utilisées dans le `main`.

--> **Une classe est responsable de ses données.**  
Les variables déclarées dans une classe (*attributs*) ne sont donc pas accessibles à l'extérieur de celle-ci, pour les protéger. Des méthodes spécifiques sont définies dans la classe pour accéder ou modifier ces variables depuis l'extérieur : appelées des assesseurs et mutateurs (*getters* et *setters*), elles permettent de sélectionner les variables auxquelles on donne accès et d'effectuer des contrôles.  

## Les exceptions {#intro-exceptions}

*(voir le chapitre dédié \@ref(les-exceptions) pour plus de détails et des exemples)*

Elles permettent de garantir une sortie propre et que le programme ne s'arrête pas de manière incontrôlée, s'il s'agit d'une situation contrôlable.

Méthodologie pour traiter une exception prédéfinie :

  - on récupère le nom de l'exception lorsque le programme s'arrête
  - on entoure le bout de code concerné dans un `try{}`
  - on fait suivre par un `catch(Exception e) {}`
  - si besoin, on ajoute un `finally {}` pour exécuter certaines instructions dans tous les cas (que l'exception soit levée ou non)
  
```{java, eval=FALSE}
try {
  bout de mon code, surlequel je leve une exception;
} catch (uneException e) {
  instructions si levee de exception;
} finally {
  instructions optionnelles;
}
```

> Une exception est un type : c'est pourquoi je la déclare et la nomme (`e` par exemple).

Méthodologie pour une méthode définie comme levant obligatoirement une exception :

  - on ajoute `throws Exception` à sa signature 
  - on ajoute dans son body une instruction `if` qui, si elle est vraie, permet de levée l'exception avec `throw new Exception`
  - lors de l'appel de cette fonction, elle devra obligatoirement être encapsulée d'en un `try...catch`
  
```{java, eval=FALSE}
... nomMethode(...) throws Exception {
  if (condition booleenne) {
    throw new Exception(...);
  }
}
```

> La méthode `.getMessage()` permet de récupérer le message d'erreur.

> La 'StackTrace' représente la totalité du message d'erreur.

## Ecriture et lecture dans un fichier

Méthodologie pour écrire dans un fichier :

  - on utilise le package `FileWriter`, qu'il faut importer
  - on instancie un nouveau FileWriter `fw` en lui donnant le chemin vers le fichier en paramètre
  - on écrit dans le fichier
  - on ferme le FileWriter à la fin de l'écriture 

```{java, eval=FALSE}
import java.io.FileWriter;
FileWriter fw = new FileWriter('.\cheminVersFichier\fichier.txt');
fw.write(...);
fw.close();
```

> On peut indiquer le chemin relatif avec `.\` qui part de la racine de l'espace de travail (*working directory* ou *workspace*).

Méthodologie pour lire dans un fichier :

  - on utilise le package `FileInputStream`, qu'il faut importer
  - on instancie un nouveau FileInputStream `fi` en lui donnant le chemin vers le fichier en paramètre
  - on utilise le package `Scanner`, qu'il faut également importer
    - on instancie un nouveau Scanner `scan` en lui donnant le FileInputStream `fi` en paramètre
    - on lit les lignes une à une tant qu'il en reste avec une boucle `while`, `scan.hasNextLine()` et `nextLine()`
    - on ferme le Scanner à la fin des saisies
  - on ferme le FileInputStream à la fin de la lecture 
```{java, eval=FALSE}
import java.io.FileInputStream;
import java.util.Scanner;

FileInputStream fi = new FileInputStream('.\cheminVersFichier\fichier.txt');
Scanner scan = new Scanner(fi);
while(scan.hasNextLine()) {
  System.out.println(scan.nextLine());
}
scan.close();
fi.close();
```

**Sauf que** FileWriter et FileInputStream sont des méthodes qui lèvent obligatoirement des exceptions !! Il faut les entourer de `try...catch` :
```{java, eval=FALSE}
import java.util.Scanner;
import java.io.FileWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.channels.FileLockInterruptionException;
import java.io.FileNotFoundException;
import java.io.IOException;


public class Ecriture {
	public static void main(String[] args) {
		FileWriter fw = null;
		try {
			fw = new FileWriter('.\Documents\tot.txt');
			fw.write("Hello world \n");
			for(int i=0;i<1000;i++) {
				fw.write(Integer.toString(i) + "\n");
			}
		} catch (IOException e) {
			System.out.println('Impossible d\'écrire dans le fichier');
		} finally {
			try {
				fw.close();
			} catch (IOException e) {
				System.out.println('Problème de fermeture');
			}
		}
	}
}

public class Lecture {

	public static void main(String[] args) {
		Scanner scan = null; 
		FileInputStream fichier = null;
		try {
			fichier = new FileInputStream('.\Documents\tot.txt');
			scan = new Scanner(fichier);
			while(scan.hasNextLine()) {
				System.out.println(scan.nextLine());
			}
		} catch (FileNotFoundException e) {
			System.out.println('Lecture impossible');
		} finally {
			scan.close();
			try {
				fichier.close();
			} catch (IOException e) {
				e.printStackTrace();
				System.out.println('Fermeture impossible');
			}
		}
	}
}
```

> Portée des variables : lorsqu'on ajoute le traitement des exceptions (`try...catch`), on déclare les variables en dehors pour y avoir accès.

> Alternative : déclarer les FileWriter, FileInputStream et Scanner dans le `try` : `try(FileWriter f = new FileWriter('./valeurs.txt') {...}`


## Types de données

Les données sont catégorisées en deux grands types : 

  - type valeur = primitif
  - type référence = object, complexe

Il existe 8 types de données primitives : `boolean`, `byte`, `char`, `float`, `int`, `long`, `short`, `double`.  
Lors du passage en paramètre d'une primitive, elle est copiée et c'est cette copie qui est modifiée par la suite.  
Lors du retour par une fonction d'une primitive, c'est sa valeur qui est retournée. 

Il existe de très nombreux types de données référence : `String`, tableaux(`[]`), collections (`ArrayList`), instances d'objet...  
Lors du passage en paramètre d'un objet, son adresse en mémoire est copiée et c'est bien l'original qui est modifié par la suite.  
Lors du retour par une fonction d'un objet, c'est son adresse en mémoire qui est retournée. 

> Plus de détails sur les types en Java [ici](https://www.geeksforgeeks.org/data-types-in-java/)

> Plus de détails sur l'allocation de la mémoire [ici](https://fr.ichlese.at/what-is-memory-allocation-java)

## Conversions

On a vu trois façons de convertir une variable :
  
  - Passer d'un type primitif à un autre (\@ref(conversion-prim-prim))
  - Passer d'un type primitif à son équivalent objet, et réciproquement (\@ref(conversion-prim-obj))
  - Passer d'un type objet à un autre (\@ref(conversion-obj-obj))

> Plus de détails sur les conversions en Java [ici](https://www.ukonline.be/cours/java/apprendre-java/chapitre2-4)

### Passer d'un type primitif à un autre {#conversion-prim-prim}

Si on ne perd pas d'informations (par exemple, un entier converti en nombre décimal), la conversion est **implicite** et sera gérée automatiquement.
```{java, eval=FALSE}
int a = 5;
double b = a;
System.out.println(a); // 5
System.out.println(b); // 5.0
```
  
Si on perd de l'information (par exemple, un nombre décimal converti en entier), la conversion doit être **explicite**.  
On "cast" alors la variable en mettant le type cible entre parenthèses : `int uneVariableInt = (int) uneVariableDoubleAConvertir`.
```{java, eval=FALSE}
double c = 15.76;
int d = c ; // Exception : "Type mismatch: cannot convert from double to int"
int d = (int) c;
System.out.println(c); // 15.76
System.out.println(d); // 15
```


### Passer d'un type primitif à son équivalent objet, et réciproquement {#conversion-prim-obj}

Pour passer un type primitif à son équivalent objet, on utilise des classes *wrapper* : `Integer varObjet = new Integer(10)` (avec 10 un entier primitif).

> C'est la notion de *boxing*.

A l'inverse, on utilise ces mêmes classes pour passer d'un objet de *wrapper* à sa valeur primitive : `int varPrimitive = varObjet`.  

> C'est la notion de *unboxing*.

```{r cache=TRUE, echo=FALSE, fig.cap='(ref:tab-wrapper)', message=FALSE, warning=FALSE}
library(dplyr)
library(kableExtra)

tab <- dplyr::bind_cols(
  c("boolean",
    "byte",
    "char",
    "float",
    "int",
    "long",
    "short",
    "double"), 
  c("Boolean",
    "Byte",
    "Character",
    "Float",
    "Integer",
    "Long",
    "Short",
    "Double"),
  ) 
tab %>% setNames(c("Types primitifs", "Classes Wrapper")) %>% 
  kableExtra::kbl("html", caption = "Liste des 8 types primitifs et leur classe wrapper correspondante") %>% 
  kable_styling(full_width = FALSE)

```

Lorsque l'on convertit un type primitif à son équivalent objet, et réciproquement, il n'y a **pas de perte d'informations** : la conversion est donc **implicite** et sera gérée automatiquement.

> C'est la notion de *auto-boxing* et *auto-unboxing*.

```{java, eval=FALSE}
Integer inum = 3; //Autoboxing : on affecte un int à un Integer
Long lnum = 32L; //Autoboxing : on affecte un long à un Long
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(11); //Autoboxing : on affecte des int à un ArrayList qui attend des Integer
arrayList.add(22); 

int num = inum; //Auto-unboxing : on affecte un objet Integer à un int
int num2 = arrayList.get(0); //Auto-unboxing : la méthode get retourne un objet Integer

System.out.println(inum); // 3
System.out.println(lnum); // 32
System.out.println(arrayList); // [11, 22]
System.out.println(num); // 3
System.out.println(num2); // 11
```

> Ce type de conversion est très utile notamment pour utiliser le package `java.util` qui ne prend en compte que des types objets, notamment avec `ArrayList`.

> Plus de détails sur les notions de *auto-boxing* et *auto-unboxing* en Java [ici](https://beginnersbook.com/2014/09/java-autoboxing-and-unboxing-with-examples/)

Il est possible de faire la conversion de manière **explicite** avec les méthodes de classes *wrapper* :

  - `valueOf()`, qui prend en paramètre au choix une `String s` ou une `primitive p`  
  Elle permet de créer un objet *wrapper* à partir d'une primitive ou d'une String de manière explicite. 
  - `xxxValue()`, qui ne prend aucun paramètre 
  Elle permet de récupérer la primitive stockée dans un objet *wrapper* de manière explicite, **uniquement** pour les types nombre.
  
```{java, eval=FALSE}
//--- valueOf()
// avec une String en paramètre
Integer I1 = Integer.valueOf("10");
Double D1 = Double.valueOf("56.3");
Integer I2 = Integer.valueOf("ten"); // RuntimeException : "java.lang.NumberFormatException" car
                                     // la valeur en paramètre est convertie littéralement
System.out.println(I1); // 10
System.out.println(D1); // 56.3

// avec une primitive en paramètre
Double D2 = Double.valueOf(99.887654);
Character C1 = Character.valueOf('a');

System.out.println(D2); // 99.887654
System.out.println(C1); // a

//---xxxValue()
int i = I1.intValue();
double d = D2.doubleValue();
char c = C1.characterValue(); // Exception : "The method characterValue() is undefined for the
                              // type Character"

System.out.println(i); // 10
System.out.println(d); // 99.887654

```


### Passer d'un type à un autre {#conversion-obj-obj}

Pour passer d'un type à un autre, la conversion est cette fois forcément **explicite**.

On utilise également les méthodes de classes *wrapper* :


  - `parseXxx()`, qui prend en paramètre `String s`  
  Elle permet de convertir une String en une primitive.
  - `toString()`, qui prend au choix aucun paramètre ou une `primitive p`  
  Elle permet de convertir un objet *wrapper* ou une primitive en String.

```{java, eval=FALSE}
//--- parseXxx()
int i = Integer.parseInt("456");
double d = Double.parseDouble("2300.74");
boolean b = Boolean.parseBoolean("true");

System.out.println(i); // 456
System.out.println(d); // 2300.74
System.out.println(b); // true

//--- toString()
// public (sans parametre)
Integer I = 6;
String s = I.toString();
System.out.println(s); // 6

// avec une String en paramètre
String s2 = Integer.toString(33);
System.out.println(s); // 33

String s1 = Character.toString('*');
System.out.println(s1); // *

```

> Plus de détails sur les méthodes de classes *wrapper* en Java [ici](https://www.geeksforgeeks.org/utility-methods-of-wrapper-classes-in-java/)