Penser en Java

Penser en Java guide de formation complet avec exemples

...

Historique Les principaux évènements de la vie de Java sont les suivants :

• 1995 mai: premier lancement commercial
• 1996 janvier : JDK 1.0.1
• 1996 septembre: lancement du JDC
• 1997 février : JDK 1.1
• 1998 décembre: lancement de J2SE 1.2 et du JCP
• 1999 décembre: lancement J2EE
• 2000 mai: J2SE 1.3
• 2002 février: J2SE 1. 4
• 2004 septembre: J2SE 5.0
• 2006

o mai: Java EE 5

o décembre: Java SE 6.0 Applic tion Vs Applet Il existe 2 types de programmes avec la version standard de Java :

o Les applets

o Les applications.

• Une application

o autonome (stand alone program) est une application qui s'exécute sous le contrôle direct du système d'exploitation.

• Une applet

o une application qui est chargée par un navigateur et qui est exécutée sous le contrôle d'un plug in de ce dernier.

Principales différences entre une applet et une application

o Les applets n'ont pas de méthode main()

• la méthode main() est appelée par la machine virtuelle pour exécuter une application.

o Les applets ne peuvent pas être testées avec l'interpréteur mais doivent être intégrées à une page HTML, elle même visualisée avec un navigateur disposant d'un plug in sachant gérer les applets Java, ou testées avec l'applet viewer.

La syntaxe et les éléments de bases de Java Les règles de base

• Java est sensible à la casse.
• Les blocs de code sont encadrés par des accolades { }
• Chaque instruction se termine par un ';'
• Une instruction peut tenir sur plusieurs lignes :

Exemple:

char code = 'D';

Les identificateurs

• Chaque objet, classe, programme ou variable est associé à un nom (Identificateur)
• Il peut se composer de tous les caractères alphanumériques et des caractères _ et $.
• Le premier caractère doit être une lettre, _ ou $. Rappel : Java est sensible à la casse.
• Un identificateur ne peut pas appartenir à la liste des mots réservé du langage Java
• Pas d'espaces

Les commentaires

• Ils ne sont pas pris en compte par le compilateur donc ils ne sont pas inclus dans le pseudo code. a. Ils ne se terminent pas par un ;.
• Il existe trois types de commentaire en Java:

1. Commentaire abrégé //commentaire sur une seule ligne

o Exemple: int N=1; // déclaration du compteur

1. Commentaire multiligne

o Exemple :

/* commentaires ligne 1 commentaires ligne 2 */

1. Commentaire de documentation automatique

o Exemple

/**

* commentaire de la methode

* @param val la valeur a traiter

* @since 1.0

* @return Rien

* @deprecated Utiliser la nouvelle méthode XXX *~

Déclaration de variables

• Une variable possède

o un nom,

o un type

o et une valeur.

• La déclaration d'une variable doit donc contenir

o un nom

o et le type de données qu'elle peut contenir.

• Une variable est utilisable dans le bloc ou elle est définie.
• La déclaration d'une variable permet de réserver la mémoire pour en stocker la valeur.
• Le type d'une variable peut être :

o soit un type élémentaire dit aussi type primitif déclaré sous la forme type~élémentaire variable;

o soit une classe déclarée sous la forme classe variable;

 Exemple:

o long nombre;

o int compteur;

o String chaine;

• Il est possible de définir plusieurs variables de même type en séparant chacune d'elles par une virgule. Exemple:
• int jour, mois, annee ;
• Il est possible en une seule instruction de faire la déclaration et l'affectation d'une valeur à une variable ou plusieurs variables.

o Exemple: int i=3 , j= 4 ;

...

n Remarque

Les types élémentaires commencent tous par une minuscule. Initialisation des variables

Exemple:

int nombre; // déclaration nombre = 100; //initialisation

OU

int nombre = 100; //déclaration et initialisation

• En Java, toute variable appartenant à un objet (définie comme étant un attribut de l'objet) est initialisée avec une valeur par défaut en accord avec son type au moment de la création.
• Cette initialisation ne s'applique pas aux variables locales des méthodes de la classe.
• Les valeurs par défaut lors de l'initialisation automatique des variables d'instances sont :

L'affectation

si✻ne d❀ectation

• Le = est lopteur et s'utilise avec une

expression de la forme

variable = expression

• L'opration d'affectation est associative de droite à gauche :

o il renvoie la valeur affectée ce qui permet d'écrire :

• Il existe des opérateurs qui permettent de simplifier l'écriture d'une opération d'affectation associée à un opérateur mathématique.

Opérateur Exe ple Signification

= a=10 a=10

+= a+=10 a=a+10

-= a-=10 a=a-10

*= a*=10 a=a*10

/= a/=10 a=a/10

%= a%=10 a=a%10

^= a^=10 a=a^10

Attention

• Lors d'une opération sur des opérandes de types différents, le compilateur détermine le type du résultat en prenant le type le plus précis des opérandes.

Exemple

• ne multiplication d'une variable de type float avec une variable de type ou le donne un résultat de type dou le.
• Lors d'une opération entre un opérande entier et un flottant, le résultat est du type de l'opérande flottant. Incr entation & écrémentation
• Les opérateurs d'incrémentation et de décrémentation sont : n++ ++n n-- --n
• Si l'opérateur est placé avan  la variable (préfixé), la modification de la valeur est immédia sinon la modification n'a lieu qu'à l'issu de l'eécution de la ligne d'instruction (postfixé)
• L'opérateur ++ renvoie la valeur avan  incrémentation s'il est postfixé,

aprè  incrémentation s'il est préfixé.

Exemple

/* test sur les incrémentations prefixées et postfixées */

class test {

public static void main (String args[]) {

int n1=0;

int n2=0;

System.out.println("n1= " + n1 + " n2 = " + n2);

n1=n2++;

System.out.println("n1= " + n1 + " n2 = " + n2);

n1=++n2;

System.out.println("n1= " + n1 + " n2 = " + n2);

n1=n1++; //attention

System.out.println("n1= " + n1 + " n2 = " + n2);

} }

• Résul a  :

int n1=0;

int n2=0; // n1=0 n2=0

n1=n2++; // n1=0 n2=1

n1=++n2; // n1=2 n2=2

n1=n1++; // attention : n1 ne change pas de valeur

Les structures de contrôle

Les boucles

1.

While ( condition )

{... // code a eécuter dans la boucle }

• Le code est eécuté tant pue la condition est vraie.
• Si avant l'instruction while, la condition est fausse, alors le code de la boucle ne sera jamais eécuté. 2.

do

{...}

while ( condition )

• Cette boucle est au moins exécutée une fois quelque soit la valeur de la condition

3.

for ( initialisation; condition; modification)

{...}

Exemples:

• for (i = 0 ; i < l0; i++ ) { ....}
• for (int i = 0 ; i < l0; i++ ) { ....}
• for ( ; ; ) { ... } // boucle infinie
• L'initialisation, la condition et la modification de l'inde sont optionnels.
• Dans l'initialisation, on peut déclarer une variable qui servira d'inde et qui sera dans ce cas locale à la boucle.
• Il est possible d'inclure plusieurs traitements dans l'initialisation et la modification de la boucle
• Chacun des traitements doit être séparé par une virgule. Exemple : for (i = 0 , j = 0 ; i * j < 1000;i++ , j+= 2) { ....}
• La condition peut ne pas porter sur l'inde de la boucle :

Exemple :

boolean trouve = false;

for (int i = 0 ; !trouve ; i++ ) {

if ( tableau[i] == l )

trouve = true;

... //gestion de la fin du parcours du tableau

}

Les branchements conditionnels

1.

...

}

2.

switch (epression) {

case constantel :

instrll;

instrl2;

break;

case constante2 :

...

default :... }

• On ne peut utiliser switch qu'avec des types primitifs d'une taille maximum de 32 bits (byte, short, int, char). L'opérateur ternaire :

( condition ) ? valeur-vrai : valeur-faux

Exemple 1 :

if (niveau == 5) total = 10;

else total = 5 ;

// équivalent à total = (niveau ==5) ? 10 : 5;

Exemple 2 :

System.out.println((genre == " H ") ? " Mr " : " Mme ");

Les tableaux

Ø La déclaration des tableaux

• Java permet de placer les crochets après ou avant le nom du tableau  dans la déclaration.

Exemple :

int tableau[ ] = new int[50]; // déclaration et allocation

O int[ ] tableau = new int[50]; O int tab[]; // déclaration

tab = new int[50]; //allocation

Remarque

• Le premier élément d'un tableau possède l'indice 0.
• Java ne supporte pas directement les tableaux à plusieurs dimensions :
• Déclarer un tableau de tableau. Exemple : float tableau[][] = new float[10][10];
• La taille des tableaux de la seconde dimension peut ne pas être identique

pour chaque occurrence.

Exemple:

int dim1[ ][ ] = new int[3][ ];

dim1[0] = new int[4];

dim1[1] = new int[9];

dim1[2] = new int[2];

• Chaque élément du tableau est initialisé selon son type par l'instruction new : 0 0 pour les numériques,

o '\0' pour les caractères,

o false pour les booléens

o et nil pour les chaines de caractères et les autres objets.

Ø L'initialisation explicite d'un tableau

o Exemples :

int tableau[5] = {10,20,30,40,50}; int tableau[3][2] = {{5,1},{6,2},{7,3}};

• La taille du tableau n'est pas obligatoire si le tableau est initialisé à sa création.

o Exemple

int tableau[] = {10,20,30,40,50};

• Le nombre d'éléments de chaque lignes peut ne pas être identique :
• Exemple :

int[][] tabEntiers = {{1,2,3,4,5,6},{1,2,3,4},{1,2,3,4,5,6,7,8,9}}; Les conversions de types

• Lors de la déclaration, il est possible d'utiliser un cast : Exemple :

int entier = 5;

float flottant = (float) entier;

• La conversion peut entraîner une perte d'informations
• Il n'existe pas en Java de fonction pour convertir :
• Les conversions de type se font par des méthodes.
• La bibliothèque de classes API fournit une série de classes qui contiennent des méthodes de manipulation et de conversion de types élémentaires.
• String pour les chaînes de caractères nicode
• Integer pour les valeurs entières (integer)
• Long pour les entiers long signés (long)
• Float pour les nombres à virgules flottante (float)
• Double pour les nombres à virgule flottante en double précision (double)
• Les classes portent le même nom que le type élémentaire sur lequel elles reposent avec la première lettre en majuscule.

La conversion d'un entier int en chaîne de caractère String

Exemple :

int i = 10;

String montexte = new String();

montexte =montexte.valueOf(i);

• value0f est également définie pour des arguments de type boolean, long, float, double et char

La conversion d'une chaîne de caractères String en entier int

Exemple :

String montexte = new String(" 10 ");

Integer monnombre=new Integer(montexte);

int i = monnombre.intValue() //conversion d'Integer en int La mani ulation des chaînes de caractères

• Les chaînes de caractères ne sont pas des tableaux
• Il faut utiliser les méthodes de la classe St❦ing d'un objet instancié pour effectuer des manipulations.
• Il est impossible de modifier le contenu d'un objet String construit à partir d'une constante.
• Cependant, il est possible d'utiliser les méthodes qui renvoient une chaîne pour modifier le contenu de la chaîne.
• Exempe:

String texte = " Java Java Java " texte = texte.replace('a','o')

Les caact•es spéciaux dans es cha♣nes

• Dans une chaîne de caractères, plusieurs caractères particuliers doivent être utilisés avec le caractère d'échappement \.

...

C1lapitre II

Proé;rammation Orientée Objet

Appliquée au lané;aé;e JAVA

POO Vs Progra ation structurée

n Proierammation structurée (procédurale)

• Diviser un programme en sous-programmes,
• S'intéresser aux traitements puis aux données ~~e dit faire le pr~gramme ?

n Objectifs de la POO

• Facilité la réutilisation de code, o encapsulation et abst action
• Facilité de l'évolution du code
• Améliorer la conception et la maintenance des grands systèmes
• Programmation par « composants ».
• Conception d'un logiciel à la manière de la fabrication d'une voiture Définition de l'approche orientée objet
• Une méthode de modélisation basée sur une représentation abstaite  des entités du monde réel
• Une méthode qui regroupe les données et les traitements sur ces données au sein d'une entité unique : l'jet.
• Une méthode qui exprime les fonctionnalités sous la forme de collaborations entre les objets

La notion d'objet

• La Programmation Orientée Objet consiste à modéliser informatiquement un ensemble d'éléments d'une partie du monde réel en un ensemble d'entités informatiques.

objet✈.

• Ces entités informatiques sont appelées
• Il s'agit de données informatiques regroupant les principales caractéristiques des éléments du monde réel (taille, couleur, ...).
• Cette modélisation consiste à créer une représentation abstraite, sous forme d'objets, d'entités ayant une existence matéielle (chien, voiture, ampoule, ...) ou bien vituelle (sécurité sociale, temps, ...).
• Un objet est caractérisé par plusieurs notions :

o Les attributs: les données caractérisant l'objet.

n Des variables stockant des informations d'état de l'objet

o Les méthodes (appelées parfois fonctions me mbes)

n caractérisent son comportement,

n l'ensemble des actions (appelées opéations) que l'objet est à même de réaliser.

n Ces opérations permettent de faire réagir l'objet aux sollicitations extérieures (ou d'agir sur les autres objets).

n les opérations sont étroitement liées aux attributs,

n leurs actions peuvent dépendre des valeurs des attributs, ou bien les modifier

o L'identité:

n Permet de le distinguer un objet des autres objets, indépendamment de son état.

n Exemple un produit pourra être repéré par un code,

n une voiture par un numéro de série,

n etc.

• Un objet est un groupe de donnéetructuréecaractérié par un identifiant unique représentant le monde réel.
• Un objet est constitué attribut qui caractérisent la structure de celui-ci.
• Exemple : Réféence, Désignation, P⑤ixUnitai e et Quantité sont les att⑤ibuts de l'objet de type ARTICLE.
• L'objet est manipulé par des procédures appelées métode qui sont caractérisées par une entête définissant leur nom, les paramètres d'appel et de retour pour chacune d'elle.
• Exemple : On peut définir comme méthodes de l'objet ARTICLE

o P⑧ixTtc : Méthode permettant de calculer le prix TTC d'un article

o SortieArticle : Méthode permettant de diminuer la quantité en stock

Remarque

On ne peut exécuter une méthode sans préciser l'objet sur lequel elle s'applique.

Notion de classe

• Les objets qui ont les mêmes états et les mêmes comportements sont regroupés :

o c'est une classe

• Une classe est un modèle de définition pour des objets

o Ayant même structure (même ensemble d'attributs)

o Ayant même comportement (même méthodes)

o Ayant une sémantique commune

• Les objets sont des représentations dynamiques, du modèle défini pour eux au travers de la classe (instanciation)

o Une classe permet d'instancier (créer) plusieurs objets

o Chaque objet est instance d'une et une seule classe

£ Exemple  : classe "Voiture"

Programmation Orientée Objet

£ Un programme OO est constitué de classes qui permettent de créer des objets qui senvoient des messages

£ L'ensemble des interactions entre les objets défini un algorithme

£ Les relations entre les classes reflètent la décomposition du programme

POO avec Java

£ Un programme en Java se présente comme un ensemble de classes ~

o une classe par fichier.

o le fichier doit porter le même nom que la classe

n (sans l'extension Java) £ Faire attention aux majuscules,

o La première lettre de l'identificateur de la classe est en mjuscule,

o La première lettre des méthodes est en minuscule.

Conventions de noms £ CeciEstUneClasse

£ celaEstUneMethode(...)

£ jeSuisUneVariable £

JE—SUIS—UNE—CONSTANTE

Affectation et comparaison £ Affecter un objet

o "a = b" signifie a devient identique à b

o Les deux objets a et b sont identiques et toute modification de a entraîne celle de b £ Comparer deux objets

o "a == b " retourne « true » si les deux objets sont identiques

o C'est-à-dire si les références sont les mêmes,

o cela ne compare pas les attributs

• Le test de comparaison(== et !=) entre objets ne concerne que les références et non les attributs!!!!
• Recopier les attributs d'un objet « clone() »

o Les deux objets a et b sont distincts

o Toute modification de a n'entraîne pas celle de b

• Comparer le contenu des objets ~

o « equals(Object o) »

• Renvoyer « true » si les objets a et b peuvent être considérés comme identiques au vu de leurs attributs

Cycle de vie d'un objet

Création

o Usage d'un Constructeur

o L'objet est créé en mémoire et les attributs de l'objet sont initialisés Utilisation

o Usage des Méthodes et des Attributs Les attributs de l'objet peuvent être modifiés

o Les attributs (ou leurs dérivés) peuvent être consultés

Remarque :L'utilisation d'un objet non construit provoque une NullPointerExcecution  exception de type

Notion de constructeur

• La création d'un nouvel objet est obtenue par l'appel à new Constructeur(paramètres)
• Il existe un constructeur par défaut qui ne possède pas de paramètres

o si aucun autre constructeur avec paramètre n'existe

• NB: Les constructeurs portent le même nom que la classe  Exemple

class Point

{

//Attributs

double X;

double Y;

//Constructeur sans paramètres

public Point ()

{

X=0;

Y=0;

}

//Constructeur avec un seul paramètre

public Point (double a)

{

x=a;

y=0;

}

//Constructeur avec deux paramètres

public Point(double a, double b)

{

x=a;

y=b;

}

//Méthode affiche : pour afficher les coordonnées

d'un point

void affic he()

{

System.out.println("p=("+x+", "+y+")");

}

}

class TestPoint

{

//Méthode main: point d'entrée du programme

public static void main(String []args)

{

//Déclaration puis création

Point p1;//déclaration

pl=new Point();/*création et allocation mémoire en utilisant le premier constructeur*/

//Déclaration et création en une seule ligne Point p2=new Point(3.5);

Point p3 = new Point(4.6, 8D);

/*Appel de la méthode affiche

pour afficher les coordonnées des points*/ pl.affic he(); p2.affic he(); p3.affic he(); }

}

On obtient sur l'écran: p=(0.0,0.0) p=(3.5,0.0) p=(4.6,8.0)

Constructeur : définition

• Un constructeur est une méthode particulière appelée au moment de la création pour initialiser l'objet en fonction des paramètres fournis par l'utilisateur.
• Règles à respecter:

o Le nom du constructeur doit correspondre exactement au nom de la classe.

o Aucun type de retour déclaré par le constructeur.

• Une classe peut avoir plusieurs constructeurs avec des listes d'arguments différents,

o La liste des arguments qui détermine quel constructeur doit être utilisé lors de l'appel de l'un des constructeurs.

• Toute classe a au moins un constructeur,

o Si aucun constructeur n'a été écrit dans la classe un constructeur par défaut est fourni sans arguments et son corps est vide.

o Si une classe comporte au moins un constructeur elle perd son constructeur par défaut. Accès au attri uts

• L'accès à un attribut d'une classe se fait toujours à l'intérieur d'une méthode.
• Si la méthode (sauf pour main) appartient à la même classe que l'attribut l'accès se fait en indiquant le nom de l'attribut directement.
• Si la méthode n'appartient pas à la même classe de l'attribut ou s'il s'agit de la méthode main il faut créer d'abord un objet à partir de la classe de l'attribut et y accéder comme suit:

Exemple  nom_objet.nom_attribut;

class Point

{

double x;

double y;

void affiche()

{

System.out.println("p=("+x+", "+y+")");

//on appelle les attributs directement par leurs noms

}

public static void main(String [ ]args)

Point p = new Point();

System.out.println("abscisse de p="+p.x);

//accès à l'attribut après création de l'objet p.affic he();

}

On obtient sur l'écran:

abscisse de p= 0.0

P=(0.0,0.0)

Acc s à une méthode

• Si l'appel de la méthode se fait à l'intérieur de la classe (dans une autre méthode sauf pour main) on écrit directement:

nom_méthode(liste_paramètres);

• Si l'appel de la méthode est effectué à l'extérieur de la classe ou dans la méthode main, il faut créer un objet de cette classe et appeler la méthode comme suit:  nom_objet.nom_méthode(liste_paramètres); Encapsulation
• Le regroupement des données et des méthodes dans un même objet enc➅su~L~on. ainsi que le masquage de données est appelé:

o Une classe fournit un certain nombre de services et les utilisateurs de cette classe n'ont pas à connaître la façon dont ces services sont rendus.

• Il faut donc distinguer dans la description de la classe deux parties :

o La partie publique, accessible par les autres classes,

o La partie privée, accessible uniquement par les méthodes de la classe.

• Il est vivement recommandé de mettre les attributs d'une classe dans la partie privée, ainsi protégés, les membres privés d'une classe ne sont pas directement modifiables.
• Les niveaux d'accès
• Java définit 3 niveaux d'accès pour les variables d'instances (données membres) et les méthodes :
• public : un élément public est accessible de partout et sans aucune restriction.

o Certaines classes (comme la classe principale main) doivent obligatoirement être déclarées publiques (pour pouvoir exécuter l'application...)

• protected : un élément protected (protégé) est accessible uniquement aux classes d'un pacage et à ses classes filles
• private : un élément private (privé) est accessible uniquement au sein de la classe dans laquelle il est déclaré.

£ Ces éléments ne peuvent être manipulés qu'à l'aide de méthodes spécifiques appelés accesseur et mutateur

La notion d'accesseur

r~cu➋~rer

£ Un accesseur est une méthode permettant de le contenu d'une donnée membre protégée.

£ Un accesseur, pour accomplir sa fonction :

o doit avoir comme type de retour le type de la variable à renvoyer

o ne doit pas nécessairement posséder d'arguments

£ Une convention de nommer veut que l'on fasse commencer de façon préférentielle le nom de l'accesseur par le préfixe get.

Exemple

public double getX()

{

return x;

}

La notion de mutateur

modiifier

£ Un mutateur (modificateur) est une méthode permettant de le contenu d'une donnée membre protégée. £ Un mutateur, pour accomplir sa fonction :

o doit avoir comme paramètre la valeur à assigner à la donnée membre. Le paramètre doit donc être du type de la donnée membre

o ne doit pas nécessairement renvoyer de valeur (il possède dans sa plus simple expression le type void)

£ Une convention de nommer veut que l'on fasse commencer de façon préférentielle le nom du mutateur par le préfixe set.

Exemple

class Point {

private double x; private double y;

public void setX(double a) { x=a; }

Notion de destructeur

£ La destruction des objets se fait de manière implicite

...

Chapitre V Le cla e a rai e e leinerlace

Introduction

• En général, l'héritage suit la règle suivante :

o Les sous-classes sont plus concrètes et spécifiques que les classes dont elles dérivent qui sont plus générales et abstraites.

• En POO, on conçoit ainsi souvent des classes dont la seule raison d'être est d'agir comme un ensemble commun de méthodes et de variables  pour des sous-classes.

o Par exemple, une classe Vehicule ne servirait que comme dénominateur commun entre les classes Voiture et Velo.

Les classes abstraites en JAVA

• Il existe en Java un modificateur spécial pour ce concept : abstract.
• Une classe déclarée abstraite (abstract) est une classe normale, mais il est interdit d'en créer des instances (des objets).

o Elles servent donc de modèle à des sous classes.

• Une méthode abstraite ne nécessite pas d'implémentation.
• Ce sont les sous-classes qui doivent fournir l'implémentation en  redéfinissant cette méthode.

Ø C'est une obligation : une sous-classe d'une classe abstraite doit redéfinir toutes les méthodes abstraites de la classe de base.

Dé inition d'une classe abstraite

• Une classe abstraite est une classe incomplète.
• Elle regroupe un ensemble de variables et de méthodes mais certaines de ses méthodes ne contiennent pas d'instructions,

o Elles devront être définies dans une classe héritant de cette classe abstraite. Utilité es classes abstraites

• Une classe abstraite sert à définir les grandes lignes du comportement d'une classe d'objets sans forcer l'implémentation des détails de l'algorithme.
• Prenons l'exemple d'une chaîne de montage automobile, de laquelle sort un modèle de voiture particulier.

o On peut choisir de faire une nouvelle chaîne de montage pour le modèle à pare-choc métallisé, une pour le modèle à pare-choc en plastique, etc.

o Ou on peut décider de faire une chaîne de montage générique, de laquelle sortiront des véhicules non finis, que l'on terminera sur d'autres petites chaînes.

Règles d'utilisation des classes abstraites

ü Rèale 1 : Une classe est automatiquement abstraite si une de ses méthodes est abstraite.

ü Rèale 2 : On déclare qu'une classe est abstraite par le mot clef abstract.

abstract NomClasse {Attributs et Méthodes}

ü Rèale 3 : Une classe abstraite n'est pas instanciable

o On ne peut pas utiliser les constructeurs d'une classe abstraite et donc on ne peut pas créer d'objet de cette classe.

ü Rèale 4 : Une classe qui hérite d'une classe abstraite ne devient concrète que si elle implémente toutes les méthodes abstraites de la cla sse dont elle hérite.

ü Rèale 5 : Une méthode abstraite ne contient pas de corps, mais doit être implémentée dans les sous-classes non abstraites:

abstract nomDeMéthode (arguments);

ü Rèale 6 : Une classe abstraite peut contenir des méthodes non abstraites et des déclarations de variables ordinaires.

ü Rèale 7 : Une classe abstraite peut être dérivée en une sous-classe :

o Abstraite si une ou plusieurs méthodes ne sont pas implémentées par la classe fille,

o Non abstraite si toutes les méthodes abstraites sont implémentées dans la classe fille. Activité

1. Il s'agit de définir une classe nommée Forme comportant

• deux méthodes abstraites :

o float perimetre() et float surface()

• Et une méthode non abstraite void contenantCarre(float surf) qui affiche

o "Cette forme peut contenir un carré de surface surf "

o "Cette forme peut contenir un carré de surface surf"

2. Écrire ensuite les deux classes Rectangle et Cercle héritant de cette classe Forme et définissant les deux méthodes abstraites de celle-ci.

• La classe Rectangle a 2 attributs entiers privés

o longueur et largeur

• La classe Cercle a un attribut privé de type float nommé rayon

Application

• Tester la méthode contenantCarre de la classe Forme avec un surf = 20 (dans la méthode main) en l'appliquant pour un rectangle de longueur = 2 et de largeur = 1
• Puis la tester avec surf = l pour un cercle de rayon=l.

Les interfaces

• Une interface en Java est comme une classe abstraite sans aucune  m~tho➵e. ~finition e
• L'interface décrit les méthodes et les types de leurs arguments, sans rien dire sur leur implémentation
• les attributs sont public static final

o Constantes

• les méthodes sont toutes abstraites

public abstract

A quoi sert une interface ?

• Elles sont utiles pour des équipes qui travaillent sur un même projet

o Chacune doit pouvoir connaître les méthodes qui seront implémentées par les autres et leur spécification pour pouvoir inclure les appels dans leurs propres méthodes.

Ø Les interfaces sont des groupes de méthodes que l'on peut réutiliser où bon nous semble.

• Une seule interface par fichier
• Une interface est différente d'une classe,

o On ne peut pas instancier une interface;

o On implémente une interfaceO

• Une interface ne comporte que des constantes et des méthodes abstraites.

o Elle n'est pas "classe abstraite"

• Une classe peut implémenter une ou plusieurs interfaces, c'est à dire définir le corps de toutes les méthodes abstraites.

o C'est l'héritage multiple de Java. Syntaxe Déclaration

interface Nominterface

{

attributs (par défaut public, static, final) méthodes (par défaut abstract, public)

}

Utilisation

class LaClasse implements Nominterfacel, ... {

Définition de toutes les méthodes abstraites

}

Activité

• Ecrire une interface nommée Homme possédant une seule méthode void identite() dont le rôle est d'afficher les informations concernant un homme.
• Ecrire une classe Personne implémentant cette interface et possédant deux attributs privés nom et prenom de type String et un constructeur paramétré avec le nom et le prénom d'une personne.
• Ecrire une classe Client héritant de la classe Personne et implémentant  l'interface Homme avec un attribut privé supplémentaire nommé numero de type entier et un constructeur paramétré en conséquence.