Table des matières

Introduction

Au début des années 90, Sun travaillait sur un projet visant à concevoir des logiciels simples et performants exécutés dans des PDA (Personnal Digital Assistant). Le langage C++ a été retenu pour la programmation de ces logiciels, mais le langage C s’est avéré peu performant , notamment en ce qui concerne la sécurité et la facilité d’utilisation. On a donc opté pour un nouveau langage spécifique inspiré du C : le langage Java.

Avec  le langage Java on peut avoir:


  • des applications, sous forme de fenêtre ou de console
  • des applets, qui sont des programmes Java incorporés à des pages web
  • des applications pour appareils mobiles, avec J2ME
  • et bien d’autres ! J2EE, JMF, J3D pour la 3D…

JAVA la Plateforme

Plateforme = environnement hardware et software sur lequel le programme est exécuté.

 Java « Platform » se compose de:

  • Java Virtual Machine (Java VM)
  • Java Application Programming Interface (Java API)

JVM

Une machine virtuelle est un ordinateur fictif s’exécutant sur un ordinateur réel :

  • possède un langage natif propre et traduit un programme écrit dans ce langage vers le langage natif de l’ordinateur.
  • Définit les spécifications hardware de la plateforme
  • Lit le bytecode compilé (indépendant de la plateforme)

La Java Virtual Machine n’est qu’une partie du logiciel Java, liée à l’interaction avec le Web. Elle est incluse dans le téléchargement du logiciel Java et permet l’exécution des applications Java

API: Java Application Programming Interface

L’API Java est structuré en libraires (packages). Les packages comprennent des ensembles fonctionnels de composants (classes).. Le noyau (core) de l’API Java (inclus dans toute implémentation complète de la plateforme Java) comprend notamment :

  • Essentials (data types, objects, string, array, vector, I/O,date,…)
  • Applet §Abstract Windowing Toolkit (AWT)
  • Basic Networking (URL, Socket –TCP or UDP-,IP)
  • Evolved Networking (Remote Method Invocation)
  • Internationalization
  • Security

Exécution d’un programme java

Un programme Java est compilé et interprété !

Etapes de développement

  • On développe, un programme JAVA en utilisant un IDE ou bien n’importe quel éditeur de texte.
  • Afin de pouvoir  créer une application JAVA consistante, on a besoin du JDK.
  • Pour tester et lancer le code écrit, on doit, nécessairement, disposer du JRE.

Hello World (Pré-configuration)

Les bases du langage JAVA

Java est un langage orienter objet ,d’abord nous traitons Java comme un langage de programmation classique. Nous  aborderons les objets ultérieurement.

Dans un programme on trouve deux choses:

  • des données
  • les instructions qui les manipulent

Les données

Pour qu’un programme puisse traiter des informations (Les données), il est nécessaire que ces dernières soient mémorisées dans des variables .

Variable

Quel nom choisir pour notre variable ?

  • Les noms des variables sont case-sensitive
  • Les white space ne sont pas permis
  • Évitez les mots réservés de java
  • Le nom de la variable doit commencer par une lettre miniscule. ( Notation Camel Case. Exemple: age, quantiteStock )

Syntaxe:

type nomVariable [=value];
int id = 0;
les mots réservés de java

Constante

On déclare une constante avec le mot final

final int MAX_STOCK=100;
  • Le nom de la constante doit être en majuscule.
  • Si le nom est composé de plusieurs mots, on utilise _ pour la séparation des mots

Les Types

Les types primitives entiers

Les types primitives reels

Exemple:

float x=1.2f
double y=34.8d

Le type primitives  caractère char

char sexe=‘M’;

Le type primitives boolean

boolean abonne=true;

Le type non primitives chaine de caractère String

String message = ‘’Bonjour les amis’’;

Les variables primitives

Déclaration d’une variable primitive réservation de l’espace mémoire.

Int ram ;
boolean romain;

La valeur affectée à la variable sera stockée dans l’espace mémoire réservé.

ram=18;
disponible =false;

Les operateurs 

Opérateurs arithmétiques

+, -, * : opérateurs arithmétiques
 /  : division entière si les 2 arguments sont des entiers
%  : reste de la division entière 
exemples : 15 / 4 donne 3 15 % 2 donne 1

Opérations sur les entiers

incrémentation ++  & décrémentation  – –   =>  ajoute ou retranche 1 à une variable

int n = 12; 
          n ++; //Maintenant n vaut 13 
                  // « équivalent à » n = n+1;
          n- -; //« équivalent à » n = n-1;
          8++; //  est une instruction illégale 

 !! Peut s’utiliser de manière suffixée : ++n

  • La différence avec la version préfixée se voit quand on les utilisent dans les expressions.
  • En version suffixée la (dé/inc)rémentation s’effectue en premier
int m=7; int n=7; 		
int a=2 * ++m; //a vaut 16, m vaut 8 
int b=2 * n++; //b vaut 14, n vaut 8 

Les opérateurs logiques de comparaisons

  • Égalité : opérateur ==
  • Différence : opérateur !=
  • supérieur et inférieur strictement à : opérateurs > et <
  • supérieur et inférieur ou égal : opérateurs >= et <=

Les opérateurs logiques

  • et logique : &&
  • ou logique : ||
  • non logique : !

Exemples :

boolean a,b, c; 
a= true; 
b= false; 
c= (a && b); // c vaut false 
c= (a || b); // c vaut true 
c= !(a && b); // c vaut true 
c=!a; // c vaut false  
boolean x; 
x= true; 
x= false; 
x= (5==5); // l ’expression (5==5) est évaluée et la valeur est affectée à x qui vaut alors vrai 
x= (5!=4); // x vaut vrai, ici on obtient vrai ,5 est différent de 4 
x= (5>5); // x vaut faux, 5 n'est pas supérieur strictement à 5 
x= (5<=5); // x vaut vrai, 5 est bien inférieur ou égal à 5  

Déclaration des variables

Exemples :

boolean x=true; 
char sexe=‘M’;
int n=12;
float f=1.2f;
double d=34.8d;
String message = ‘’Bonjour les amis’’;

! Declaration d’un tableau : il existent plusieurs méthodes :

int[] tab; 
tab = new int[5]; 
tab[0] = 10; // initialiser le premier élément 
tab[1] = 20; // initialiser le second élément
int[] tab = { 10, 20, 30, 40, 50}; //déclaration + initialisation 

Les valeurs par défaut des variables

TypeValeur par défaut
byte0
short0
int0
long0L
float0.0f
double0.0d
char‘\u0000’
booleanfalse

Instructions et commentaires en JAVA

  • Toute instruction se termine par le caractère ‘;
  • Il existe deux manières d’écrire des commentaires (qui ne doivent donc pas être compilés) dans un texte source :
  • Les commentaires écrits sur plus d’une ligne sont encadrés par les symboles /* et */ ,
  • Les commentaires écrits sur une seule ligne sont précédés des symboles //.

La Class Principale

Tous les programmes Java doivent avoir un point d’entrée, qui est toujours la méthode main (). Chaque fois que le programme est appelé, il exécute automatiquement la méthode main () en premier.

La méthode main () peut apparaître dans toute classe faisant partie d’une application, mais si l’application est un complexe contenant plusieurs fichiers, il est courant de créer une classe séparée juste pour main (). La classe principale peut avoir n’importe quel nom, bien qu’en général elle s’appelle simplement “Main”

public class Test{

	public static void main(String[] args){

		 PcPortable monPcPortable;

		 monPcPortable =new PcPortable();	
	}
} 

Les Structures de Contrôle Conditionnelles

On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vrai ou faux

Structure conditionnelle ( if )

L’instruction if prend pour paramètre une expression booléenne placée obligatoirement entre parenthèses.

  • Si l’expression renvoie true, le bloc d’instructions suivant est exécuté.
  • Si elle renvoie false, le bloc d’instruction suivant est ignoré
if (expression) instruction; 
ou if (expression) {    
instruction 1;    
instruction 2;    
...    
instruction n;
   }

L’instruction else permet de compléter une instruction if lorsque la valeur retournée par l’expression est false

if (expression) {     
bloc d'instructions 1;
} 
else {     
bloc d'instructions 2;
 }

Il est possible d’écrire plus simplement des imbrications successives d’instructions if else

if (expression1) {     
bloc1; 
} else if (expression 2) {
     bloc2; 
} else if (expression3) {
     bloc3;
 } else { 
    bloc4;
 }

 Structure conditionnelle ( switch )

L’instruction switch permet de s’affranchir des branchements else if vu précédemment, dans le cas ou les conditions sont toujours des tests d’égalité sur la même variable. Une grosse contrainte porte sur le paramètre de l’instruction switch : il doit être obligatoirement de type entier (ok pour la version 8). On peut donc uniquement utiliser le switch pour comparer des valeurs entières entre elles.

La structure  switch  permet d’effectuer tel ou tel traitement en fonction de la valeur des conditions 1ou 2 ou ..n .

switch (expression) { 
case valeur 1: d'instructions; break; 
case valeur 2: d'instructions; break; 
. . 
case valeur N: d'instructions; break; 
default: d'instructions par défaut ;
 }

La boucle for

La boucle for est utilisée pour répéter un traitement sous forme de bloc d’instructions un certain nombre de fois en principe connu à l’avance.



L’instruction while

L’instruction while permet d’itérer un bloc d’instructions tant qu’une condition est vérifiée.

Elle présente de plus l’avantage de tester la condition avant la première exécution.

Les instructions break et continue peuvent aussi être utilisées dans les boucles while.

while (expression) {
    instruction1;
    instruction2;
    ...
    instructionn;
}

L’instruction do…while

L’instruction do…while correspond au “repeat” des autres langages. Il correspond au cas ou le traitement doit s’éffectuer au moins une fois et lorsque c’est lui qui détermine l’état de la condition.

do {
    instruction1;
    instruction2;
    ...
    instructionn;
} while (expression);

 Les packages

  • Un package regroupe un ensemble de classes sous un même espace de  ‘nomage’.
  • Les noms des packages suivent le schéma : name.subname …
  • Une classe Watch appartenant au package time.clock doit  se trouver dans le fichier time/clock/Watch.class
  • Les packages permettent au compilateur et à la JVM de localiser les fichier contenant les classes à charger.
  • L’instruction package indique à quel package appartient la ou les classe(s) de l’unité de compilation (le fichier).
  • Les répertoires contenant les packages doivent être présents dans la  variable d’environnement CLASSPATH
  • En dehors du package, les noms des classes sont : packageName.className
  • L’instruction import packageName permet d’utiliser des classes sans les  préfixer par leur nom de package.
  • Les API sont organisées en package  (java.lang, java.io, …)

Classe et objet

un langage orienté-objet

Qu’est-ce qu’un objet ?

Modélise toute entité identifiable, concrète ou abstraite, manipulée par l’application logicielle :

  • une chose tangible ex: ville, véhicule, étudiant, un bouton sur l’écran
  • une chose conceptuelle ex: date, réunion, planning de réservation

Un objet possède :

  • Une identité unique (permet de distinguer un objet d’un autre)
  • Des états interne représentent les caractéristiques de l’objet (Les attributs)
  • Des comportements représentent les opérations qui s’appliquent sur ces états (les méthodes)

Classe et objet Java ?

On appelle classe la structure d’un objet, c’est-à-dire la déclaration de l’ensemble des entités qui composeront un objet.

Un objet est donc « issu » d’une classe, c’est le produit qui sort d’un moule. En réalité on dit qu’un objet est une instanciation d’une classe  
objet = instance

Une classe est composée de deux parties :

  • Les attributs (parfois appelés données membres) : il s’agit des données représentant l’état de l’objet
  • Les méthodes (parfois appelées fonctions membres): il s’agit des opérations applicables aux objets

Déclaration de la classe

public class PcPortable {

/*Déclaration des attributs*/
/*Déclaration des méthodes*/
//commentaire sur une seule ligne
/*commentaires sur 
plusieurs lignes*/


}
  • Le fichier .java doit avoir le même nom que la classe (PcPortable.java)
  • Le nom de la classe doit commencer par une majiscule

Catégories des variables

Il existe deux sortes de variables :

  • Une variable primitive contient des bits qui représentent sa valeur. Exemple : int, foat , boolean.
  • Une variable référence contient des bits qui indiquent comment accéder à l’objet.   Exemple : String, Chien, Joueur,…

Les variables références: String

  • on crée une référence sur une String 
  • Lorsqu’on déclare une variable objet , on est en fait en train de faire la réservation de l’espace mémoire pour la référence

Les variables références: Les tableaux

Déclaration des méthodes

Syntaxe:
    Type_retour nom_method([arguments])     {    }
 Exemple: 
    void afficherInfoPcPortable (){     }

Le nom de la méthode doit commencer par un verbe

Les constructeurs

Pour créer un objet à partir d’une classe, on utilise l’opérateur new.

L’opérateur new fait appel au constructeur de la classe

public class Test{
PcPortable  pc1=new PcPortable();

}  
  • un constructeur porte le même nom que la classe dans laquelle il est défini
  • un constructeur n’a pas de type de retour (même pas void)

Qu’est ce que fait le Le mot-clé this ?

Le mot-clé this permet de désigner l’objet courant, this permet d’accéder aux attributs et méthodes de l’objet courant

  • Pour manipuler un attribut de l’objet courant: this.couleur
  • Pour manipuler une méthode de la super-classe :  this.ajouter_PcPortable (100)
  • Pour faire appel au constructeur de l’objet courant: this()
  • Si vous ne créez pas un constructeur dans votre classe, le compilateur va  automatiquement vous créer un constructeur par défaut implicite.
  • Si le constructeur surchargé est créé, le constructeur par défaut implicite ne sera plus créer par le compilateur
  • La platforme java différencie entre les différents constructeurs déclarés au sein d’une même classe en se basant sur le nombre des paramètres et leurs types.

On ne peut pas créer deux constructeurs ayant le même  types des paramètres.

Chemise(int id) {
		this.id=id
	}
	Chemise(int id) {
		this.id=id*2    //Erreur de compilation

	}

Quel constructeur va choisir Java lorsque vous allez créer votre objet ?

Le Destricteur

le programmeur  java n’a pas à s’occuper lui-même de libérer la mémoire en supprimant les objets devenus inutiles, c’est le rôle du Garbage Collector

Le Garbage Collector est exécuté automatiquement dès que la mémoire disponible devient inférieure à un certain seuil.

Le destructeur est une méthode spéciale qui sera appelée lorsque l’objet sera nettoyé de la mémoire par le Garbage Collector.

Java Destructor finalize()

Notion de référence

Encapsulation

  • L’encapsulation est un pilier de la programmation orientée objet, où chaque classe définit des méthodes ou des propriétés pour interagir avec les données membres, mais ce principe peut se rencontrer dans d’autres styles de programmation (par exemple la programmation modulaire [les packages]).
  • Consiste à ne laisser apparaître d’un code  que ce qui doit être visible de l’extérieur
  • On parle de contrôle d’accès
  • On peut masquer des membres d’une  classe ou des classes d’un package

Les niveaux d’accès

  • Public : un élément public est accessible de partout et  sans aucune restriction.
  • Protected : un élément protected  l’accès aux données est réservé aux fonctions des de la même package  ainsi que les classes héritières, c’est-à-dire par les fonctions membres de la classe ainsi que des classes dérivées
  • 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éthode spécifiques appelés accesseur et  mutateur
  • « Package » : un élément est Package par défaut est  accessible uniquement aux classes d’un package et à ses  classes filles.

Encapsulation des classes



Encapsulation des attributs



Encapsulation des méthodes


  • Dans le but de renforcer le contrôle de l’accès aux variables d’une classe, il est recommandé de les déclarer private.
  • Pour la manipulation des attributs private, on utilise:
    • Un mutateur (setter): est une méthode qui permet de définir la valeur d’une variable particulière
    • Un accesseur (getter): est une méthode qui permet d’obtenir la valeur d’une variable particulière.
  • Le setter et le getter doivent être déclarés public
private float prix;

public void setPrix(float prix){
	this.prix=prix;
}
public float getPrix(){
	return prix;
}
private boolean absent;

public void setAbsent(boolean absent){
	this.absent=absent;
}
public boolean isAbsent(){
	return prix;
}

Static

  • Les variables static sont communes à toutes les  instances de la classe.
  • Il n’est pas nécessaire d’instancier une classe pour  accéder à un de ses membres statiques.
  • Les attributs static sont initialisés par défaut à 0  pour les nombres entiers et réels, à false pour les  booléens et à null pour les références.
  • Les méthodes static sont des fonctions qui  délivrent un résultat indépendamment de tout  objet, elles sont mises (en dehors de leur classe)  en les faisant précéder du nom de la classe les  définissant.

Les attributs static

Utilisation : On invoque les variables static avec le nom de la classe.

class Etudiant{
	String nom;
	static int nbrEtudiants;
	
	Etudiant(String nom){
		this.nom=nom;
		nbrEtudiants++;
	}
}
class Test{
    public static void main(String[] args){

      System.out.println(Etudiant.nbrEtudiants);

    }
}

Les méthodes static

Le comportement d’une méthode statique ne dépend pas de la valeur des variables d’instance

class MaClassMath{
		
	static int  min(int a , int b){
	     if(a<b){
		return a;
	      }else{
		return b;
	      }
	}
}

Utilisation: L’appel à une méthode statique se fait en utilisant le nom de la classe.

class Test {
public static void main ( String [] args ){
	int x = MaClassMath .min (21 ,4);
}
}

Puisque les méthodes static appartiennent à la classe, elles ne peuvent en aucun cas accéder aux variables d’instances qui appartiennent aux instances de la classe.

  • Les méthodes d’instances accèdent aux variables d’instance et méthodes d’instances
  • Les méthodes d’instances accèdent aux variables de classe (static) et méthodes de classe (static)
  • Les méthodes de classe (static) accèdent aux variables de classe (static) et méthodes de classe (static)
  • Les méthodes de classe (static) n’accèdent pas aux variables de d’instance et méthodes d’instance
  • Dans une méthode static on ne peut pas utiliser this

Héritage

  • Duplication de code.
  • Une modification faite sur un attribut (ou méthode) commun doit être refaite dans les autres classes.

Solution:

On place dans la classe mère tous les attributs et toutes les méthodes communs à toutes les classes.

Les classes filles ne comportent que les attributs ou méthodes plus spécifiques.

Les classes filles héritent automatiquement les attributs (et les méthodes) qui n’ont pas besoin d’être ré-écrits.

En Java, on indique qu’une classe hérite d’une autre en utilisant le mot-clé “extends”

class Personne { 

String nom; 
long cin;

public void setNom(String nom){
	this.nom=nom;}

public String getNom(){
	return nom;}

public void setCin(long cin){
	this.cin=cin;}

public long getCin(){
	return cin;}
}
class Etudiant extends Personne { 

float moyenne;

public void setMoyenne(float moyenne){
      this.moyenne=moyenne;}

public float getMoyenne (){
	return moyenne;}
} 

Une classe peut avoir plusieurs sous-classes.

Une classe ne peut avoir qu’une seule classe mère

class Personne { 

private String nom; 
private long cin;

public Presonne(){
	nom=“Mohamed”;
	cin=00000000;
}

}

Redéfinition

class Personne { 

     public void lire() {
	System.out.println(“Je sais lire”);
     }

}
class Etudiant extends Personne { 

 public void lire() {
	System.out.println(“Je suis un étudiant”);
	super.lire();
     }
} 

=> Possibilité de réutiliser le code de la méthode héritée (super)

Surcharge

class Etudiant extends Personne { 

 public void lire(String titreLivre) {
	System.out.println(“Je sais lire”);
	System.out.println(“J’ai lu le livre ”+titreLivre);
     }
} 

On garde la même nom de la méthode, le même type de retour et on change les paramètres => On parle alors de surcharge

La classe Object

  • Toutes les classes java héritent implicitement de la classe Object.
  • On dit alors que la classe Object est l’ancêtre de toutes les classes
  • Méthodes importantes de la classe Object :
    •   public String toString()
    •   public booleanequals (Object)
    •   public final Class getClass()
    •   public inthashcode()

Final attribut / methode / class

  • Le mot clé Java final signifie « Cela ne peut pas  changer ».
  • Vous pourriez vouloir empêcher les changements pour deux raisons :
    • conception
    • efficacité
  • Une constante est utile pour deux raisons: 
    1. Elle peut être une constante lors de la compilation qui ne changera jamais
    2. Elle peut être une valeur initialisée à  l’exécution qu’on ne veut pas changer.
  • Une méthode indiquée comme final ne peut être redéfinie dans une classe dérivée.
public class MaClass { 
public final void uneMethode() { ... }
 } 
  • Les class final ne peuvent être dérivées , Cela peut être fait dans un souci d’efficacité ou pour empêcher l’utilisateur d’en faire une utilisation non appropriée dans la classe dérivée
public final class ClasseFinal { ... } 

Polymorphisme

N’importe quel objet en Java qui peut passer d’une relation « est un » peut être considéré polymorphe. Le polymorphisme est le fait de référencer une classe fille avec un référence déclaré de type une classe mère.

Avec le polymorphisme : le type de la référence peut être la classe mère de l’objet instancié. èOn peut penser à un tableau polymorphique.

Soit : 

Personne [ ] personne = new Personne [3];
  • Déclarer un tableau de type Personne.
  • Un tableau qui contiendra des objets de type Personne.

On peut mettre n’importe quel classe fille de la classe

personne [0] = new Etudiant();
personne [1] = new Employe();
personne [2] = new Chercheur()

Lorsqu’une méthode d’un objet est accédée au travers d’une référence “surclassée” (Personne), c’est la méthode définie au niveau de la classe réelle (Employe) de l’objet qui est invoquée et exécutée

Class abstract

  • La définition d’une classe abstraite est entre la définition d’une classe «normale» et d’une interface
    • Elle déclare un comportement
    • Elle ne définit pas d’’implémentation

Pour définir une classe abstraite, on utilise le mot clé abstract

public abstract class Personne

Méthode abstraite

Une méthode sans implémentation est obligatoirement  abstraite , elle est défini par le mot clé abstract public abstrat void lire();

Une classe dont une méthode est abstraite est  obligatoirement abstraite et est donc défini par le mot clé  abstract.

public abstract class Personne
 { 
 public abstract void lire();
 }

 

Exceptions

L’exception est une erreur qui se produit, soudainement, lors de l’exécution d’un programme

Une exception :

  • est un objet, instance d’une classe d’exception
  • provoque la sortie d’une méthode
  • correspond à un type d’erreur
  • contient des informations sur cette erreur
  • Throwable est la classe de base, à partir de laquelle vont dériver toutes les exceptions.
  • Error: Elle gère les erreurs liées à la machine virtuelle (LinkageError, ThreadDeath etc.)
  • Exception: contient l’ensemble des exceptions gérées par le  Programmeur (ArithmeticException etc.).
  • RunTimeException: regroupe les erreurs de base(Arithmetic, etc.)
  • IOException: regroupe les erreurs entrée/sortie.
  • Error et RunTimeException appartiennent à la catégorie « uncheked » donc “throws” n’est pas nécessaire à coté de la méthode qui lance une exception  de cette catégorie là.
  • Toutes les autres excéptions (y compris donc celles créées par le programmeur) appartiennent à la catégorie des “checked” où   l’utilisation de “throws” est exigée.

Une exception peut être déclenchée de deux façons :

  • Suite à une erreur d’exécution dans le programme JAVA, la JVM génère une exception (RunTimeException) ou bien ( Error)
  • Le développeur peut, à son tour, déclencher une exception au sein de son programme(qui étend la classe Exception).

Exemple:

public class Calcul {
public static void main(String[] args) {
     int x = 20, y = 0 ;
     System.out.println (x / y); //Aucune erreur lors de la compilation
}}

Résultat d’exécution :
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Erreur.main(Erreur.java:4)

Le programmeur peut lever ses propres exceptions à l’aide du mot réservé throw.

throw prend en paramètre un objet instance de Throwable ou d’une de ses sous-classes.

Le mot-clé throw fait partie des mots-clés réservés du langage Java, et il permet de forcer la génération d’une exception, représentée par l’objet qu’on lui passe en paramètre.

throw  new MonException ("Exception personnalisée !!!");

Interface et Collection

Une interface est une collection d’opérations utilisée pour spécifier un service offert par une classe.

Une interface peut être vue comme une classe abstraite sans attributs et dont toutes les opérations sont abstraites.

  • Toutes les méthodes sont abstraites
  • Elles sont implicitement publiques
  • Possibilité de définir des attributs à condition qu’il s’agisse d ’attributs de type primitif
  • Ces attributs sont implicitement déclarés comme static final
import java.awt.*;
public interface Dessinable {
     public void dessiner(Graphics g);
     void effacer(Graphics g);
}

Une classe JAVA peut implémenter simultanément plusieurs interfaces

Pour cela la liste des noms des interfaces à implémenter séparés par des virgules doit suivre le mot clé implements

class RectangleDessinable extends Rectangle implements Dessinable,Comparable {
	public void dessiner(Graphics g){
		g.drawRect((int) x, (int) y, (int) largeur, (int) hauteur);
	}
	public void effacer(Graphics g){
		g.clearRect((int) x, (int) y, (int)largeur, (int) hauteur);
	}
	public int compareTo(Object o) {
		if (o instanceof Rectangle)
		...
	}
}

Interface et polymorphisme

Une interface peut être utilisée comme un type a des variables (références) dont le type est une interface il est possible d’affecter des instances de toute classe implémentant  l’interface, ou toute sous-classe d’une telle classe.

public class Fenetre {
      private nbFigures;
      private Dessinable[] figures;
      ...
      public void ajouter(Dessinable d){
      	...
      }
      public void supprimer(Dessinable o){
      	...
      }
      public void dessiner() {
          for (int i = 0; i < nbFigures; i++)
              figures[i].dessiner(g);
      }
}

Héritage d’interface

  • De la même manière qu’une classe peut avoir des sous-classes, une interface peut avoir des “sous-interfaces”
  • Une sous interface
    • hérite de toutes les méthodes abstraites et des constantes de sa “super-interface”
    • peut définir de nouvelles constantes et méthodes abstraites
  • Une classe qui implémente une interface doit implémenter toutes les méthodes abstraites définies dans l’interface et dans les interfaces dont elle hérite.
interface Set extends Collection
{
...
}

A la différence des classes une interface peut étendre plus d’une interface à la fois

package java.nio;
interface ByteChannel extends ReadableByteChanel, WriteableByteChanel {
}

Les collections

Collection :  objet qui regroupe de multiples éléments dans une seule entité.

Utilisation de collections pour

  • stocker, retrouver et manipuler des données
  • transmettre des données d ’une méthode à une autre.

Exemples :

  • un dossier de courrier : collection de mails
  • un répertoire téléphonique : collection d ’associations noms  numéros de téléphone.

Par exemple, un tableau est une collection. Le JDK fournit d’autres types de collections sous la forme de classes et d’interfaces. Ces classes et interfaces sont dans le paquetage java.util

Des interfaces dans 2 hiérarchies principales :

  • Collection<E>
  • Map<K,V>

Collection correspond aux interfaces des collections proprement dites par contre Map correspond aux collections indexées par des clés ,un élément de type V d’une map est retrouvé rapidement si on connaît sa clé de type K (comme les entrées d’un dictionnaire ou les entrées de l’index d’un livre)



Comme exemple, on va voir les classes  ArrayList et HashMap comme classes  d’implémentation de List et de Map , elles permettront d’introduire des concepts et informations qui sont aussi valables pour les autres classes d’implantation

  • Collections (avec un s final) fournit des méthodes static pour, en particulier,
    • trier une collection
    • faire des recherches rapides dans une collection triée
  • Arrays fournit des méthodes static pour, en particulier,
    • trier
    • faire des recherches rapides dans un tableau trié
    • transformer un tableau en liste

 Exemple de liste

List <String> l = new ArrayList <String>();
	l.add("Pierre Jacques");
	l.add("Pierre Paul");
	l.add("Jacques Pierre");
	l.add("Paul Jacques");
	Collections.sort(l);
	System.out.println(l);

 Exemple de Map

Map <String, Integer> frequences = new HashMap <String, Integer> ();
for (String mot : args) {
	Integer freq = frequences.get(mot);
	if (freq == null)
		freq = 1;
	else
		freq = freq + 1;
	frequences.put(mot, freq);
}
System.out.println(frequences);

Conclusion

Dans la prochaine partie, nous passerons à la logique de programmation,

Que pensez-vous de ce cours ? Donnez-nous votre avis dans un commentaire.

Commentaires

  1. Pingback: Why is processing a sorted array faster than an unsorted array ?

  2. Pingback: Hello World Java Swing example » JavaTuto

Laisser un commentaire