02-utilisation-classes.Rmd

# (PART) POO {-} 

# L'utilisation des classes

Définition POO

Objectif : 

  - Regrouper des variables "qui vont bien ensemble"
  - Associer les méthodes qui manipulent ces valeurs
    
**Classe** = un regroupement d'objets caractérisés par une sémantique commune,  
*dit autrement*, une classe est un modèle qui permet de créer des objets ayant des caractéristiques communes

**Instance** = un élément de ce regroupement

## Utiliser une classe

Méthologie :

  - on importe la classe (\@ref(import-classe)) : `import package.souspackage.Classe;`
  - on déclare une variable de type objet (\@ref(declare-classe)) : `Classe varDeTypeObjet ...`
  - on crée une instance d'objet grâce au constructeur (\@ref(instance-classe)) : `... = new Classe(liste de parametres potentiels);`

Exemple avec une classe que l'on connait : `Scanner`

```{java, eval=FALSE}
import java.util.Scanner;
Scanner console = new Scanner(System.in); // pour info : le paramètre System.in permet 
                                          // de récupérer la saisie utilisateur
```

### Importer la classe {#import-classe}

Une classe est définie dans un fichier du même nom, ainsi les classes sont définies dans des fichiers distints.

> Plus de détails sur l'organisation des fichiers dans un projet Java dans le cours de Développement en couche.

La méthode `main()` est la méthode principale : c'est le point d'entrée du programme et la première méthode exécutée. 

> On peut avoir plusieurs fichiers avec une classe `main`, par exemple pour tester individuellement les classes (TestClasse1.java, TestClasse2) : c'est alors la classe `main` dans laquelle on se trouve qui est exécutée.  
*Remarque* : le programme entier est exécutée quand même, on peut donc avoir des erreurs survenues dans d'autres `main`.

Pour utiliser une classe, il faut lier le fichier qui appelle la classe avec le fichier de la classe : c'est l'importation.  
On précise le package où se trouve la classe, les potentiels sous-packages et enfin le nom de la classe en question.

> On peut importer toutes les fonctions d'un sous-package avec `*` : `import package.souspackage.*;`  
Pratique déconseillée car elle induit une perte de perfomance si le package importé est très lourd.

### Déclarer une variable de type objet {#declare-classe}

La classe est un type complexe (ou objet, ou référence) et elle est utilisée pour déclarer une variable complexe (ou objet), à l'instar des types primitifs.

### Créer une instance d'objet {#instance-classe}

Une instance d'objet se crée en l'initalisant avec le mot-clé `new` suivi de l'appel à un constructeur. 

Un constructeur est une méthode très particulière. Elle s'appelle toujours comme la classe et peut prendre soit aucun paramètre, soit un ou plusieurs (notion de *surcharge* (\@ref(surcharge))).

> Les paramètres potentiels sont listés dans la documentation java (ou *javadoc*). L'auto-complétion permet la plupart du temps d'avoir accès à la liste des paramètres potentiels. 

## Méthodes

L'utilisation d'une classe donne accès aux méthodes définies pour cette classe :

  - les méthodes d'instance
  - les méthodes de classe

> *Rappels* : Une méthode permet de faire une action, quand elle est **appelée** avec un point suivi du nom de la méthode et de parenthèses : `.nomMethode()`

Les méthodes d'instance s'appliquent à des instances de la classe (*obviously*), ce qui signifie que **toutes** les instances peuvent les utiliser indépendamment les unes des autres.  
Elles sont appelées en plaçant le nom de l'instance concernée avant le point : `MonInstance.nomMethodeInstance();`

Les méthodes de classe s'applique à la classe en soi, ce qui signifie que toutes les instances y accède de la même façon. 
Elles sont appelées en plaçant le nom de la classe concernée avant le point : `MaClasse.nomMethoClasse();`

**Eléments d'instance et de classe :**

Chaque instance a donc accès à : 

  - ses caractéristiques propres, individuelles (*éléments d'instance*)
  - et à des caractéristiques collectives (valables pour l'ensemble des instances) et communes (identiques pour toutes les instances).

## Surcharge {#surcharge}

Mécanisme qui permet d'avoir plusieurs méthodes portant le même nom, qui se différencient par leur nombre et/ leurs types de paramètres.

```{java, eval=FALSE}
// Exemple avec les différents constructeurs de la classe Chat
Chat voyou = new Chat("Voyou") // Un seul parametre : prenom
Chat gandhi = new Chat("Gandhi",4,"Axel") // Trois parametres : prenom, age, maitre
Chat pouloute = new Chat("Pouloute",1.2) // Deux parametres : prenom, poids
```

> Il n'est pas possible de surcharger par type de retour : on surcharge sur les paramètres d'entrée !

```{java, eval=FALSE}
public class TestSurcharge {

    public double getValue(){
        // ...
    }
    // erreur de compilation : getValue() est déjà définie
    public char getValue(){
        // ... 
    }
}
```


## String : classe spécifique

La classe `String` permet de créer un objet `String` qui stocke une chaîne de caractères, sous la forme d'un tableau de charactères.

Un objet `String` est **immmuable** : une fois construit, il n'est plus modifiable. Chaque action effectuée sur une `String` induit donc la création d'une nouvelle instance (soit un nouvel espace alloué en mémoire).

```{java, eval=FALSE}
String s1 = "une première chaîne de caractères";
String s2 = new String("une seconde chaîne de caractères"); // il est possible d'utiliser 
                                                            // le constructeur
String s3 = s1 + s2; // on crée explicite une autre instance

System.out.println("Voici " + s1 + "et même " + s2);  // on crée implicitement une nouvelle 
                                                      // instance
```

Alternative : `StringBuilder`, qui est modifiable