Programmation Orientée Objet - JAVA

1. Programmation Orientée Objet - JAVA Marcelo Zanconi Sup2i

2. Révision Objets/Classes • Objet: Une entité décrite par • quelques propriétés, appelées attributs, • un comportement , donné par un ensemble de méthodes et • un état, donné par un ensemble de valeurs

3. Classe • Une classe est une structure avec des attributs et des méthodes • Une classe est aussi un ensemble d'objets qui partage les mêmes caractéristiques et le même comportement. • Une classe définit aussi un nouveau type de donnée et chaque élément ainsi déclaré est une instance de la classe.

4. Classes en Java • Fichier .java • Généralement une classe par fichier • Chaque fichier contient UNE classe publique (publicclass) • Le mot clé class pour créer une classe publicclass Car { }

5. Classes Formalités Le nom d'une classe commence par une lettre majuscule. Nous pouvons mettre de majuscules et minuscules a volonté.

6. Classes Modificateurs • public: idem variables et méthodes • abstract: la classe ne peut pas être instanciée, elle sera utilisée comme classe de base dans un héritage. Squelette d'une superclasse. • final: classe qui n'est pas 'héritable'. • Notre classe Car est publique avec ses méthodes et pourra participer dans une relation de héritage.

7. Création de Classes • Opérateur new pour créer une instance (nouvel objet). • L'opérateur retourne un objet avec • L'ensemble de attributs et méthodes définis dans la classe. Les valeurs par défaut dépendent du constructeur (a voir…) Classe objet création constructeur Car yourCar =newCar("orange"); new Car() Car mycar =

8. Un constructeur? • Méthode spéciale définie dans la classe • Crée une nouvel instance d'un objet • Appelé automatiquement avec l'opérateur new • Porte le même nom que la classe ou il est défini • En absence de constructeur, le compilateur fournit en un. public class Car { // … publicCar(){ // Corp du constructeur } }

9. Surcharge du Constructeur • Plusieurs constructeurs sont possibles public class Car { String color ; public Car(){ //Constructeur sans paramètres } public Car( String c ){ color = c; } }

10. Attributs d'une classe • Aussi appelés variables • Définit l'état d'un objet • Leurs valeurs sont particulières à une instance • Déclaration: • Notation DOT pour acceder aux attributs: nomInstance.nomAttribut publicclass Car { String color; String name; float weight; } myBeautifulCat.name;

11. Attributs Formalités Les variables commencent par une lettre minuscule. On peut ajouter de majuscules pour plus de claireté.

12. Attributs Modificateurs • private • protected • public • protected est le modificateur par défaut. (Attn: en C++ est private). • Normalement les variables son private ou protected et seront visibles par l'action des méthodes. (Concept d'encapsulation).

13. Attributs statiques de classe • Attributs partagés par toutes les instances d'une classe. • Toutes les instances ont les mêmes valeurs pour ces attributs. Assimilables à une variable globale... • Déclarés en utilisant le mot clé static • Accessibles par la classe et par les instances de la classes. public class Car { String color; String name; float weight; static intmotornumber; } Car.numberOfMoteurs;

14. Méthodes d'instance • Bloc de code pour définir le comportement d'une instance et manipuler ses attributs. • Déclarée dans les classes et référençables par les instances, (selon les modificateurs...) • Possibilité de surcharge • Utilisation: public class MyClass { // … public void myMethod() { // my actions } } myInstance.myMethod();

15. Méthodes Modificateurs • private: • protected • public: • static: méthode de classe • final: la méthode ne peut pas être substituée dans une sous-classe (pas d'héritage) • abstract: méthode d'une classe abstraite, définie les signatures des méthodes • native: méthode externe écrite dans une autre langage • synchronized: un seul thread a la fois.

16. Méthodes de Classe • Bloc de code pour définir un comportement général. • Déclarée en utilisant le mot clé static • Possibilité de surcharge • Elle ne peut pas utiliser des attributs d'instance et ne peut pas appeler des méthodes d'instance • Utilisation: public classMyClass { public static void myMethod() { //mes actions } } MyClass.myMethod();

17. Méthodes de classes • Les méthodes statiques n'accèdent qu'aux variables locales ou aux autres membres statiques de la classe. • Les fonctions mathématiques sont un exemple de méthodes statiques. public class Car { String color; String name; float weight; static intmotorNumber; public static int assignMotor() { return motorNumber++;} }

18. Méthodes Formalités Elles commencent par une lettre minuscule. On peut ajouter de majuscules a volonté

19. Résumé Variable de classe partagée par toutes les instances d'une classe. Utiliser mot clé static Synonyme Variable de classe Comment les utiliser… myInstance.myVariable Variables d'instance ou Attributs Méthodes de classe o statiques MyClass.myMethod()

20. Notation "." • Accès aux: • Attributs • Méthodes • Retourne la valeur d'un attribut • Appeler une méthode myInstance.nameOfAttribute; myInstance.nameOfMethod();

21. Le pointeur "this" • Pointeur explicit a l'instance actuelle (celle qui a appelé la méthode…). • Utilisé pour référencer l'instance actuelle • Pour référencer les attributs/méthodes de l'instance actuelle. • Appelle le constructeur de l'instance • Doit être la première instruction myMethod(this); this.myVariable; this("Tomi","White");

22. Le pointeur "this" • Exemple: public class MyClass { inttest = 6; public MyClass() { inttest = 4; System.out.println("Test = " + this.test); System.out.println("Test = " + test); } public static void main(String args[]) { new MyClass(); } }

23. Aggregation • Association d'un objet vers un autre … • Un attribut d'une classe B est d'une classe A (Rappel: une classe est un type de donnée). • Exemple: ajouter a la classe CatLike un Maître, qui a un nom, prénom… 1,n 0,1 CatLike Addresse 0,1 1,n String name String color float weight Maitre moi String street String city String zipCode String country Maitre String prenom String nom int age Address myAddresse

24. Encapsulation • Un objet est une boite noire ou seulement quelques propriétés et comportement sont exportés. • Un objet ne peut pas être modifié que par les méthodes d'instances déclarées public • Les attributs sont déclarés private ou protected Mon objet Mon programme Methodes publiques Attributs privés

25. Encapsulation • "Enfermer" l'organisation interne d'une classe et protéger son accès de l'extérieur. • Les attributs ne sont modifiables qu'a partir des méthodes publiques (d'instance) de la classe.

26. Getter/Setter (Les Accesseurs) • Les valeurs des attributs d'une classe sont obtenues par "les getters" • Normalement: getXXX(); (XXX nom d'attribut) • Les valeurs des attributs d'une classe sont attribuées par "les setters" • Normalement: setXXX(ValueType newValue);

27. Les Accesseurs public class Car { String color; // par default protected String name; float weight; static int motorNumber; public Car () {... } public String getColor() {return color;} }

28. Les accesseurs • Syntaxe • Soit myNumber un attribut private/protected définit comme int • Soit checked un attribut private/protected définit comme booléen public int getMyNumber() { ... } public void setMyNumber(intmyNumber) { ... } public boolean isChecked() { ... } public void setChecked(booleanchecked) {...}

29. Utilisation d'une classe • Définition d'une classe • Déclaration d'une variable: Car mavoiture; // mavoiture = null • Création de l'objet: instance de la classe. mavoiture = new Car () • Opération combiné: Car mavoiture = new Car () ; • Initialisation d'une instance par appel au constructeur • L'opérateur new fait une demande pour obtenir la mémoire nécessaire au stockage de l'instance.

30. Initialisation d'une instance • Définir un (ou plusieurs) constructeur pour les instances. • Ce constructeur travaille sur les attributs d'instance mais pas sur les attributs de classe (statiques). • Pour les attributs de classe: methode static.

31. Initialisation de variables de Classe public class Car { ... static int motorNumber; ... static { motorNumber = 0;} ... } • Chargé par la JVM au moment de l'exécution

32. La Classe String • String Prenom1 = new String ("Pierre"); • String Prenom2 = "Pierre" ; • Comparateurs: • Ne pas utiliser: >, <, <=, ==, ... • equals : Prenom1.equals(Prenom2); • compareTo: Prenom1.compareTo(Prenom2) • 0 si Prenom1 est égal a Prenom2 • Négatif si Prenom1 < Prenom2 • Positif si Prenom1 > Prenom2 • (-> 0, -1, 1)

33. La Classe String • Concaténation: • Prenom1.concat(Prenom2); • Prenom1 + Prenom2 ; • Extraction: • String Prenom3 = Prenom1.substring(0,2) -> Pi (la chaine de 2 caractères a partir de 0) • String Prenom3 = Prenom1.substring(3) ->rre (la chaine a partir de la position 3) • Longueur: • Prenom3.length();

34. La Classe String • toLowerCase, toUpperCase • trim: éliminer les espaces • replace(oldChar,newChar) • Prenom3 = Prenom1.replace('r', 'l') -> Pielle • valueof(int i) • int i = 54 ; • Prenom3 = Prenom3.valueOf(i) -> "54" • int j = Integer.parseInt(Prenom3); -> 54

35. La Classe StringBuffer • Plus de flexibilité • append, capacity, charAt, delete, insert, length, replace, reverse, setCharAt, setLength, substring • StringBuffer S1=new StringBuffer(), • S2= new StringBuffer(); • S1.append("Cours"); -> "Cours" • S1.append(123); -> "Cours123" • System.out.println(S1); -> "Cours123"

36. La Classe StringBuffer • S1.insert(3,"XXX"); -> "CouXXXrs123" • System.out.println(S1.length()); -> 11 • System.out.println(S1.capacity()); -> 16 (?) • et 30 autres méthodes...

37. La Classe StringTokenizer • Pour travailler avec une chaîne et la séparer en morceaux (tokens). • import java.util.StringTokenizer; String s = "Java est un langage moderne"; StringTokenizer st = new StringTokenizer(s); System.out.println("Nombre de mots:" + st.countTokens()); (-> 5) while (st.hasMoreTokens()) { System.out.println(st.nextToken());} -> Java est un ...

38. La Classe StringTokenizer • Creation: • StringTokenizer (string s) ; • StringTokenizer (string s, String delim); • StringTokenizer st = StringTokenizer( "Le-Prof-explique-tres-bien","-"); • System.out.println(st.countTokens()) -> 5 • StringTokenizer St2 = new StringTokenizer( "Le-Prof-et tres-modeste!","- "); • System.out.println(St2.countTokens()); -> 5

39. La Classe StringTokenizer • StringTokenizer (string s, String delim, boolean token) • StringTokenizer St2 = new StringTokenizer ( "Le-Prof-explique tres-bien!","- ", true); System.out.println(St2.countTokens()); -> 9

40. L'héritage • Une classe peut être héritière d'une classe 'a la UML'. • Elle hérite, en principe, les attributs et les méthodes de la classe mère déclarés comme default, public ou protected • Peut redéfinir le comportement de quelques méthodes de la classe mère et ajouter de nouveaux attributs. • Déclaré par le mot clé extends • Une classe peut avoir au maximum UNE CLASSE MERE, pas d'héritage multiple comme dans la conception UML.

41. Illustration CatLike String name String color float weight Maitre moi Tiger extendsCatLike Cat extendsCatLike Héritage implicite de tous les attributs et méthodes Héritage implicite de tous les attributs et méthodes • Une sous classe est une relation is-a

42. Mot clé super • Appel les méthodes de la classe mère public class Cat extends CatLike { // … public Cat(String name, String color, int weight, Maitre moi) { // Appel le constructeur de la superclasse // Toujours la premiere instruction … super(name,color,weight,owner); } public void eat() { // We call the super class method super.shout(); System.out.println(name + " eats"); } }

43. Constructeur et Héritage • La classe de base et la classe dérivée ont au moins un constructeur public: • le constructeur de la classe dérivée doit appeler le constructeur de la classe de base disponible. • La classe de base n’a aucun constructeur. La classe dérivée peut ne pas appeler explicitement le constructeur de la classe de base. • La classe dérivée ne possède aucun constructeur. Dans ce cas, la classe de base doit avoir un constructeur public sans argument (par défaut ou un explicite).

44. Constructeur et Héritage publicclass Shape { int x=9, y=6 ; publicint getX() {return x;} publicstaticvoid main (String[] args) { Shape s ; Circle c1 = new Circle(); } } publicclass Circle extends Shape{ float radius; public Circle() {radius = 2; System.out.println(getX()); } } 9 La création de c1 crée les variables de Shape

45. Constructeur et Héritage public class Circle extends Shape { float radius; public Circle() { radius = 0;} public Circle (int x, int y, float r ) { super(x,y); radius = r;} } public class Shape { int x, y ; public Shape() { x = 0 ; y = 0;} public Shape (int X, int Y ) { x = X; y = Y;} } public static void main (…) { shape s; circle c1; circle c2(2, 3, 3.5); c1.getX()? c2.getX? } 0 2

46. Constructeur et Heritage publicclass Circle extends Shape { float radius; } publicclass Shape { int x=9, y=6 ; publicint getX() {return x;} publicstaticvoid main (…) { Shape s ; Circle c1 = new Circle(); System.out.println(c1.getX()); } } 9 La creation de Circle cree un instance de Shape

47. Constructeur et Heritage • Une classe fille doit appeler le constructeur de sa classe mère: • S'il y a un constructeur mère par défaut, l'appel se fait automatiquement. (super()). • S'il n'y a pas, il faut appeler explicitement un constructeur. • Conclusion: la classe fille appelle toujours un constructeur de la classe mère… il faut en fournir un!!!

48. Mot clé final • Empêche l'héritage • Une classe ne peut pas hériter d'une classe marquée comme final • Empêche la surcharge: • Une méthode marquée comme final ne peut pas être surcharger, i.e. une sousclasse ne peut pas le redéfinir. • Empêche l'attribution d'un attribut • Un attribut marqué comme final ne peut pas changer de valeur… une fois initialisé il garde sa valeur durant toute l'exécution • Utiliser pour les constantes

49. Polymorphisme • Permet d'utiliser une instance avec la classe mère. • Exemple • Créer un tableau de Tigers et ajouter un CatLike

50. Polymorphisme • Permet la déclaration d'une variable de type 'mère' et l'instancier avec un type de la sousclasse. public static void main (String args[]) { CatLike myCat = new Cat("Fifou","Blue",70,me,"Tigrou"); CatLike myCatLike = new CatLike("Doudou","Green",6); CatLike [] tabCatLike = new CatLike [4]; tabCatLike[0] = myCat; tabCatLike[1] = myCatLike; System.out.println("The first cat of my table is: " + tabCatLike[0].getName()); }