Badr Benmammar bbm@badr-benmammar.com Formation Développeur Java Programmation objet avec JAVA Partie 2 Badr Benmammar bbm@badr-benmammar.com

Plan Héritage Classes abstraites Interfaces Modificateur final Exception

Héritage de classe public class Carre4 extends Rectangle4 { Carre4(double valX, double valY, double valCote) { x = valX; y = valY; largeur = valCote; hauteur = valCote; } double surface() { return Math.pow(largeur, 2); double diagonale() { return largeur * Math.sqrt(2); public class Rectangle4 { double x, y, largeur, hauteur; Rectangle4 ( ) { x = 0; y = 0; largeur = 0; hauteur = 0; } Rectangle4 (double valX, double valY, double valL, double valH) { x = valX; y = valY; largeur = valL; hauteur = valH; double surface() { return largeur * hauteur; double perimetre() { return 2*(largeur + hauteur); La classe Carre4 (fille ou sous-classe) hérite les attributs et les méthodes de la classe Rectangle4 (mère ou superclasse). La méthode surface est re-définie dans Carre4 et donc masque la définition de surface de Rectangle4.

Héritage de classe public class Prog35 { public static void main (String args[]) { Carre4 c; c = new Carre4(40,40,100); System.out.println("surface de c : "+c.surface()); System.out.println("perimetre de c : "+c.perimetre()); System.out.println("diagonale de c : "+c.diagonale()); } A l'appel de la méthode surface, celle-ci est d'abord recherchée dans la classe Carre4 où se trouve une (re)définition. A l'appel de la méthode perimetre, celle-ci est d'abord recherchée dans la classe Carre4 : pas de définition; puis elle est recherchée dans sa superclasse où se trouve une définition. Résultat: surface de c : 10000.0 perimetre de c : 400.0 diagonale de c : 141.4213562373095

Exemple : sous-classe avec nouvel attribut class Personne { protected String nom; protected int age; Personne (String nom, int age) { this.nom=nom; this.age=age;} void setNom (String nom) { } void setAge (int age) { this.age=age; String getNom ( ) { return nom; int getAge ( ) { return age; public String toString( ) return nom + " (" + age + ")"; class Formateur extends Personne { private boolean formation; Formateur (String nom, int age,boolean formation) { super (nom,age); this.formation=formation; } boolean getFormation() return formation; void setFormation(boolean formation) public String toString() { if (formation) return super.toString() + " a une formation"; else return super.toString() + " n'a pas de formation";

Exemple : sous-classe avec nouvel attribut class TestPers{ public static void main(String arg[]) { Formateur s=new Formateur("bb",32, false); System.out.println(s); s.setNom(s.getNom( ) + " ben"); s.setAge(s.getAge( ) + 2); s.setFormation(true); } Résultat: bb (32) n'a pas de formation bb ben (34) a une formation

Héritage de classe Une classe hérite d'une autre classe par le biais du mot clé extends. Une classe ne peut hériter que d'une seule et unique classe (en JAVA, pas d’héritage multiple). La classe fille hérite de toutes les propriétés et méthodes public et protected de la classe mère. Les méthodes et propriétés private d'une classe mère ne sont pas accessibles dans la classe fille. On peut redéfinir ou changer tout le code d'une méthode héritée (polymorhisme). Une méthode déclarée final est non redéfinissable. Vous ne pouvez pas hériter d'une classe déclarée final.

Classes abstraites Une classe abstraite est une classe qui n'est pas instanciable, elle n'aura pas d'objet. Une classe abstraite permets de définir les caractéristiques communes de plusieurs classes d'objets. FORMES GÉOMÉTRIQUES RECTANGLE CARRÉ CERCLE

Classes abstraites abstract public class FormeGeometrique1 { double posX, posY; void deplacer (double x, double y) { posX=x; posY=y; } void afficherPosition ( ) { System.out.println("position : (" +posX+","+posY+")"); abstract double surface ( ) ; abstract double perimetre ( ) ; public class Rectangle7 extends FormeGeometrique1 { double largeur, hauteur; public Rectangle7( ) { posX=0; posY=0; largeur=0; hauteur=0; } public Rectangle7 (double x, double y, double la, double lo) { posX=x; posY=y; largeur=la; hauteur=lo; double surface() { return largeur * hauteur; double perimetre() { return 2*(largeur + hauteur); public class Cercle7 extends FormeGeometrique1 { double rayon; Cercle7 (double x, double y, double r) { posX=x; posY=y; rayon=r; } double surface ( ) { return Math.PI*Math.pow(rayon, 2.); double perimetre ( ) { return 2*rayon*Math.PI; public class Prog50 { public static void main (String args[]) { Rectangle7 rect; Cercle7 cerc; rect = new Rectangle7 (9,3,10,20); cerc = new Cercle7 (43,32,100); System.out.print ("cercle "); cerc.afficherPosition ( ); System.out.print ("rectangle "); rect.afficherPosition ( ); cerc.deplacer (66,88); System.out.print ("cercle maintenant "); } Résultat: cercle position : (43.0,32.0) rectangle position : (9.0,3.0) cercle maintenant position : (66.0,88.0) cercle surface : 31415.926535897932 Cette classe est abstraite car ses méthodes surface et perimetre sont abstraites, c.a.d. non définies.

Classes abstraites Une classe abstraite est déclarée avec le modificateur abstract. Une classe est abstraite si elle contient au moins une méthode abstraite ; elle ne peut pas être instanciée, mais ses sous-classes non abstraites le peuvent. Une méthode abstraite ne contient pas de corps, mais doit être implémentée dans les sous-classes non abstraites. Une classe abstraite peut contenir des méthodes non abstraites et des déclarations de variables ordinaires. Une classe abstraite peut être dérivée en une sous-classe : abstraite si une ou plusieurs méthodes ne sont pas implémentées par la classe fille. non abstraite si toutes les méthodes abstraites sont implémentées dans la classe fille.

Interfaces import java.awt.Graphics; public interface Dessinable1 { Dans une interface, toutes les méthodes sont abstraites (c.a.d. non définie), elle ne peut avoir que des variables static final (des constantes). Une interface n'est pas instanciable, et n'est pas une classe. import java.awt.Graphics; public interface Dessinable1 { public void dessiner(Graphics g); } public class Rectangle8 extends Rectangle7 implements Dessinable1 { public Rectangle8 (double x, double y, double la, double lo) { super (x,y,la,lo); } public void dessiner (Graphics g) { g.drawRect ((int)posX, (int)posY, (int)largeur, (int)hauteur); import java.awt.Graphics; public class Texte8 implements Dessinable1 { String texte; int posX, posY; public Texte8 (String t, int x, int y) { texte=t; posX=x; posY=y; } public void dessiner (Graphics g) { g.drawString(texte,(int)posX,(int)posY); } La classe Rectangle8 hérite de la classe Rectangle7 et implémente l'interface Dessinable1. Elle définie toutes les méthodes de l'interface.

Interfaces Dessinable1 FormeGeometrique1 Rectangle8 Rectangle7 Dessinable1 Texte8 Rectangle8 hérite de la superclasse Rectangle7. En Java, l'héritage est simple, une classe n'hérite que d'une superclasse, l'interface permet de contourner cette limite : Rectangle8 hérite de Rectangle7 et implémente Dessinable1. La technique de l'implémentation d'interface permet de réaliser un héritage multiple sans ses inconvénients. Une classe peut implémenter plusieurs interfaces, et une interface peut hériter d'une autre interface.

Interfaces Une interface ne comporte que des constantes et des méthodes abstraites. Elle n'est pas "classe abstraite". Elle peut implémenter une ou plusieurs interfaces, c'est à dire définir le corps de toutes les méthodes abstraites. C'est l'héritage multiple de Java. Les constantes sont explicitement ou implicitement static et final.

Interfaces Les méthodes sont explicitement ou implicitement abstraites. Une classe qui implémente une interface doit définir le corps de toutes ses méthodes abstraites. Les sous-classes d'une super-classe qui implémente une interface, héritent (et peuvent redéfinir) des méthodes implémentées. Une interface peut hériter (par extends) d'une autre interface et en implémenter (par implements) d'autres.

Exemple d’interfaces en Java public interface Comparable L'interface Comparable modélise les objets qui possèdent un ordre total. La seule méthode est compareTo (autre) qui renvoie un entier positif si l'objet est supérieur à l'autre, 0 s'ils sont égaux, et négatif sinon. Cette interface permet d'utiliser des collections d'objets ordonnés comme TreeSet. Collections en Java

Collections en Java Une collection représente un groupe d’objets, connu par ses éléments. Certaines collections acceptent les doublons, d'autres pas. Certaines sont ordonnées, d'autres pas. Certaines collections émettent quelques restrictions, comme le type ou l'interdiction de la valeur null. Exemple de collection : ArrayList (pour les listes) : Sous forme de tableau qui se redimensionne automatiquement. TreeSet (pour les ensembles) : Contient un ensemble d'éléments ordonnés.

Tableau non trié public static void main(String arg[]) { ArrayList<Personne1> liste; liste=new ArrayList<Personne1>(); Personne1 p1=new Personne1("Tom",21); Personne1 p2=new Personne1("Pierre",45); Personne1 p3=new Personne1("Toto",18); Personne1 p4=new Personne1("Arthur",26); liste.add(p1); liste.add(p2); liste.add(p3); liste.add(p4); System.out.println(liste); }} import java.util.*; class Personne1 { protected String nom; protected int age; Personne1 (String nom, int age) this.nom=nom; this.age=age; } public String toString() { return nom + " (" + age + ")"; Résultat: [Tom (21), Pierre (45), Toto (18), Arthur (26)]

Tableau trié import java.util.*; class Personne1 implements Comparable { protected String nom; protected int age; Personne1 (String nom, int age) { this.nom=nom; this.age=age; } public String toString() { return nom + " (" + age + ")"; public int compareTo (Object o) { Personne1 p=(Personne1)o; return nom.compareTo(p.nom); public static void main(String arg[]) { TreeSet<Personne1> liste; liste=new TreeSet<Personne1>(); Personne1 p1=new Personne1("Tom",21); Personne1 p2=new Personne1("Pierre",45); Personne1 p3=new Personne1("Toto",18); Personne1 p4=new Personne1("Arthur",26); liste.add(p1); liste.add(p2); liste.add(p3); liste.add(p4); System.out.println(liste); }} Résultat: [Arthur (26), Pierre (45), Tom (21), Toto (18)]

Modificateur final final devant une variable, empêche de changer sa valeur donc la rend constante. Une méthode est déclarée final afin de mettre un verrou sur la méthode pour empêcher toute sous-classe de la redéfinir. Ceci est fait pour des raisons de conception quand on veut être sûr que le comportement d’une méthode est préservé durant l’héritage et ne peut pas être redéfini. Exemple : final boolean checkPassword(). Quand on dit qu’une classe entière est final on stipule qu’on ne veut pas hériter de cette classe ou permettre à qui que ce soit de le faire. En d’autres mots, soit la conception de cette classe est telle qu’on n’aura jamais besoin de la modifier, soit pour des raisons de sécurité on ne veut pas qu’elle soit sous-classée.

Classe Number public abstract class Number extends Object implements Serializable C’est la classe mère de plusieurs classes: BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short, Character, Boolean. Les types primitifs peuvent être "enveloppées" dans un objet provenant d'une classe prévue à cet effet et appelée Wrapper (mot anglais signifiant enveloppeur). Les enveloppeurs sont donc des objets pouvant contenir une primitive et auxquels sont associés des méthodes permettant de les manipuler.

Enveloppeurs (Wrappers) Enveloppeur Primitive associée Character char Byte byte Boolean boolean Short short Float float Integer int Long long Double double BigDecimal aucune primitive associée, car cette classe peut contenir des valeurs décimales de précision quelconque BigInteger aucune primitive associée, car cette classe peut contenir des valeurs entières de précision quelconque

Utilisation : conversion entre classe public class Equation1 { private int a, b; public Equation1(int a, int b) { this.a=a; this.b=b; } public void afficher() { System.out.println(a+" * X = "+b); int solution() { return b/a; public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation1 equa = new Equation1(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); Passer des paramètres sur la ligne de commande javac Equation1.java java Equation1 2 4 2 * X = 4 résultat : X = 2

Utilisation : conversion entre classe int valeurA=Integer.valueOf(args[0]).intValue(); Integer est une classe pour manipuler les entiers comme des objets et non pas uniquement comme une valeur int. Integer.valueOf (chaineDeChiffres) renvoie un objet Integer ayant la valeur correspondante à la chaine de chiffres. La méthode intValue( ) de la classe Integer renvoie la valeur int.

Exception public class Equation1 { private int a, b; public Equation1(int a, int b) { this.a=a; this.b=b; } public void afficher() { System.out.println(a+" * X = "+b); int solution() { return b/a; public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation1 equa = new Equation1(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); java Equation1 0 2 0 * X = 2 Exception in thread "main" java.lang.ArithmeticException: / by zero at Equation1.solution(Equation1.java:20) at Equation1.main(Equation1.java:10)

Exception L'instruction division entière peut lever une exception: ArithmeticException (erreur d'exécution) . Une exception (générée) levée (non propagée et non capturée) finit par provoquer l'arrêt de la "méthode du programme principal". Une exception est un message envoyé lors d'une erreur à l'exécution. Ce message contient des informations sur l'erreur qui s'est produite. Java stoppe l'exécution du code là où l'exception a été levée et envoie le "message" exception. Sans capture du message exception, celui provoque l'arrêt successif des méthodes appelées jusqu'à la machine JVM qui vous indique l'erreur produite avec beaucoup de détails issus des informations du message. Les exceptions sont organisées en classe, Java contient une classe nommée Exception, où sont répertoriés différents cas d'erreurs.

Capturer une exception public class Equation2 { private int a, b; public static void main(String args[]) { int valeurA= Integer.valueOf(args[0]).intValue(); int valeurB= Integer.valueOf(args[1]).intValue(); Equation2 equa = new Equation2(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); } public Equation2(int a, int b) { this.a=a; this.b=b; public void afficher() { System.out.println(a+" * X = "+b); } int solution( ) { int x; try { x = b/a; } catch (ArithmeticException e) { x = -1; return x; L'instruction "try ... catch" permet de capturer des exceptions : dès qu'une exception est levée dans le corps de try, le traitement de ce corps est terminé. catch définit le traitement pour les ArithmeticException capturées. L'exécution continue normalement en reprenant après le bloc try-catch. Ce mécanisme permet de traiter les erreurs et d'empêcher qu'elle n'arrête l'application en cours. L'exception a été capturée et traitée : x = -1. EXECUTION: java Equation2 0 2 0 * X = 2 résultat : X = -1