Vous êtes sur la page 1sur 6

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 :

- Comparator :

interface pour définir un ordre de tri naturel pour un objet

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

abstract

la classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite. Une 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.

final

la classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite. Les 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.