---
# System prepended metadata

title: POO2 - Cours 2018

---

# POO2 - Cours 2018
PRIMAULT Alexandre D1

[TOC]

## Variables et types de retour
Il est possible de stocker les valeurs retournées par des fonctions (aussi appelées méthodes) dans des variables, ou de les utiliser directement.

Exemples :
``` Java
String uneChaine = "Les D c'est les meilleurs";
System.out.println( uneChaine.toLowerCase() ); //retourne les d c'est les meilleurs
```
équivaut à :
``` Java
String uneChaine = "Les D c'est les meilleurs";
String uneChaineMin = uneChaine.toLowerCase();
System.out.println(uneChaineMin);
```

## Structures de contrôle et boucles

### If

###### Avec un type de base (int, char, byte, ...)

``` Java
if (une_variable == une_autre_variable) {
    // Choses à faire...
}
```

###### Avec une chaine de caractère :

``` Java
if (une_chaine.equals((String)une_autre_chaine)) {
    // Choses à faire...
}

// OU

if (une_chaine.equalsIgnoreCase((String)une_autre_chaine)) {
    // Choses à faire
}
```


## Les chaines de caractère
### Concaténation d'une chaine
``` Java
String laChaine = "Une chaine" + " une autre chaine";
```

### Longueur d'une la chaine
``` Java
laChaine.length();
```
::: info
Retourne un ENTIER de la valeur de la longueur de la chaine
:::
### Comparaison de chaines
::: warning
Voir dans la seconde boucle ``if`` si dessus.
:::
::: info
Retourne VRAI ou FAUX
:::
### Valeur d'un index de la chaine
``` Java
laChaine.charAt( (int)numero );
```
::: info
Retourne un CHAR contenant le caractère à la position ``numero``
:::
:::danger
ATTENTION : Le 1er caractère est à l'index 0 !
:::
### Si la chaine contient un mot/groupe de mot
``` Java
laChaine.contains( (String)groupe_de_mot );
```
::: info
Retourne VRAI ou FAUX
:::
### Créer une sous chaine allant de l'index du caractère a vers l'index du caractère b
``` Java
laChaine.substring( (int)a , (int)b );
```
::: info
Retourne un STRING contenant la sous-chaine.
:::
:::warning
Si seul ``a`` est spécifié, l'index de fin de la sous-chaine sera l'index de fin de la chaine.
:::
### Mettre une chaine en MAJUSCULE
``` Java
laChaine.toUpperCase();
```
::: info
Retourne un STRING contenant la chaine avec toutes les lettres de la chaine en majuscule.
:::
### Mettre une chaine en minuscule
``` Java
laChaine.toLowerCase();
```
::: info
Retourne un STRING contenant la chaine avec toutes les lettres de la chaine en minuscule.
:::

### Récupérer la taille de la chaine
``` Java
laChaine.size();
```
::: info
Retourne un ENTIER contenant la taille de la chaine
:::

## Méthodes communes à ``java.util.ArrayList<E>`` et ``java.util.HashSet<E>``
``` Java
List<E> desElements = new ArrayList<>(); 
// Set<E> desElements = new HashSet<>(); 
```

:::warning
Ici ``E`` est un type. On peut très bien mettre ``String`` ou ``Integer`` par exemple.
:::

### Ajouter un élément
``` Java
E element = new E();
desElements.add( (E)element );
```
::: info
Retourne VRAI (si bien inséré) ou FAUX
:::

### Vider la liste
``` Java
desElements.clear();
```
::: info
Retourne VRAI (si bien inséré) ou FAUX
:::

### Cloner la liste
``` Java
desElements.clone();
```
::: info
Retourne la même liste de type E.
:::

### Si la liste contient un objet
``` Java
E element = new E();
desElements.contains( (E)element );
```
::: info
Retourne VRAI ou FAUX
:::

### Si la liste est vide
``` Java
desElements.isEmpty();
```
::: info
Retourne VRAI ou FAUX
:::

### Retirer un élement de la liste
``` Java
E element = new E();
desElements.remove( (E)element );
```
::: info
Retourne VRAI ou FAUX
:::

### Taille de la liste
``` Java
desElements.size();
```
::: info
Retourne un ENTIER contenant la taille de la liste
:::


## Méthodes utiles pour ``java.util.ArrayList<E>``
```Java
List<E> unTableauDyn = new ArrayList<>();
```

### Ajouter un élément à une position w
``` Java
E element = new E();
unTableauDyn.add( (E)element , (int)w );
```
::: info
Retourne VRAI (si bien inséré) ou FAUX
:::

### Supprimer un élément à une position w
``` Java
unTableauDyn.remove( (int)w );
```
::: info
Retourne VRAI (si bien inséré) ou FAUX
:::

### Récupérer un élément contenu à une position w
```Java
unTableauDyn.get( (int)w );
```
::: info
Retourne le contenu de type E du tableau à l'index w.
:::

### Remplacer un élément par un autre à un index w
```Java
E element = new E();
unTableauDyn.set( (int)w , (E)element );
```
::: info
Retourne l'élément inséré.
:::

### Transformation en tableau statique
```Java
unTableauDyn.toArray();
```
::: info
Retourne un tableau statique ( ici de type E[ ] ).
:::

## Méthodes utiles pour ``java.util.HashMap<K,V>``
### Insérer des éléments

:::info
``K`` est le type de la clé.
``V`` est le type de la valeur.
:::
``` Java
uneHashMap.put( (K)uneCle , (V)uneValeur );
```  

## Parcours de listes
### ``java.util.ArrayList<E>`` ou ``java.util.HashSet<E>``
``` Java
List<E> desElements = new ArrayList<>(); 
// Set<E> desElements = new HashSet<>(); 
    
for(E element : desElements) {
    // Des choses... Exemple :
    System.out.println(element);
}
``` 

### ``java.util.HashMap<K,V>``
``` Java
HashMap<int,String> uneListeAvecDesChaines = new HashMap<>();

for(Map.Entry e : uneListeAvecDesChaines.entrySet() ) {
    // Des choses... Exemple :
    System.out.println( e.getKey() + " est la clé de " + e.getValue() );
}
```

## Conversions d'éléments
### int -> String

```Java
Integer.toString( (int)unEntier );
```

### double -> String
```Java
Double.toString( (double)unDouble );
```

### String -> char[ ]
```Java
uneChaine.toCharArray();
```

## Enumération
:::success
* Possibilité de créer un constructeur
:::

Exemple d'enum :
``` Java
public enum Telephone {
    // En 1er, les composantes de l'enum
    FIXE("Fixe"), 
    PORTABLE_ANDROID("Portable android"), 
    PORTABLE_IOS("Portable iOS");
    
    // Les variables si besoin (du type de ce qu'il y a dans les parenthèses)
    private String nom;
    
    // Le constructeur si il y a des variables
    public Telephone(String nom) {
        this.nom = nom;
    }
    
    // D'autres fonction si besoin
    public String getNom() {
        return this.nom;
    }
    
}
```

## Interface
::: danger
* Ne contient que la déclaration des méthodes
* Ne contient pas d'attributs
* Toutes les méthodes sont publiques par défaut
:::

:::success
Utilisation dans les classes avec ``implements``
:::

Exemple d'interface :
``` Java
public interface Predateur {
    void chasserProie(Proie p);
    void mangerProie(Proie p);
}
```

## Classes

:::info
* ``extends`` pour un héritage entre classe (une seule classe à la fois)
* ``ìmplements`` pour hériter des interfaces (possibilité d'en avoir plusieurs)
:::

``` Java
public class Grenouille [extends ...] [implements ...] {
    // Attributs privés
    private String nom;
    
    // Constructeur
    public Grenouille(...) {
        // Des choses...
    }
    
    // Méthodes 
    public String getNom {
        return this.nom;
    }
}
```




