# 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; } } ```