Java

Java
Caractéristique de java :
Architecture neutre
Orienté objet
Distribué
Compilé et interprété
Robuste
Dynamique
Sécurisé
Indépendant du système d’exploitation.
Limites de Java :
Moins rapide qu’un vrai exécutable (C).
Solutions : Optimiser les machines virtuelles, compilateur JIT
(Just In Time).
2 types de programmes :
Application (programme indépendant)
Applet (Exécuté a automatiquement quand ils sont chargé dans une page HTML.
Commentaire :
Identique au C++
// sur une ligne
/* plusieurs lignes */
Javadoc
/** déscription pour la création Automatique de documentations.*/
Afficher un texte.
En C++ ( cout<< ‘’hello World !’’<<endl ;
En Java :
System.out.printl(‘’hello World !’’) ;
1 exemple d’application : (format :ASCII)
//fichier HelloWorld.java
class HelloWorld
{
static public void main(String args[])
{
system.out.printl(‘’HelloWorld’’) ;
}
}
Compilation de l’exemple :
javac HelloWorld.java
-g ou –g :none :compile avec ou sans les infos de debug.
-d <dir> spécifie le répertoire de destination des .class .
Execution de l’exemple :
Java HelloWorld
Les types natifs Java :
Entiers (byte, short, int, long)
Nombre réels (float, double)
Caractère (char)
128 premiers = codes ASCII ‘a’,’1’
‘\n’ pour un saut de ligne
‘\t’ pour une tabulation
‘\’’ pour une ‘
‘\\’ pour \
Booléen (true, false)
Conversion automatique :
Erreur :
double d =0.0d ;
int i = d ; // ‘’possible loss of precision’’
Necessite une conversion explicite :
double d = 0.0d ;
int i = (int)d ; // ok
Références :
En java pas de pointeur, une variable est soit de type natif, soit une référence.
Les blocs :
Identique au C
{
}
On peut déclarer les variables à tout instant, elles sont locales et temporaires.
Les variables sont automatiquement détruite en dehors de sa portée.
Les tests
Identique au C :
if(conditions) { }
if() { }
else { }
switch ()
{
case : break ;
default : break ;
}
! différence : les expressions à tester doivent être de type boolean.
Les boucles
Identique au C :
while() { }
do { }
while () ;
for ( ; ; ) { }
L’opérateur new
Sert à créer des instances d’une classe
String s = new String() ;
Ne s’applique pas aux types natifs en Java (sauf pour l’initialisation des tableaux)
Les tableaux
Déclaration similaire au C
On peut mettre les [] avant ou après la variable
Possibilité de créer des tableaux multidimensionnels
L’indexage est protégé (dépassement génère une exception d’erreur)
2 exemple : tableaux
//Déclaration
int [] tInt ;
float tfloat [] ;
//Création
int [] tInt2 = new int[4] ;
double tDboule[] [] = new double[2][3] ;
//Création avec initialisation
long [] tLong = {3L, 2L} ;
short [] [] tShort = {{4,5},{1,2,3}
, null } ;//Dimension
int [] vide = {} ;
Les classes de base :
Les chaînes de caractères
Deux types :
Pour les constantes : String
Pour les variables : StringBuffer
Les types natifs peuvent être convertis
String s= ´´total = ´´+3 + ´´CHF´´ ;
Retrouver la longueur d’une chaîne
int lg = s.lenght() ;
Accès en lecture (String ou StringBuffer) à
un caractère donné de la chaine :
.charAt (int index) ;
String s =´´total´´ ;
char c = s.charAt(1) ; // c = ‘o’
au tableau de caractère donné de la chaîne :
.toCharArray() ; // ou .toString().toCharArray() ;
char[ ] ctab = s.toCharArray() ; //ctab[] = {´t´,…}
.getChars ( int deb, int fin,
char[] dst, int dstdeb) ;
char [] ctab = new char [s.lengh()] ;
s.getChars(0, s.length(), ctab, 0) ; //ctab[]=(´t´,…)
Accès en écriture (StringBuffer)
A un caractère donné de la chaine
.setCharAt (int index, char c) ;
StringBuffer s = new StringBuffer(´´total´´) ;
s.setCharAt(2,´n´) ; // s = ´´tonal´
La classe System et les E/S
Cette classe permet d’accéder à la console pour les entrées et les sorties avec
out, err pour la sortie standard et d’erreur.
in pour l’entrée standard
3 exemple : lire ligne clavier
import java.io.* ;
public class LireLigneClavier
{
public static void main (String[] args)
throws java.io.IOException
{
BufferedReader inr = new BufferedReader
(new InputStreamReader (System.in)) ;
System.out.print(´´tapez un nombre ; ´´) ;
String s = inr.readLine() ;
Int a = Integrer.parseInt(s) ;
System.out.println(a*a) ; // imprime a au carré
}
}
EXERCICE 1
Faire un programme qui calcule la moyenne de N notes saisies au clavier
( la somme des notes sera calculée au fur et à mesure de la saisie).
Pas à pas :
Déclaration des variables :
N = nombre de note à saisir
I = compteur de 1 à N
somme = cumul de la somme
note = note saisie par l’utilisateur
moyenne = résultat
Algorithme :
Somme  0
Saisir N
Pour i = 1 à N
Saisir note
Somme  somme + note
Moyenne  somme/N
Afficher (moyenne)
Solution :
import java.io.* ;
class lireligne
{
public static void main(String args[])
throws java.io.IOException
{
BufferedReader inr = new BufferedReader(new
InputStreamReader(System.in));
System.out.print("Entrez le nombre de notes a saisir : ");
String s =inr.readLine();
int nbNotes = Integer.parseInt(s);
int somme = 0;
int i;
for(i=0; i<nbNotes; i++)
{
System.out.println("entez votre note numero : " +i);
s = inr.readLine();
somme += Integer.parseInt(s);
}
System.out.println("La somme est =" +somme);
}
}
EXERCICE 2 :
Faire un programme simulant une calculatrice 4 opérations
(saisir un nombre, une opération, et un nombre puis afficher le résultat).
= pour terminer le programme.
Exemple :
2*5 10
4=6 fin du programme
Pas à pas :
1. saisir les données (valeurs et opérateurs)
2. Faire les calculs
3. Afficher le résultat
Déclaration des variables
float val et val2 = les 2 valeurs courantes de l’opérations
float res = résultat de l’opération
Bool fin = fin des calculs ?
Fin  faux
faire {
saisir val1, op et val2
suivant op
si op =´*´alors res  val1*val2
si op =´/´alors res  val1/val2
si op=´+´ alors res  val1+val2
si op =´-´alors res val1-val2
si op=´=´alors fin vrai
fin suivant
afficher res
} tant que (non fin)
Solution :
import.java.io.* ;
class calculette {
public static void main(String args[])throws java.io.IOException
{
int val1,val2,res = 0 ;
char oper ;
boolean fin=false ;
BufferedReader inr = new BufferedReader(new
InputStreamReader(System.in)) ;
String sval1, soper, sval2 ;
do
{
System.out.println(´´NOMBRE OPERATEUR NOMBRE, par exemple :
5*2´´) ;
System.out.println(´´Operateur = pour terminer \n´´) ;
System.out.println(´´Calcul : ´´) ;
sval1 = inr.readLine() ;
soper = inr.readLine() ;
sval2 = inr.readLine() ;
val1 = Integer.parselnt(sval1) ;
val3 = Integer.parselnt(sval2) ;
oper = soper.charAt(0) ; //prendre le premier caractère
switch(oper)
{
case ‘*’ : res=val1*val2 ; break ;
case’/’ : res=val1/val2 ; break ;
case ‘+’ : res=val1+val2 ;break ;
case’-‘ : res=val1-val2 ;break ;
case’=’ : fin=true ;
}
if(fin == false)
{
System.Out.Println(val1 + ‘’ ‘’+oper +’’ ‘’+val2+’’ =’’+res) ;
}
}
while(fin !=true) ;
}//main
}
Java Classes et Objets
Notions :
Classe : c’est un type d’objet
Définition d’un objet en terme de
Conteneus (variables)
Méthodes à exécuter pour accéder /modifier son contenu
Objet : c’est une instance d’une classe
Créé par un constructeur (méthode spéciale fournie par la classe)
Héritage : Relation entre les classes, donc entre les objets.
Classe
Définit un type d’objet en termes de
Variables = stockage d’état
Méthodes = opérations changeant l’état de l’objet
Different type de variable
Variable de classe : commun à tous les objets
Variable d’instance : Lié à une instance d’objet.
Variable d’instance : Utilise ces mots clés comme qualificatifs (modifier)
Public : indique un accès libre à la variable
Private : indique un accès exclusif par les méthodes de classe
Protected : indique un accès réservé aux méthode de la classe et de ses
descendants.
Sans mots clef : accessible seulement par les autres classes du même
package.
Variable d’instance, exemple :
class Compte
{
public int numero ; //variable d’instance
private float solde ;//variable d’instance
static public int nb2comptes = 0 ; //variable de classe
{
// bloc d’initialisation
numero = 0 ;
solde = 0.0f ;
nb2compte++ ;
}
}
Objet :
Instance d’une classe :
Contient les valeurs associées à un objet particulier
Pour chaque variable d’instance de la classe qui le définit.
Difference classe VS objet
Classe : définit le modèle de l’objet, de ses propriétés et attributs généraux
Ex : classe vélo
couleur, nombredevitesse
Objet : Incarne une instance avec des paramètres propres :
Ex : objet vélo
couleur=bleu, vitesse = 10, …
Constante
Déclaration, puis première initialisation
final int numeroBanque ;
numeroBanque = 2345 ; // ok
numeroBanque = 2345 ; // erreur (car valeur est final)
Déclaration avec initialisation
final int numeroBanque = 2345 ;
numeroBanque = 2345 // erreur
Exemple de constante : Float
Champs :
public final static float POSITIVE_INFINTY
public final static float NEGATIVE_INFINITY
public final static float NaN
public final static double MAX_VALUE
1.40129846432481707e-45f
public final static double MIN _VALUE
3.40282346638528860e+38f
Variable de classe
Utilise le mot clé static .
class Compte
{
static int nb2comptes = 0 ;
static String nomBanque = ‘’MiraB’’ ;
static finl int numeroBanque ;
static
{
// bloc d’initialisation static
numeroBanque = 0 ;
}
}
Accès à une variable d’un objet
Se fait en précisant le nom de l’objet suivit de ’’.’’ et du nom de la variable
Compte client1 = new Compte() ;
if(client1.numero == 1)
client1.solde += 10000.0f ;
class Compte
{
public int numero ;
private float solde ;
public float calculerSolde()
{ return this.solde ; }
}
class AutreCompte
{
private Compte c = new Compte() ;
public float autresolde()
{
if (c.numero >0) //ok
return c.solde ; //erreur
return 1.0f ;
}
}
Structure d’un programme Java
3 sections optionnelles :
Déclaration de package
Import de packages ou de classes : import
Déclarations des classes et des interfaces du fichier.
Package :
Définit un groupe de travail dans lequel les classe doivent être rangées
Cette directive doit être placée au début du fichier
Le nom de package correspond à un répertoire dans lequel les
classes doivent être placées.
Exemple
package alternet ; // Répertoire : alternet/
class AltClasse1 {} // alternet/Altclasse1.class
Import :
Permet de charger des classes d’autre packages en vue d’utiliser leurs
fonctionnalités.
On peut spécifier le nom du package qui contient la ou les classes
Exemple :
import cePackage.* ; (nom du package d’ou on utilise la classe)
import package.autreClasse ;
import cetteClasse ;
Déclaration de classses
Syntaxe : qualificatif class nomClasse{}
public class Classe2
{ // corps de classe2 }
Les qualificatifs sont
public : indique la classe exporté par le fichier .java (même nom que le
fichier.java
final : indique que la classe ne peut pas être dérivée
abstract : obligatoire pour les classes contenant les méthodes abstract
(on ne peut pas créér d’instance d’objet de ces classes)
Le corps d’une classe peut contenir :
des dclarations de varialbes
des déclarations de méthodes
des blocs d’intialisatilons
des classes internes (déclarée à l’interieur d’une classe)
Classe interne :
Les qualificatifs sont :
public, private, protected ( comme variable d’instance)
final, abstract (comme les classes externes)
static ( indique que la classe est indépendante des instances d’objet)
Création de classe interne static
class Externe
{
static class Interne {}
}
class Autre
{
public Externe.Interne ei ;
{ ei= new Externe.Interne() ; }
}
Création de classe interne non static
class Externe
{
oublic class Interne {}
}
final class Autre
{
public Externe e = new Externe() ;
public Externe.Interne ei ;
{
ei= new Externe.Interne() ; //erreur
ei= e.new Interne() ; //ok
}
}
Classe interne non static
Dépend de l’instance de la classe externe
2 objets d’une même classe externe peuvent stocker des instances
internes différentes
Conserve une éférence vers cette classe
Permet d’appeler les méthodes de la classe externe
Classes internes imbiquées
Une classe interne peut à son tour contenir des classes internes
class Externe
{ public class Interne1
{
private class Interne2 {}
}
}
Compilation : chaque classe d’un fichier .java génère un fichier .class
lors de la compilation.
Pour une classe interne le nom du fichier :
Externe$Intrne.class
Externe$Interne1$interne2.class
Exemple :
// 1 debut du fichier maClasse.java
//déclaration de package :
package MonPackage
// 2 déclaration d’Import
//classe sans package :
import MaClasse
// classe d’un package :
import MonPackage.MaClasse ;
//toutes les classes d’un package
import MonPackage.* ;
//3 déclarations des classes
public class MaClasse
(1 seule classe déclarée public, par convention porte le même nom que le fichier.)
{//corps de MaClasse}
class MaClasse2
{ //corps de Maclasse2}
Introduction à la programmation objet
La programmation par objet PPO
On peut dire que la complexité des problèmes qu’opn est capable de resoudre est
directement proportionnelle au type et à la qualité de nos capacités d’abstraction.
Le fortran, Basic et le C sont de nettes amélioration par rapport au langage assembleur
mais leur abstraction première requiert une réflexion en termes de structure ordinateur
plutôt qu’à la structure du problème.
L’approche orienté objet va un cran plus loin en fournissant un concepteur des outils
premettant de représenter des éléments dans l’éspace problème.
L’idée est que :
Le programmeur est autorisé à s’adapter à l’ésprit du problème en ajoutant de
nouveaux types d’objet, de façon à ce que, quand on lit le code décrivant la solution,
on lit aussi quelque chose qui décrit le problème.
La programmation orienté objet (POO) permet de décrire le rpoblème avec les termes
même du problème plutôt qu’avec les termes de la machine ou la solution sera mise en
œuvre.
Tous les objets ont leur propre caractéristique et comportement.
1. Toute chose est un objet (=variable amélorée)
2. Un programme est un ensemble d’objet se disant les uns aux autre quoi faire.
3. Chaque objet à son propre espace de mémoire composé d’autres objets.
4. Chaque objet est d’un type précis.
5. Tous les objets d’un type particulier peuvent recevoir le même
message.(=substituablité)
Un objet dispose d’une interface :
Une classe décrit un ensemble d’objet partageant des caractéristiques communes
et des comportements.
Une fois qu’une classe est créée, on peut créer autant d’objets de cette classe
qu’on veut et les manipuler comme s’ils étaient les éléments du problème.
Comment utiliser un objet ?
Il faut pouvoir lui demander d’exécuter une requète.
Chaque objet ne peut traiter que certaine requetes (définis par son
interface).
Limite d’accès :
Java utilise 3 mots clés pour fixer les limites au sein d’une classe :
public (tt le monde à accès au définition)
private (personne y a accès)
protected (seul la classe et ses dérivée y ont accès)
par defaut (accès dans le même package sinon se comporte en private)
Les méthodes
Définition : fonction, procédure définie dans une classe.
On distingue
Les méthodes de classe (invoquées sans faire référence à un objet)
Les méthodes d’instance (invoquées pour une instance d’objet)
Encapsulation : séparation entre le service rendu par la classe et son implementation.
Il est judicieux de cacher les varaibles d’instance private en fournissant un accès
par des méthodes qui testent la validité des paramètres.
Déclaration d’une méthode (symilaire au C)
type nomDeFonction (type param1,…)
{
}
Pas de déclaration sans définition ( sauf méthode abstract c.f héritage)
Méthode de classe static :
class compte
{
static String nomBanque = "mirab " ;
static bool initialise ()
{
return true;
}
static String getnomBanque()
{
return nomBanque
}
}
Méthode d'instance :
class Compte
{
private float solde;
private boolean testSolde()
{…}
public float getSolde()
{
if (testsolde())
retun solde; //défini après
return 0.0f;
}
}
Autres qualificatifs :
native : indique un code spécifique à une architecture matérielle (C/C++)
donc non portable !
synchronised : bloque l'accès à l'objet durant l'opération.
Utile pour garantir les opérations en mode d'exécution concurrente.
Pas de fonction globale mais fonction de classe :
class A
{
public static float puiss_n(float x, int n)
{
float puiss = 1.0f;
for ( ; n > 0; -- n)
puiss *= x;
return puiss;
}
Appel :
}
class b
{
static public void main (String args[])
{
A.puiss_n(3.0f, 5);
}
}
Ordre des déclarations quelconque:
class Compte
{
private bool testSolde()
{…}
public float getSolde()
{
if (testSolde())
return solde; //défini après
return 0.0f;
}
private float solde;
Surcharge de méthode :
interdit de surchargé la fonction par type de retour :
public int methodeCoue()
{ retun1 ; }
public boolean methodeCoue() //erreur
{ return true ; }
Constructeur :
méthode spéciale :
appelée pour crée un objet
reprend le nom de la classe par convention
pas de type
Qualificatifs : public, private
Par défaut : constructeur public et sans paramètre qui ne fait que l'allocation
mémoire.
class Compte
{
public Compte()
{ solde = 0.0f; }
public Compte(float solde1)
{ solde = solde1; }
private float solde;
}
Appel d'un constructeur : (new)
class Comptablilite
{
private Compte compte1;
public Comptabilité ()
{ compte1 = new Compte(); }
public Comptabilité (Compte c)
{ compte1 = c; }
}
Destruction des objets :
Réalisée automatiquement par le garbage collector
quand l'objet n'est plus utilisé
pas forcement immédiatement
Le garbage collector appelle la fonction finalize() juste avant de détruire un objet.
Passage de paramètres :
Pour les types de base = par valeur (il faut utiliser une classe conteneur pour les
modifier).
Pour les objets = par référence.
exemple :
class Compte
{
public Compte()
{ reset(this); }
private void reset(Compte c)
{ c.solde = 0.0f; }
private float solde;
}
Contre exemple :
class Compte
{
public Compte()
{
reset(this.solde); //passage par valeur
}
private void reset (float s)
{ s = 0.0f; }
private boolean reset (float s) // erreur
{ s = 0.0f; return true; }
private float solde;
}
Paramètre constant final :
Un paramètre comme une variable locale peut être qualifié de constant
Avec le mot clé final :
public void reset (final Compte c) {}
Un paramètre final ne peut pas être modifié
compte b = new Compte ();
c = b // erreur
Mais l'objet référencer peut être modifié
c.val = b.val; // ok
Classe conteneur :
Pour pouvoir modifier un type de base passé en parmètre.
class DoubleCont // classe conteneur
{
public double val = -1.0;
public DoubleCont ()
{}
public DoubleCont (double v)
{ val = v;}
}
class Compte
{
public Compte ()
{
solde = new DoubleCont();
reset (this.solde);
}
private void reset (DoubleCont s)
{ s.val = 0.0; }
private DoubleCont solde ;
}
Les exceptions : interruption de l'exécution du programme (erreur).
try : sert à délimiter un bloc dans lequel une exception peut survenir
try
{ // bloc d'instruction}
catch : associé à try {}, sert à spécifier une action pour un typde d'excepetion donné
catch (TypeException1 e)
{ // instruction gérant l'erreur }
finally : associé à try {}, sert à spécifier une action à effectuer erreur ou pas.
finally
{ //instruction finales }
Exemple :
public Object securedPop (pile p)
{
Object o = null;
try { o = p.pop(); }
catch (IOEception e)
{ System.err.println("Erreur IOException : " + e.getMessage() ); }
finally
{
if (o == null)
system.out.println("objet null!");
return o ;
}
}
throw : génère une exception sous forme d'un objet de type donné, Throwable …
throw objetException;
indique qu'une classe ou méthode est suceptible de générer une exception de type
donné.
class X throws objetExcption;
Exemple Throws :
public Object pop() throws IOException
{
object obj ;
if (size == 0)
throw new IOException();
obj = objectAt (size – 1 );
setObjectAt (size – 1, null);
size -- ;
return obj;
}
Héritage
Hiérarchie des classes :
On peut organiser les classes sous formes de hiérarchie
En Java, une classe peut avoir au plus une classe parente directe.
qualficatif class X extends Y{}
 la X hérite de la classe Y
Une sous classe hérite :
Des paramètres des classes parentes
Des méthodes des classes parentes (super classes)
Elle peut :
Soit redéfinir des méthodes de la classe parente (overload)
Soit les réutiliser et ajouter ses propres paramètres et méthodes.
Exemple :
class Compte
{
private int numero;
public float solde;
public Compte()
{
numero = 0;
solde = 0.0f;
}
public float CalculerSolde ()
{ return solde; }
public void CahngerNumero (int n )
{ numero = n ; }
}
class CompteDepot extends Compte
{
public float operations [];
public int nbop = 0 ;
public CompteDepot () {}
public float CalculerSolde ()
{
for (int i = 0; i < nbop; ++i)
solde += operations [i]
nbop = 0;
return solde;
}
}
Utilité de l'héritage :
Généralement utilisé pour modifier le comportement d'une classe( spécialisation).
Réutilisation de méthodes communes.
Empêche la modification directe de la classe existente.
Héritage versus compostion
Héritage se fait sur des classes partageant des mêmes fonctionalités
(nombreDeroues, nombreDePassager).
Le lien entre des classes sans rapport se fait par simple composition.
 Une classe autobus peut utiliser une classe roue mais pas en hériter !
Constructeur & Héritage :
Lors de la création d'une instance (objet)
les constructeurs de toutes les classes parentes sont appelés,
dans l'orde parent -> enfant.
Constructeur :
On peut rediriger l'appel d'un constructuer vers un autre avec :
this(param, …) pour un constructeur de la même classe.
super(param, …) pour un constrcuteur de la classe parent.
Exemple : Entier
class Entier
{
public int _e;
Entier (int i)
{ _e = i ; }
Entier ()
{ this(0); }
}
class EntierPos extends Entier
{
entierpos(int i )
{
super(i);
if (i>=0)
_e = 0;
}
EntierPos()
{
super(0);
}
}
Appel super() implicite :
class EntierPos extends Entier
{
EntierPos (int i)
{ //super(); implicite
if (i<0)
_e = 0 ;
else
_e = i;
}
EntierPos()
{ super(); }
Conséquences :
Il faut soit :
créer un constructeur sans paramètre dans la super classe.
soit appeler explicitement super(params, …)
dans les constructeurs de la classe.
Autre utilisation de super :
On peut utiliser ce mot clé pour appeler des méthodes de la classe parente directe.
class CompteDepto extends Compte
{
//…
public CompteDepot (int num)
{ super.ChangerNumero(num) ; }
}
Redéfinition de varfiable :
Lorsqu'une variable d'une super classe est redéfinie dans une sous classe en
respectant exactement son nom, elle masque la variable de la super classe.
class Entier
{ public int _e; }
class EntierPos entends Entier
{ public int _e ; }
Exemple : Qualificatifs
class Entier
{
public int e;
protected int f;
private int g;
Entier ()
{
e = 0;
f = 1;
g = 2;
}
}
class EntierPos extends Entier
{
EntierPos()
{
e=0;
f=1;
g = 2; // non! car private !
}
}
Exemple 2 : qualificatifs
class Entier
class Entier
class EntierPos extends Entier
{
{
public int a ()
public int a()
{ return 0; }
{ return 1 ; }
}
}
{
public int e;
prototected int f;
private int g;
Entier ()
{
e=0;
f = 1;
g = 2;
}
}
class Autre // ne dérive donc pas
{
Autre(Entier ent)
{
ent.e = 0;
ent.f = 1; // non car protected = seulement pour les mêmes classes ou parentes
ent.g = 2; // non car private.
Redéfinition d'une méthode :
Lorsqu'une méthode d'une super classe est redéfinie dans une clase en respectant :
son nom, le nombre, l'ordre et les types des paramètres elle remplace la méthode
de la super classe pour les objets de cette sous classe.
Qualificatifs de classe :
qualif.class X [extends super X] {}
Les qualificatifs sont :
final : la classe ne peut être dérivée (pas de sous classe)
abstract : utilisé pour fournir des méthodes et des champs commun à
toutes les classes qui en dérivent.
public : désigne la classe correpsondant au nom de fichier, une seule par
.java
Autre qualificatifs de méthode :
Rappel : public, protected, private, static, native, synchronised
En + :
final : indique que la méthode ne peut pas être redéfinie dans une sous classe.
abstract : défini un modèle de méthode sans corps qui doit être redéfini dans toute
sous classe dérivée.
Utilité des classes abstraites :
Permet de modéliser des concepts qui n'ont pas de sens en termes d'existence.
Exemple de la nourriture (concept abstrait) :
abstract class Food
{
abstract public boolean isFruit();
}
class Carot extends Food
{
public boolean isFruit
{
return true;
}
}
class Apple extends Food
{
public boolean isFruit()
{ return true; }
}
class Chocolate extends Food
{
public boolean isFruit()
{ return false; }
}
Interface & Applet
Interface:
déf : c'est une collection de définition de méthode sans implémentations.
Syntaxe : qualificatif interface I extends J
{}
qualificatifs :
absent : l'inerfeace n'est utilisable que par les classes du même
package.
public : l'interface est utilisable par toutes les classes (1 par fichier)
Interet :
Permet de savoir qu'une classe possède ces méthodes, se comporte de telle
manière.
Relation avec une classe
class C implemets I //,k,…
{ // implémentation de toutes les méthodes de I }
Autre utilisation des interfaces :
Masquage de classe d'implémentation.
Certaine classe java sont cachées derrière une interface commune.
Permet de créer des classe liées à differents système d'exploitation.
Interface vide :
Permet de créer une catégorie de classes :
chaque classe implémentant ce type d'interface appartient à telle ou telle
catégorie.
Pour tester si la classe d'un objet appartient à une catégorie, il suffit
d'utiliser l'opérateur instanceof() avec le nom de l'interface.
ex : interface Cloneable
Déclaration d'un ensemble de constantes : utiliser dans des classes sans liens
d'héritage.
interface ConstatntesCommunes
{ // déclaration des constantes A,B,C
}
class Classe1 extends SuperClasse1 implements ConstantesCommunes
{//les constantes A,B,C sont utilisables dans la Classe1
}
class Classe2 extends SuperClasse2 implements ConstantesCommunes
{//Les constantes A,B,C sont utilisables dans la classe Classe2
}
Exemple d'interface :
public interface appareilElectrique
{ // teste si l'appareil est enclenché
public boolean estEnclenché();
/* on appelle cette méthode lorsqu'on branche l'aapareil dans une source
de courant active (=true) */
public void alimenté(boolean alim);
}
Exemple de classe
Class lampe implements appareilElectrique
{
private boolean allumé = false;
public boolean estEnclenché()
{ return allumée;}
public void alimenté(boolean alim)
{allumée = alim;}
Differences avec les classes abstract
Une interface ne peut définir de variable seulement des constantes.
Une classe ne peut hériter que d'une seule super classe (abstract incluse)
Mais elle peut implémenter plusieurs interfaces.
On peut implementer des méthodes (non abstract) dans une classe abstract,
Aucune implémentation accepetée dans une interface.
Héritage des interfaces :
Attention une classe qui implémente une interface qui hérite d'une super-interface
doit implémenter toutes les méthodes définies dans ces interfaces.
interface A
{ // Déclaration des méthodes de A }
interface B extends A
{//Déclaration des méthodes de B}
class Classe1 implements B
{ // définitions des méthodes de B et A }
Interface comme type d'objet :
Le nom d'une interface peut être utilisé comme type d'objet.
Seules des instances de classes implémentant cette interface peuvent être
assignées à des variables de ce type.
public interface A
{//Déclaration méthodes A }
class ClasseA implements A
{
public void méthode(A objetdetypeA)
{ objetdetypeA = new ClasseA();}
}
Tout objet de type interface X sont garantis d'avoir les méthodes déclarées dans
cette interface X.
public interface A
{public int méthodeA(A objetdetypeA);}
class ClasseA implements A
{
public void méthodeC(A objetdetypeA);
{objetdetypeA.méthodeA();}
public int méthodeA(A objetdetypeA)
{…}
}
Application & Applet
Rappel :
Application :
Programme indépendant
Point d'entrée du programme
public static void main(String [] args)
Applet :
Programme téléchargeable
Executé automatiquement quand ils sont integrés à l'intérieur des pages
HTML.
Applet Java :
La classe d'un applet doit :
dériver de la classe Applet, être public
avoir un constructeur public sans paramètre
public class monApplet exetends Applet
{
public monApplet (){}
}
Pour l'exécution il faut 2 fichiers :
L'exécutable de l'applet : monApplet.class
Le fichier .html qui décri l'applet au navigateur
tag html :
<APPLET CODE =monApplet.class WIDTH=150
HEIGHT=25></APPLET>
Exemple Hello World :
import java.applet.Applet;
import java.awt.Graphics;
public class AppletHelloWorld
extends Applet
{
public void paint(Graphics g)
{ g.drawString("Applet Hello World",20,20);
}
public static void main (String [] args)
{ System.out.println("Applet Hello World");
}
Syntaxe complète des tag html
<APPLET CODE=ClasseApplet.class
WIDTH = largeur, HEIGHT = Hauteur
CODEBASE ="répertoire" ALT="marche pas"
NAME="NomApplet"
ALIGN=alignement
ARCHIVE="fichier.jar"> Message HTML pour les clients non
java</applet>