Héritage : Relation entre deux classes: La classe B hérite de la classe A :tout objet

de la classe B est un objet de la classe A . C’est une relation non symétrique

super : Le mot-clé « super » permet d’accéder aux méthodes et aux attributs de la

super-classe

Polymorphisme : Une méthode polymorphe est une méthode déclarée dans une
super-classe et redéfinie dans une sous-classe
• Les méthodes « final » ne peuvent pas être redéfinies
Exemple:
ObjectGraphique A= new Cercle(2,3,6);
System.out.println(A. toString( )) ;

méthode abstraite : Une méthode abstraite est une méthode dont on donne la
signature sans décrire l’implémentation
- Le mot-clé « abstract » permet d’indiquer qu’une méthode doit être redéfinie dans
une sous-classe
public abstract nom_methode(params); //pas de code
Abstract indique que la classe ne pourra être instanciée telle quelle. De plus, toutes les méthodes de cette
classe abstract ne sont pas implémentées et devront être redéfinies par des méthodes complètes dans ses
sous-classes.

classe abstraite : Une classe abstraite est une classe qui contient au moins une
méthode abstraite.
- Une classe abstraite est une classe qui n’est pas faite pour être instanciée, elle est
destinée à être dérivée
public abstract class nom_classe {...}

Utilisation de l’abstraction :
Quand des classes ont une méthode en commun, il est préférable de la placer dans
une classe de base dont ces classes dérivent.
• Si le comportement de cette méthode ne peut être défini dans la classe de base
(l’existence est commune mais pas le code) la méthode est alors déclarée abstraite

Interface : C’est une classe composée d’un ensemble de méthodes abstraites et

de constantes (initialisation obligatoire).

public interface NomInterface {

public nomMeth1 (paramètres) ;
public nomMeth2 (paramètres) ;
…
}
•Les classes qui implémentent une interface ,doivent obligatoirement redéfinir toutes
les méthodes de cet interface

public class UneClasse implements uneInterface

•Une classe peut simultanément dériver et implementer (la dérivation est indiquée
avant l’implémentation).

Les exceptions : Les exceptions sont des objets particuliers qui définissent une
situation particulière ou d'erreur qui sont générés par des méthodes ou par la
machine virtuelle Java et qu'il convient de traiter.
•Le fait de gérer les exceptions s'appelle aussi « la capture d'exception »
•Le mécanisme des exceptions Java permet de traiter les erreurs d’éxécution

Lorsqu'une exception est levée, il y a deux possibilités pour le programme:

• Il capture l'exception et la traite (mot-clés try/catch ) ;
• Il propage l'exception (mot-clé throws ) ;

clause finally : La clause finally définit un bloc qui sera toujours exécuté, qu'une
exception soit levée ou non.
public static void main(String[] args) {
try {
System.out.println(20/0);
} catch (ArithmeticException e) {
System.out.println("Division par zéro !");
}
finally{
System.out.println("action faite systématiquement"); }}

Les classes « Wrapper » : Les wrappers sont des classes prédéfinies qui sont
de simples enveloppes permettant de donner un look objet aux types primitifs. Elles
se trouvent dans le paquetage java.lang.

Les collections : Les collections sont des objets qui permettent de gérer des
ensembles d'objets
• Chaque objet contenu dans une collection est appelé un élément.

•Les interfaces à utiliser par des objets qui gèrent des collections sont :
Collection : interface qui est implémentée par la plupart des objets qui gèrent des
collections

Map : interface qui définit des méthodes pour des objets qui gèrent des collections
sous la forme clé/valeur

Set : interface pour des objets qui n'autorisent pas la gestion des doublons dans
l'ensemble
List : interface pour des objets qui autorisent la gestion des doublons et un accès
direct à un élément

SortedSet : interface qui étend l'interface Set et permet d'ordonner l'ensemble

SortedMap : étend l'interface Map et permet d'ordonner l'ensemble

•Le framework propose plusieurs objets qui implémentent ces interfaces :

Vector: qui implémente l'interface List
HashTable : qui implémente l'interface Set
TreeSet : arbre qui implémente l'interface SortedSet
ArrayList : tableau dynamique qui implémente l'interface List
LinkedList : liste doublement chaînée (parcours de la liste dans les deux sens) qui
implémente l'interface List

Les énumérations :Une énumération correspond à une liste d’éléments

accessibles séquentiellement.
•Une énumération est définie par l’interface « java.util.Enumeration » et propose les
deux opérations suivantes :
-boolean hasMoreElements(): retourne « true » si l’énumération comporte encore des
éléments.
-Object nextElement(): récupère l’élément suivant de l’énumération.

Vector :Parmi les méthodes proposées par cette classe on a :

–void addElement( Object obj ) : ajoute un nouvel élément au vecteur.

–int size() : retourne le nombre d’éléments du vecteur

–Object elementAt( int index ) : retourne l’élément demandé.

–void removeAllEmements() : supprime tous les éléments.

–void removeElementAt( in index ) : supprime un élément à un index du

vecteur

–Object lastElement() : retourne le dernier élément du vecteur.

–Enumeration elements() : retourne l’ensemble des éléments du vecteur

Hashtable : Une table hash codée est mise en oeuvre par l’intermédiaire de la
classe « java.util.Hashtable ».
•Une table hash permet d’insérer des éléments dans un tableau en fonction d’une
clef. Pour récupérer l'élément on doit fournir la clef.

•Les éléments et les clefs sont du type « java.lang.Object ».

Les méthodes de java.util.Hashtable :

• void clear() : supprime tous les éléments de la table,

•Enumeration elements() : retourne sous forme d’une énumération tous les éléments
de la table,

•Enumeration keys() : retourne cette fois ci toutes les clefs,

•Object put( Object key, Object value ) : ajoute un élément dans la table

•Object get( Object key ) : récupère un élément de la table,

•int size() : nombre d ’éléments dans la table,

•Object remove( Object key ) : supprime un élément.

La classe Collections :
Les fonctions de cette classe:
•Trier:
- sort(List list) ; trie une liste.
-sort(List list,Comparator comp) ; trie une liste en utilisant un comparateur.

•Inverser :
- reverse(List liste) ; inverse les éléments de la liste .
•Mélanger:
-shuffle(List liste) ; mélange les éléments de manière aléatoire

•Rechercher :
binarySearch(List list, Object element) ; une recherche binaire d'un élément.
binarySearch(List list, Object element, Comparator comp) ; une recherche d'un élément en
utilisant un Comparator.
•Minimum et maximum :
-min(List); min(List,Comparator).
- max(List); max(List,Comparator).

• Le framework définit aussi des interfaces pour faciliter le parcours des collections et leur tri
- Comparable : interface pour définir un ordre de tri naturel pour un objet
- Comparator : interface pour définir un ordre de tri quelconque

Interface Comparable Elle propose une méthode :

int compareTo(Object o)
Elle doit renvoyer :
• <0 si this est inférieur à o
• ==0 si this est égal à o
• >0 si this est supérieur à o

Quelle est la différence entre == et equals sur les String en Java ?

Différence entre le type valeur et référence, == teste l'égalité des emplacements mémoire
(pointeur), tandis que equals teste l'égalité sur la valeur (comparaison de chaîne de
caractères).

Class : Une classe est le support de l'encapsulation : c'est un ensemble de données et de

fonctions regroupées dans une même entité. Une classe est une description abstraite d'un
objet. Les fonctions qui opèrent sur les données sont appelées des méthodes. Instancier une
classe consiste à créer un objet sur son modèle. Entre classe et objet il y a, en quelque
sorte, le même rapport qu'entre type et variable.
La syntaxe de déclaration d'une classe est la suivante

Modificateur Rôle

la classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite. Une
abstract classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui hérite
de cette classe et qui implémente les méthodes nécessaires pour ne plus être abstraite.

la classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite. Les
final
classes déclarées final ne peuvent donc pas avoir de classes filles.

private la classe n'est accessible qu'à partir du fichier où elle est définie

public La classe est accessible partout

Objet : Les objets contiennent des attributs et des méthodes. Les attributs sont des
variables ou des objets nécessaires au fonctionnement de l'objet. En Java, une application
est un objet. La classe est la description d'un objet. Un objet est une instance d'une classe.
Pour chaque instance d'une classe, le code est le même, seules les données sont différentes
à chaque objet.

L'encapsulation : consiste à rendre les membres d'un objet plus ou moins visibles pour les
autres objets.

Les 4 niveaux d'encapsulation de Java sont par ordre de visibilité croissante :

– un membre privé (private) n'est visible que dans les instances directes de la classe où il est déclaré.
– un membre sans modifieur est visible uniquement dans les instances directes de la classe où il est
déclaré et dans celles des classes du même paquetage.

– un membre protégé (protected) n'est visible que dans les instances, directes ou non, de la classe où
il est déclaré (et donc aussi dans les instances des sous-classes) et dans les instances des classes du
même paquetage.

– un membre public (public) est visible par n'importe quel objet.

Une méthode static : est une méthode qui n'agit pas sur des variables d'instance mais uniquement sur
des variables de classe. Ces méthodes peuvent être utilisées sans instancier un objet de la classe. Les méthodes
ainsi définies peuvent être appelées avec la notation classe.methode() au lieu de objet.methode() : la première
forme est fortement recommandée pour éviter toute confusion.

Les constantes : sont définies avec le mot clé final : leur valeur ne peut pas être modifiée une fois
qu'elles sont initialisées.

Le constructeur : La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une
méthode particulière appelée constructeur pour que les variables aient une valeur de départ. Elle n'est
systématiquement invoquée que lors de la création d'un objet.

Le constructeur suit la définition des autres méthodes excepté que son nom doit obligatoirement
correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y avoir d'instruction
return dans un constructeur. On peut surcharger un constructeur.