Badr Benmammar

bbm@badr-benmammar.com

Programmation objet avec JAVA

Partie 2

Plan

Héritage

Classes abstraites

Interfaces

Modificateur final

Exception

Héritage de classe

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); }}

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); }}

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());

}}

Résultat:surface de c : 10000.0perimetre de c : 400.0diagonale de c : 141.4213562373095

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.

class Personne {protected String nom;protected int age;Personne (String nom, int

age) {this.nom=nom;this.age=age;}void setNom (String nom) {this.nom=nom;}void setAge (int age) {this.age=age;}String getNom ( ) {return nom;}int getAge ( ) {return age;}public String toString( ) {return nom + " (" + age + ")";

}}

Exemple : sous-classe avec nouvel attribut

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) {this.formation=formation;}public String toString() {if (formation)return super.toString() + " a une

formation";elsereturn 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);System.out.println(s);}}

Résultat:bb (32) n'a pas de formationbb 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

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); }}

Classes abstraites

Cette classe est abstraite car ses méthodes surface et perimetre sont abstraites, c.a.d. non définies.

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 "); cerc.afficherPosition ( ); }}

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

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.

Classes abstraites

Interfaces 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); } }

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.

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); } }

Interfaces

FormeGeometrique1

Rectangle8

Rectangle7Dessinable1

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é

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 + ")";

}

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);}}

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.javajava Equation1 2 4

2 * X = 4ré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 20 * X = 2Exception 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; }}

EXECUTION:java Equation2 0 20 * X = 2résultat : X = -1

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.