Les fondements de la programmation en JAVAOlivier Le Cadet JAVA

(1)

1 Olivier Le Cadet - IUT de Vélizy

25/02/22

JAVA

Les fondements de la programmation en JAVA Olivier Le Cadet

IUT Vélizy SRC1

(2)

Références



"Penser en Java", Bruce Heckel



"Java tutorial", de sun.

http://java.sun.com/docs/books/tutorial/



Cours de Miguel Tomasena, université de Chambéry.



Cours de Xavier Hautbois.

(3)

25/02/22 Olivier Le Cadet - IUT de Vélizy 3

I. Généralités sur le langage.

(4)

Historique. Acronymes.



1991 : projet 'Green' (Sun) -> langage Oak.



1994 : création de Java



1996 : Java 1.02 (JDK 1.02 : Java Development Toolkit).



1998 : Java 2 Playground (J2SE 1.2 : Java2 Platform, Standard Edition)



2004 : Java 5 Tiger (J2SE 1.5)

(5)

Caractéristiques

 JVM : Java Virtual Machine

 Indépendant des plateformes, portable

 Mi-interprété, Mi compilé.

 Nombreuses bibliothèques (API) disponibles.

 Multitâche (réalise du multi-threading).

 Distribué

 Robuste. Pas de pointeurs.

 Adapté pour des applications web.

- Assez lent. Gourmand en mémoire.

(6)

Robustesse



Langage fortement typé.



Compilateur contraignant -> conduit à bien programmer.



Pas d'accès direct à la mémoire (pas de pointeurs). Gestion de la mémoire par un

"ramasse-miettes" (garbage collector).



Mécanismes d'exception (

division par 0, accès à une référence null,…

).



Seules les conversions sûres sont automatiques.

(7)

Fonctionnement d'un programme java. La JVM.

 fichier.class

est

identique sous tous les environnements.



l'utilisateur installe la JVM propre à son

système.



Celle-ci interprète le

bytecode (pseudo-code) contenu dans

fichier.class.

(8)

Les outils



http://www.javasoft.com (Site officiel; JDK ->

interpréteurs (java.exe), compilateur (javac.exe), appletviewer.exe…).



IDE : ce sont les environnements de

développement (Integrated Development Environment). Ils facilitent l'écriture des algorithmes.

 IDE Gratuits : Eclipse (http://www.eclipse.org/), NetBeans

 IDE commerciaux : Jbuilder (Borland), Forte (Sun), etc…

(9)

Java est orienté objet

 Dans un programme java, comme nous le verrons, on va définir différents objets (des classes), en leur donnant des attributs qui décrivent leur état, et des méthodes qui

indiquent les actions qu'ils peuvent faire (ex: chat…).

 Ainsi, certains objets déjà définis peuvent être réutilisés: java offre de nombeuses API (bibliothèques) dans lesquelles sont prédéfinis des objets bien utiles (vecteurs, objets pour gérer les entrées-sorties, etc…)

 Java fournit, de base de nombreux packages, c'est-à-dire des ensembles de classes utiles déjà définies. Les Java

Foundation Classes (JFC, à installer, intégrées au kit de développement à partir de java2 -> les SDK contiennent les JFC) contiennent d'autres objets importants.

(10)

II. Types et variables

(11)

25/02/22

Instruction, déclaration.

Instruction :

 Une instruction est une ligne de code; elle se termine par un point-virgule ;

 Les variables sont des lettres qui pourront prendre différentes valeurs, il faut leur associer un type (entier, flottant…). Ce sont des instructions particulières, les déclarations, qui permettent de les définir.

Déclaration :

 La déclaration est obligatoire, précédée du type : _{int i;}

i pourra prendre dans la suite n'importe quelle valeur entière.

 Règles de nommage : lettres et chiffres, _, -,… pas de chiffre en premier. Sensible à la casse.

(12)

Types de données

 Java est fortement typé (typage explicite)

 Java définit différent types de base :

Entiers (byte, short, int, long) : int j= -152; 1,2,4,8 octets Flottants (float, ou double) : float a=13.2; 4 ou 8 octets Caractère (char) : char c='o'; 2 octets

Booléens (boolean) : true, false 1 octet

Les variables d'autres types sont en fait des références vers des objets ou des tableaux.

(13)

conversion de types primitifs (casting)



Conversions implicites :

int i=3;

double x=i; // i est préalablement converti en un double.



Conversions explicites : cast.

int i=3;

double x=1.333;

i=(int) x; // i prend la valeur 1.

(14)

Les nombres

Opérateurs numériques :

Affectation : =

 Calcul : + - * /

 Combiné : += -= *= /=

 Modulo : %

 Comparaison : == < <= > >= !=

 Incrémentation/décrémentation : ++ --

 Piège1 : ne SURTOUT pas confondre = et == !!

Exemple :

int a = 1;

a++;

(15)

25/02/22

Tests et boucles

Pour comparer, ou répéter plusieurs fois (i est alors le compteur).

Piège2 : ne pas oublier les parenthèses if ( … )

for (i=0;i<100; i++){ if (a>10){

. . . . . . } }

else{

switch(var){ . . .

case 'a' : . . . }

break;

default: . . .

break; while (i<100){

} . . .

}

(16)

Exercices

1.

Que valent a et b après les trois instructions :

a=1;

b=2+a;

a+=b;

2.

Ecrivez un bout de code, qui en fonction de la valeur d'une variable jour (entier compris entre 1 et 7) affiche le jour de la semaine.

3.

Faites afficher la table de multiplication par 7.

(17)

III. Les tableaux, les chaînes

de caractères.

(18)

Tableaux: initialisation, déclaration.

 Initialisation :

int tab[] = new int[10]; // 1 dimension, 10 places int[] tab = new int[10];

int[] tab2 = {1,2,3,4,5,6,0};

int[][] tab3 ={{8,1},{4},{1,-3,2}};

 Accès aux éléments

tab[0]=3;tab[1]=2; // On définit les 2 premiers élmts de tab

tab3[0][0]=2; // On remplace le 8 par un 2

 Pièges : un tableau commence à l'indice 0! La

longueur n'est pas dynamique, on l'obtient ainsi: int longueur=tab.length;

(19)

Tableaux : un exemple

public class Moyenne{

public static void main(String[] args){

float moy=0;

int tab[]={8, 12, 14.4, 2};

for (int i=0; i<tab.length;i++){

moy+=tab[i];

}

moy/=4;

System.out.println("moyenne :"+ moy);

} }

(20)

Les chaînes de caractères

 En java, c'est un objet défini :

 par la classe String (chaînes constantes)

 StringBuffer pour des chaînes variables.

 String s="abc"; //String s =new String("abc");

 L'opérateur + permet de concaténer des chaînes :

int i=1; String s="abc"+i;

 La classe String définit des méthodes (passer en minuscules, compter le nombre de lettres,

comparer…). Exemple :

String s="ABC".toLowerCase();

(21)

IV. Les classes

(22)

Les classes

 En java, tout le code est inclus dans des classes. "Tout est classe en java".

 Les classes représentent des objets, caractérisés par un état actuel (les attributs) et des actions qu'ils peuvent effectuer (méthodes).

class Chat{

int nombrePattes=4;

String couleurPoil;

void manger(){…} // Instructions indiquant à un chat quoi faire pour manger void miauler(){…}

}

Attributs

Méthodes

(23)

Les attributs

 Ce sont des variables caractérisant l'objet décrit par la classe.

 Syntaxe : <modificateur d'accès><type><nom>

 Exemples : private String nom;

public int nombrePattes;

 Les modificateurs d'accès indiquent la visibilité des attributs ou des méthodes qu'ils caractérisent (voir plus loin).

(24)

Les méthodes

 Ce sont des fonctions, définissant les actions que peut accomplir l'objet décrit par la classe.

 Une fonction prend en entrée certains paramètres, les

arguments, les traite, et retourne une valeur de sortie (qui peut être un tableau). Pour retourner une valeur, on utilise le mot clé return.

 Si une fonction ne retourne rien le type de retour est void.

 Syntaxe :

}

(25)

Portée des variables

 Passage par valeur : Les paramètres d'entrée d'une méthode sont copiés puis on utilise à l'intérieur de la méthode cette copie. Les paramètres d'entrée ne

sont donc pas modifiés en sortie.

 Variable locale : une variable déclarée dans un bloc d'instruction (dans des accolades { .. }) n'est connue que dans ce bloc.

 Donc, une variable déclarée dans une méthode n'est connue que dans cette méthode.

 Variable globale :Une variable définie en dehors de toute méthode ou de tout bloc d'instruction est visible dans toute la classe qui la contient.

(26)

Exemples de méthodes

 Exemple 1 :

private String presenteToi(String nom){

return "Je m'appelle "+nom+".";

}

 Exemple 2 :

public double calculePerimetre(double rayon){

return 2*Math.PI*rayon;

}

 Exemple 3 : définissez une méthode qui inverse les deux éléments d'un tableau à deux cases (Entrée? Sortie?

Prototype de la méthode?).

(27)

Utilisation d'une classe

 Une fois notre classe créée, comment l'utiliser?

 La classe Chat définit le comportement général de tous les chats : si l'on veut créer un chat en particulier il faut créer une instance de la classe avec l'opérateur new.

Chat C1; Chat C2; // rien n'a été crée. C1 et C2 seront des chats.

C1=new Chat(); // C'est là qu'est créé une instance de chat.

 Ce qui suit l'opérateur new, c'est le nom d'une méthode particulière, qui a le même nom que la classe : c'est le constructeur.

 Le constructeur est la méthode qui est appelée lors de la création d'un objet par l'opérateur new.

(28)

Constructeurs

 Surcharge : Il peut y avoir plusieurs constructeurs avec un nombre d'arguments

différents

 Chat() construit un Chat.

Chat(String nom) construit un chat qui a déjà un nom.

 Un constructeur doit porter le même nom que la classe.

 Un constructeur ne retourne aucun type (on n'utilise pas void non plus).

(29)

Un autre exemple : cercle (fichier Cercle.java).

public class Cercle{

private double x,y; // Le centre private double rayon; // Le rayon // méthodes

public double perimetre(){

return 2*Math.PI*rayon;

}

public void affiche(){

System.out.println("Cercle de centre ( "+x+" , "+y+")"+"et de rayon "+rayon);

}

public Cercle(){

rayon=1;

}

public Cercle(double x0, double y0, double r){

x=x0;y=y0;rayon=r;

}

} // Fin de la classe Cercle

(30)

Instanciation de la classe Cercle



Un autre constructeur possible:

public Cercle(double rayon){this.rayon=rayon};



Le mot clé this représente, au moment de

l'exécution, l'objet courant. Rayon de ce cercle.

Cercle C1=new Cercle(8.0); // C1 de rayon 8 Cercle C2=new Cercle(1.0, 1.0, 2.0);

// C2 de centre (1,1) et de rayon 2

(31)

Accès aux attributs et aux méthodes d'une classe.



Syntaxe :

monObjet.attribut

monObjet.maMethode(paramètres)



Exemples : Cercle1=new Cercle(1.0, 1.0, 2.0);

Cercle1.x=1.0; Impossible ici car x est private!

double perimetre=Cercle1.perimetre();

(32)

Encapsulation ; visibilité des méthodes et attributs.



Certains attributs, certaines méthodes d'une

classe n'ont pas à être connues d'un utilisateur

=> il faut les rendre inaccessibles.



Quatre niveaux de protection :

private, protected, public, package.

 double diametre=2*Cercle1.rayon;

impossible car

rayon

est private. Il faut créer une méthode

getRayon()

publique permettant d'obtenir le rayon :

double diametre=2*Cercle1.getRayon();

(33)

Encapsulation; les 4 niveaux de

protection.

(34)

Démarrage d'un programme java



Démarrage d'une applet java :

 Le navigateur repère la balise <applet> et créé une instance de l'applet.

 puis l'initialise (méthode _init())

 puis la démarre (méthode _start())



Démarrage d'une application java :

 Une des classes doit posséder une méthode _main

 public static void main(String args[])

 On appelle la machine virtuelle java (java) en lui donnant le nom de la classe qui contient le _main.

(35)

Un exemple

 fichier Cercle.java

public class Cercle{ .. voir avant .. }

 fichier Test.java

public class Test{

public static void main(String args[]){

Cercle C1=new Cercle (-1.0,1.0,2.0);

C1.affiche();

} }

(36)

Le mot clé _static

 Caractérise les attributs ou les méthodes (ou des classes).

 Un attribut ou une méthode statique n'a pas besoin d'être instancié pour être utilisé.

 Exemple :

public class Personne{

public static String nom="Dupont";

}

On accèdera à nom en faisant Personne.nom

et non Personne P1=new Personne(); puis P1.nom

(37)

Le mot clé _final



Caractérise des attributs ou des méthodes (ou des classes).



Permet de définir cet attribut ou cette méthode comme étant constante : impossible de

changer la valeur d'un objet déclaré comme final.

 public final double RAYON_MAX=100;



Par convention, les constantes sont écrites en

majuscule.

(38)

Conventions de programmation

 Les constantes en majuscules

 Première lettre du nom de la classe : en majuscule (class Chat{..} et non class chat{..})

 Nom de variables : première lettre en minuscule. S'il y a plusieurs mots, les premières lettres des mots suivants sont en majuscule. Ex: Chat monChat;

int monEntierPositif;

 Bien indenter le code : ce qui est dans une même boucle est mis en retrait par rapport au reste du

code.

(39)

V. L'héritage

(40)

L'héritage. _extends

 Certains objets sont des cas particuliers, des sous- catégorie, d'un autre type d'objet. Un carré est un rectangle. Un chat est un animal.

 Plutôt que de réécrire entièrement une classe Chat si l'on dispose déjà d'une classe Animal, on peut en

hériter. Seul ce qui caractérise un chat devra être réécrit.

 public class Chat extends Animal{ … }

 Une sous-classe (ou classe fille) hérite des attributs et méthodes de sa classe mère (aussi appelée

parfois super-classe).

(41)

L'héritage.

 Intérêt :

 Il n'y a pas tout à réécrire : on utilise le code des classes parents.

 Supprime des redondances dans le code.

 Permet de structurer logiquement son code.

 Attention : pas d'héritage multiple en java. Une classe a une seule classe mère.

 Redéfinition : on peut redéfinir les méthodes de la classe mère, qui sont alors masquées.

 Object : toutes les classes héritent d'une classe

Object définie dans _java.lang

(42)

Héritage – exemple (classe mère)

public class Animal{

private String nom;

private int nombrePattes;

private String categorie; //mammifère, reptile,..

public Animal(String nom, String categorie){

this.nom=nom; this.categorie=categorie;

}

public Animal(String nom){

this.nom=nom; this.categorie="indeterminé";

}

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

public String getNom(){ return this.nom;}

public String getCategorie(){ return this.categorie;}

public void parler(){System.out.println("groumph");}

public String toString(){return "Catégorie: "

(43)

Héritage – la classe fille

public class Chat extends^Animal{

private String couleurPoil;

public Chat(String couleur, String nom){

super(nom, "mammifère");//super appelle le constructeur parent

this.couleurPoil=couleur;

}

public Chat(String nom){

super(nom);

}

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

public void parler(){System.out.println("miaou");}

public String toString(){return "Catégorie: "

+this.getCategorie()+" nom: "+this.getNom();}

}

(44)

Héritage : la classe de test

class Essai{

public static void main(String[] args){

Chat C1=new Chat("roux", "kochka");

System.out.println(C1.toString());

C1.setNom("liloo");

System.out.println(C1.toString());

} }

(45)

Le mot clé ^super

 Dans le constructeur :permet d'appeler le constructeur parent.

public Chat(String couleur, String nom){

super(nom, "mammifère");//super appelle le constructeur parent

this.couleurPoil=couleur;

}

 Dans une méthode : permet d'appeler une méthode telle qu'elle est définie dans la classe mère.

public String toString(){

return super.toString()+ " couleur de poil : "+couleurPoil;

}

(46)

Constructeurs fils.Règles

d'utilisation de super() et de this()



Les constructeurs ne sont pas hérités!

 super()

passe la main au constructeur de la classe mère.



L'appel

super()

doit être la première instruction du constructeur.

 this()

passe la main à un autre constructeur de la classe considéré. Cela doit être la

première instruction.

(47)

Polymorphisme



Un chat défini par la classe Chat peut, si

besoin, être considéré comme un animal défini par Animal => polymorphisme.



a est dans l'exemple un animal mais aussi un chat: (Chat)a permet de l'utiliser comme Chat.

Chat c1=new Chat("kochka", "blanc");

Animal a=c1;

// Utilisation du polymorphisme

System.out.println(a.toString());

System.out.println(a.getPoil()); // ERREUR //getPoil() pas défini pour un animal.

System.out.println(((Chat)a).getPoil()); //OK

//On indique ici que a doit être regardé comme un chat

(48)

Polymorphisme



Un chat peut être considéré comme un animal (plus général), mais un animal ne peut pas

être considéré comme un chat.

Chat C=new Animal("miaou"); // ERREUR

// On ne peut convertir un animal en chat



Lors de l'exécution, si deux méthodes existent, c'est la plus spécifique qui est exécutée (cf

toString() de l'exemple).

(49)

Classes abstraites. _abstract

 public abstract class ClasseAbstraite{ . . . }

 Une classe abstraite définit le prototype de certaines méthodes abstraites (type des paramètres d'entrée et de retour, nom des méthodes), ma is pas leur

implémentation. Une classe qui contient des méthodes abstraites doit être abstraite.

 Cette classe ne peut pas être instancié.

 Elle doit être héritée. Les classes filles doivent

implémenter les méthodes abstraites de la classe abstraite (sinon elle est abstraite également).

(50)

Les interfaces

 Pas d'héritage multiple en java (une seule classe mère).

 Les interfaces permettent de contourner le problème.

 Définies avec le mot clef _interface au lieu de _class.

 caractéristiques :

 On définit les méthodes de l'interface mais pas leur code (comme pour les classes abstraites).

 Les méthodes doivent être public

 Tous les attributs doivent être public et static.

 Une interface peut hériter d'un nombre quelconque d'interfaces. interface C extends A, B { . . . }

(51)

Relations classes-interfaces



Une interface ne peut hériter d'une classe, mais une classe peut implanter (

_implements

) une

interface.

 public class A implements I1, I2, I3 { ... }

 La classe doit alors implémenter toutes les méthodes définies dans l'interface. "Contrat" à

remplir. Définit un fonctionnement commun à toutes les classes qui implémentent l'interface.

 Une classe peut implémenter un nombre quelconque d'interfaces.

(52)

Un exemple (de "penser en java")

 import java.util.*;

interface CanFight { void fight();

}

interface CanSwim { void swim();

}

interface CanFly { void fly();

}

class ActionCharacter {

public void fight() {. . .}

}

class Hero extends ActionCharacter

implements CanFight, CanSwim, CanFly { public void swim() {. . .}

public void fly() {. . .}

}

(53)

Interface : exemple (fin)

 public class Adventure {

static void t(CanFight x) { x.fight(); } static void u(CanSwim x) { x.swim(); } static void v(CanFly x) { x.fly(); }

static void w(ActionCharacter x) { x.fight(); } public static void main(String[] args) {

Hero h = new Hero();

t(h); // Le traite comme un CanFight u(h); // Le traite comme un CanSwim v(h); // Le traite comme un CanFly

w(h); // Le traite comme un ActionCharacter }}

 Ainsi, grâce au polymorphisme de java, un héros peut être considéré comme ActionCharacter, comme CanFly

(entité pouvant voler), comme CanSwim, ou comme CanFight selon les besoins.

 Oblige l'utilisateur de l'interface à implémenter les méthodes de l'interface, et donc à se conformer à un certain type de fonctionnement.

(54)

VI. Les exceptions

(55)

Les exceptions



Lors de l'exécution d'un programme, il existe parfois des situations exceptionnelles à gérer:

 Dépassements de tableau

 Divisions par zéro

 Accès aux fichiers



On peut alors :

 Ne rien faire

 Interrompre l'exécution normale, traiter le problème (gérer l'exception) et reprendre l'exécution.

(56)

Les exceptions

 Certaines exceptions sont lancées lors d'événements

inattendus : / par 0 (ArithmeticException), dépassement de tableau (IndexOutOfBoundException),…

 Les exceptions dérivent toutes de la classe throwable

(57)

Capture des exceptions

try{

// … Code où une exception risque d'être levée }

catch (Exception e){

// … Instructions à exécuter en cas d'erreurs // (l'exception a effectivement été levée)

}

finaly{

// Optionnel. Instructions exécutés dans tous les cas.

}

(58)

Exemple

class TestException{

public static void main (String args[]){

try{

int tab[]=new int[3];

tab[1]=1; tab[2]=2; tab[3]=4;

}

catch (ArrayIndexOutOfBoundsException e){

System.out.println("Dépassement d'indice!");

} }

}

(59)

relayer ( _throws ) et lever ( _throw ) une exception



Il est possible de relayer, sans la traiter, une exception (

throws

) :

 void maMethode throws IOException{ . . . }

 L'exception, si elle survient, est alors transmise, elle peut-être traitée plus tard.



Il est possible de définir une nouvelle exception puis de la lever :

 public class MonException extends Exception{

public Strig toString(){return("mon problème")}

}

 if (machin==0) throw new MonException();

(60)

VII. Librairie de classes (l'API)

(61)

Les packages



Ranger les classes en package permet

 De structurer le projet

 Proposer aux utilisateurs un ensemble de classe cohérent (thématique commune)

 Sécurité : renforce le mécanisme de portée.

 Un paquetage contient des classes et des sous- paquetages.

 Un package porte le nom du répertoire qui l'accueille.

Package Regroupement

de classe

(62)

Principaux packages de base

 java.lang : types de base (Object), Threads, Exception… La base.

 java.util : Vector, Hashtable, Date…

 java.applet : gestionnaire d'applets.

 java.awt : interfaces graphiques.

 java.io : entrées/sorties.

 java.net : socket, URL, …

 java.sql : accès aux bases de données.

 …

Gestion des couleurs : java.awt.Color (classe Color du package

(63)

Inclure un package



Définir un package :

package

 package SRC1.grA.tp1; public class .. { … }



Importer un package :

_import

 Accéder à la classe Date du package _java.util :

java.util.Date dateDebut;

 Ou sinon mettre au début du fichier :

import java.util.Date ou import java.util.*

pour importer toutes les classes de _java.util. On peut alors écrire : Date dateDebut;

(64)

package java.lang



Arborescence des classes java :

http://java.sun.com/j2se/1.4.2/docs/api/

 java.lang

contient les classes

Object, Class, Math, System, String, StringBuffer, Thread, Exception, Error

, …

(65)

Classe Object

 C'est la classe d'où dérivent toutes les autres classes.

 Méthodes :

 getClass() : renvoie un objet Class (monObjet.getClass().getName();)

 equals() : comparaison de deux objets (obj1.equals(obj2);)

 finalize() ; appelé lorsque le ramasse-miettes doit récupérer l'emplacement d'un objet.

 clone() : renvoie un second objet identique au premier (q=p.clone();)

(66)

Classe String : quelques méthodes.

 charAt(int) : renvoie le caractère à l'indice spécifié.

 equals(String) : s1.equals(s2) true si s1 et s2 identiques

 indexOf(String) : s1.indexOf(s2) indice de la première occurrence de s2 dans s1.

 length() : s1.length() longueur de s1.

 replace(char,char) : s1.replace('a','b') change tous les a en b dans s1 et renvoie la nouvelle chaîne.

 subString(int,int) : s1.substring(1,3) renvoie la sous- chaîne de s1 comprise entre le 2^ème et le 4^ème caractère.

 trim() : s1.trim() : enlève les espaces blancs en début et fin de chaîne.

(67)

Integer, Float, Double, System…

 parseInt(String) : méthode abstraite de la classe Integer. int i=Integer.parseInt("1") va convertir la

chaîne argument en un entier (type primitif).

 parseFloat(String) : float f=Float.parseFloat("1.1")

 in, out, err : attributs de System. out et err sont des objets PrintStream. in: entrée standard (clavier).

out: sortie standard. err: sortie d'erreur standard.

 println() : méthode de la classe PrintStream.

Affichage.

(68)

Classe Math



Ses attributs et méthodes sont statiques :

Math.PI, Math.E.



Autres méthodes (statiques) :

 sin(double), cos(double), tan(double)

 exp(double), log(double), sqrt(double)

 floor(double) // partie entière inférieure

 pow(double a, double b) // a puissance b

 random()

 round(double), abs(double), etc…

(69)

package java.util: Vector, Random, Date, Calendar…



Vector : collections d'objets (taille dynamique)

 Object addElement(Object) :

v.addElement(monObjet). Ajouter monObjet dans v.

 Object firstElement() : v.firstElement() retourne le premier objet de v.

 int indexOf(Object) :

 void insertElementAt(Object,int) :

 void removeElement(Object) :

 void removeElementAt(int) :

 int size() : v.size() -> taille de v.

 Un vecteur peut stocker des objets de toutes sortes (mais pas de type primitifs : pas de int, utiliser des Integer).