cm informatique : java -...
TRANSCRIPT
CM INFORMATIQUE : JAVA
Chapitre I : Introduction ......................................................................................................... 2
I) Les classes .................................................................................................................................. 2
Chapitre II : Les tableaux ....................................................................................................... 6
I) Tableau à 1 dimension ............................................................................................................. 6
II) Les tableaux à deux dimensions ............................................................................................ 11
Chapitre III : Classes et objets .............................................................................................. 14
I) Rappels .................................................................................................................................... 14
II) Surcharge des méthodes ........................................................................................................ 14
III) Le this ...................................................................................................................................... 15 L'objet courant .............................................................................................................................. 15
Appel de constructeur ................................................................................................................... 16
Objet courant ................................................................................................................................ 16
IV) Les références ......................................................................................................................... 18
V) Les static .................................................................................................................................. 19
VI) Encapsulation des données .................................................................................................... 20
Chapitre IV : Héritage ........................................................................................................... 21
Chapitre V : Les collections ................................................................................................... 24
I) Les vectors ............................................................................................................................... 24
Chapitre VI : Les Exceptions ................................................................................................ 26
Chapitre I : Introduction
Java plus simple que C,C++
pas de pointeurs
Utilisation de Netbeans
Langage objet
Répertoire
Programmes
Fichier java, on compile le programme (permet de corriger les typos)
Ligne de commande : javac____.java
Sur Netbeans : « ampoules rouges » pour savoir ce qui est à corriger
Exécution ligne de commande : java___.
Sur Netbeans : cliquodrome ▶
Seules les classes avec 1 main sont exécutables
Langage Apprendre les règles
Machine virtuelle
Bibliothèque tout est objet, on indique au programme où ils se trouvent
I) Les classes
Netbeans ou éditeur de texte
Windows ou linux
1 classe = 1 fichier : nomclasse.java.
public class nom { signature de la classe
Attributs (variable dans laquelle on va stocker quelque chose)
Constructeur (permet de construire les objets)
Méthode
}
Exemple :
Classe Creation objetL'objet appelle les
méthodes de sa classe
Classe Classe ... Classe Principale
Public class Personne {
String nom,
Personne (string n) {
Nom=n ;
}
void affiche () {
System.out. println (nom) ;
}
public static void main (String a [ ]) {
Personne p = new Personne
(« Rico ») ;
p. affiche ( ) ;
}
}
A l’écran après exécution on
affiche :
Rico
On pourra la mettre dans une
autre classe
≠ Python : on pourra avoir plusieurs constructeurs
Déclaration des variables
type nom ;
↳ existence de la variable entre les { } de sa création variable locales
Types :
- Primitif :
o int = entier
o double = réel
o boolean = booléen
o char = caractère
o == , <, <=, >, >=, != pour comparer les classe il faut faire une méthode
- Les classes :
o De la bibliothèque
o Nos classes
Exemple: int a ;
a = 2
System.out.println(a);
Personne b;
b=new Personne ("rico");
b.affiche ( );
méthode définie dans la classe personne
Chaine de caractères : String
Une classe mais les opérateurs ==,… ont été redéfini.
On peut utiliser System.out.println
Déclaration des méthodes :
typeretour nom (type arg1, type arg2,…)
{
instructions
}
On peut retourner un élément ou rien : void
Exemple void affiche ( ) {
system.out.println ("bonjour");
}
double renvoiereel ( ) {
return 2.5;
}
Déclaration constructeur
Nomdelaclasse (type arg1, type arg2)
{
instructions
}
On peut mettre plusieurs constructeurs il suffit de ne pas mettre les mêmes arguments.
On change le type ou le nombre.
Exemple
public class Exemple {
// attributs
int x, y ,s;
// constructeur
Exemple (int a, int b){
x =a;
y = b;
}
Exemple (int a ) {
x=a;
y=a;
s=0;
}
// méthodes
void affiche ( ) {
System.out.println(x+" "+y+" "+s);
}
void somme( ){
s=x+y;
}
int produit(int p){
return x*y*p;
}
} //classe
public class Principale {
public static void main (String arg[])
{
Exemple e=new Exemple(3,4);
e.affiche( );
e.somme( );
Déclaration
La classe exemple n'est pas exécutable car
elle n'a pas de fonction main.
On crée un objet de type exemple
On fait afficher l'attribut x de l'objet e
3 4 0 ce qu'il va afficher
3 4 7
e.affiche( );
e.produit (2);
System.out.println(e.produit(2));
Exemple b=new Exemple(1);
e.somme( );
e.affiche( );
System.out.println(e.produit(3));
System.out.println(e.produit(3));
} //main
} //class
24
on déclare un nouvel élément b de type
exemple. Il affiche 1 1 2
3
Exemple
Déclarez une classe Cercle avec
º 3 attributs, des réels (2 pour les coordonnées du centre un pour le rayon)
º un constructeur qui prend en paramètre 3 réels
º une méthode affiche
º une méthode main pour appeler les méthodes
public class Cercle {
double x, y, R;
Cercle (double a, double b, double c)
{
x=a;
y=b;
R=c;
}
void affiche () {
System.out.println(x+" "+y+" "+R);
}
public satic void main (String a []) {
Cercle c = new Cercle (3,4,8);
c.affiche( );
} // main
} //class
Chapitre II : Les tableaux
Fonction main
String arg [ ]
Stockage de données
Tableau à 1 dimension , 1 ligne plusieurs colonnes
Tableau 2D
Déclaration
Création
Remplissage
Affiche
I) Tableau à 1 dimension
Parcourt à l'aide d'un entier de 0 à tailledutableau – 1
nomtableau.length renvoie la taille du tableau
length ! accès en lecture
Ex: a
↳ a[0] ↳a[a.length-1]
Déclaration : typedesdonnées nom []
↳ même pour toutes les cases
Ex : int t [];
double a [];
String b [];
On ne peut pas écrire dedans : il faut les
créer
Création : nom = new typededonnées [taille]
On réserve de la place en mémoire
Ex: t = new int [2];
a = new double [3];
b = new String [2];
↳ classe de la bibliothèque
t 0 0
a 0.0 0.0 0.0
b null null
On remplit et on affiche un tableau case par case
Ex :
t[0] = 23;
t[1]=22;
for(int i=0 ; i< t.length; i++)
{
System.out.println (t[i]);
System.out.println
("t["+i+"]"+t[i]);
}
rempli lors de la création
22 23
t[0] 23 t[1] 22
Remplir a avec 0.5, 0.75 et 1 et l'afficher a[0]=0.5
a[1]=0.75
a[2]=1
for (int i=0; i<a.length; i++)
{
System.out.println("a["+i+"]"+a[i]);
}
a[0] 0.5
a[1] 0.75
a[2] 1
Remplir b avec "cours", "td" et l'afficher b[0]="cours";
b[1]="td";
for (int i=0; i<b.length; i++)
{
System.out.println ("b["+i+"]"+b[i]);
}
b[0] cours
b[1] TD On peut déclarer et créer en une seule fois avec le contenu.
Ex:
int t [] = {2,4,5} t 2 4 5
Faire la même chose pour un tableau de réels et un tableau de String double a []={2.5, 3.5, 6};
String b[]={"OK", "TD"};
Remarque : public class maclasse
Déclaration attributs
Constructeur création
intitialisation
Main
On crée un tableau rapidement pour tester
Ex:
public class Remarque
{
int t[];
Remarque(int tab[])
{
t=new int[tab.length];
for (int i=0; i<t.length; i++)
t[i]=tab[i];
}
void affiche ()
{
for (int i=0; i<t.length; i++)
System.out.println(t[i]);
}
public static void main (String
arg[])
{
int temp[] = {1,4,6}:
Remarque q = new Remarque(temp)
q.affiche(à;
} //main
} // class
j=0 j=t.length-1
t
tab
i=0 i=tab.length-1
t.length qui vaut tab.length
1
4
6
Remarque
Si on considère un tableau d'objets. On affiche case par case en appelant la méthode affiche
de la classe de l'objet.
Ex: public class Personne
{
String nom;
String prenom;
Personne (String n, String p) // Personne (classe fermée)
{
nom=n;
prenom=p;
}
void affiche ()
{
System.out.println(nom+prenom);
}
}
public class Maclass
{
Personne t[];
Maclass (Personne tab[])
{
t = new Personne[tab.length];
for (int i =0; i<t.length; i++)
t[i]=tab[i];
}
void affiche()
{
for(int i=0; i<t.length; i++)
t[i].affiche( )
}
} // Classe
Dans une classe principale :
- déclarer une fonction main
- créer 2 personnes
- on crée un objet ma classe contenant ces deux personnes
- afficher l'objet de type Maclasse
public class Principale
{
public static void main (String arg[])
{
Personne a= new Personne("Rahis", "Erwan");
Personne b= new Personne("Nique", "Tarace");
Personne t[]={a,b}
Maclass m = new Maclass(t);
m.affiche();
} //main
} //principale
Type / Nom
de la classe
Maclasse
Ex:
public class Maclasse
{
double tab[];
Maclasse (int n)
{
tab= new double [n];
for (int i=0;i<tab.length;i++)
tab[i]=Math.random();
}
void affiche()
{
for (int i=0; i<tab.length;i++)
Méthode static qui
renvoie un réel
compris entre 0 et 1
Classe de la
bibliothèque
Personne
est dans la classe Personne
dans Maclass
System.out.println(tab[i]);
}
public static void main (String arg [])
{
Maclasse m= new Maclasse(3);
m.affiche();
m.ajoute(2);
m.affiche();
m.supprime();
m.affiche();
} // Main
} //classe
m.tab tableau de réels
avec 3 cases remplies
aléatoirement
Question : On veut écrire une méthode qui ajoute un réel dans le tableau tab. Ce réel sera passé en
paramètre de la méthode
Il faut créer une nouvelle case :
- création d'un tableau temporaire (variable locale : temp) de taille tab.length+1
- on parcourt et on recopie case par case tab dans temp
- On met le réel dans la dernière case de temp
- On recrée tab avec 1 tab de plus
- On recopie temp dans tab case par case
void ajoute (double r)
{
double [] temp= new double [tab.length+1];
for (int i=0; i<tab.length;i++)
temp[i]=tab[i];
temp [temp.length-1]=r;
tab = new double [temp.length];
for (int i=0;i<tab.length;i++)
tab[i]=temp[i];
}
}
Question : Ecrire une méthode qui supprime la dernière case de tab
void supprime ()
{
double [] tempo = new double [tab.length-1];
for (int i=0; i<tab.length-1;i++)
{
tempo [i]=tab [i];
tab = new double [tempo.length];
for (int i=0;i<tab.length;i++)
tab[i]=tempo[i];
}
II) Les tableaux à deux dimensions
Tableau de tableaux
0
j
tab [0].length-1
↓
i
tab.length-1
tab est un tableau 2D :
tab.length nbr de lignes
tab[i].length nbr de colonnes de ième+1 ligne
Le reste du cours est une applicationdes tableaux 1D
Déclaration : type nom [][];
Ex : M = new int[2][3]
s= new String[2][2]
m= new Maclasse [2][1]
0 0 0
0 0 0
null null
null null
null
null
Remplir ou afficher le tableau se faire case par case
2 indices : i = lignes
j = colonnes
One parcourt les lignes i. Pour chaque ligne on parcourt les colonnes j : nom [i][j]
Ex : for (int i = 0; i<M.length;i++)
for (int j = 0;j<M[i].length;j++)
M[i][j] =
(int)(Maths.random()*10)
cast (math random renvoi un entier , on
prend la partie entière)
Création: nom = new type [nbr ligne][nbr colonnes];
Ex: s[0][0]="Java";
s[0][1]="TD";
s[1][0]="cours";
s[1][1]="TP";
Java TD
Cours TP
Ex: m[0][0]= new Maclasse();
m[1][0]= new Maclasse();
Objet dont l'attribut est un tableau réel 1D il y a 2 cases remplies aléatoirement
Ex :
Afficher M for (int i=0;i<M.length;i++){
for (int j=0;j<M[i]length;j++){
System.out.print(M[i][j]);
}
System.out.println();
}
Ex:
Afficher s for (int i=0;i<s.length;i++){
for (int j=0;j<s[i]length;j++){
System.out.print(s[i][j]);
}
System.out.println();
}
Ex:
Afficher m for (int i=0;i<m.length;i++){
for (int j=0;j<m[i]length;j++){
m[i][j].affiche(); de type Maclasse
}
System.out.println();
}
Ex:
0 0
1 1 1
2
int[ ][ ] t = new int [3][ ];
t[0] = new int [2];
for (int j=0;t[0].length;j++)
t[0][j]=0;
t[1]= new int [3];
for (int j=0; j<t[1].length;j++)
t[1][j]=1;
t[2]= new int [1];
t[2][0]=2;
en une seule fois :
int t [][]={{0,0},{1,1,1},{2}};
Maclasse m[][]={{new Maclasse(2)};
{new Maclasse(3), new Maclasse(1)}};
Chapitre III : Classes et objets
I) Rappels
Constructeur
Méthode Création d'objets
initialiser
créer les attributs
nomdelaclasse (paramètres){
On peut définir plusieurs constructeurs
Objet new
Déclaration type nom;
Création new constructeur (paramètres)
Après la déclaration l'objet n'existe pas
TP tableaudePoints
Point t[]
créer t
créer t[i] pour toutes les cases
Pour les cases t[i] on appelle le constructeur Point
Un objet peut appeler les méthodes de sa classe
System.out.print
System.out.println
types primitifs
Double, int, boolean, char
String
Sinon on fait une méthode affiche
II) Surcharge des méthodes
On peut définir plusieurs méthodes avec le même nom. On change les arguments en type en
nombre.
Lors de l'appel la méthode est choisie en fonction des paramètres donnés. (Héritage (plus
tard))
Ex : class Point {
double x,y;
Point (double a, double b){
x=a;
y=b;
}
Méthode qui calcule la distane entre le point courant (point qui appelera la méthode) et
l'origine.
double distance ( ) {
return Math.sqrt (x*x+y*y);
}
Méthode qui calcule la distance entre le point courant et un Point passé en paramètre.
double distance (Point p){
return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
}
↱ pas d'objet courant
public static void main (String a []){
Point p= new Point (0,1);
System.out.println(p.distance());
Point q = new Point(1,1);
System.out.println(p.distance(q));
}
} //Classe
Dans la classe String
boolean equals (String)
retourne true si les 2 string sont égaux et false sinon.
Dans la classe Point on va surcharger la méthode equals. boolean equals (Point p){
return ((x==P.x)&&(y==P.y)); entre type primitif
↳boolean ↳boolean
}
III) Le this
L'objet courant
- constructeur
objet qu'on créera à l'appel du constructeur
- méthode
objet qui appellera la méthode
Ex public class Exemple {
double x;
Exemple (double x){
this.x=x;
}
void affiche () {
System.out.println (this.x);
}
Appel de constructeur public class Exemple {
double x;
Exemple (double x){
this.x=x
}
Exemple (){
this(5); j'appelle le constructeur qui prend en paramètre un réel
}
Exo
Créer une classe Personne ayant deux attributs pour le nom et le prénom. Ecrire un
constructeur qui prend deux String en paramètre.
Ecrire un constructeur qui prend une personne en paramètre. Ce constructeur appellera le
précédent.
public class Personne {
String nom;
String prenom;
Personne (String nom, String prenom){
this.nom=nom;
this.prenom=prenom;
}
Personne (Personne P){
this(P.nom,P.prenom)
}
Dans un main appelez ces deux constructeurs.
Exo public static void main (String a[]){
Personne p= new Personne ("Rahis","Erwan");
Personne q= new Personne(p);
}
}
Objet courant
C'est le paramètre d'une méthode appelée
class Point {
int x,y;
Point(int x, int y){
this.x=x;
this.y=y;
}
}// Point
class Cercle {
Point p;
double r;
Cercle (Point p; double r){
this.p= new Point(p.x,p.y);
this.r=r;
}
void ajouter (Figure f)
{
f.setcercle(this);
}
} // Cercle
class Figure {
Cercle c;
Point p;
Figure (Cercle c, Point p){
this.c= new Cercle (c.p, c.r);
this.p= new Point (p.x,p.y);
}
void setcercle (cercle a){
c=a;
}
} // Figure
class Principale {
public static void main (String arg[]){
Point p=new Point (1,1);
Cercle c=new Cercle (p,1);
Point q = new Point (0,1);
Cercle d= new Cercle (q,2);
Figure h= new Figure (c,p);
d.ajouter(h);
}// Main
} // Principale
IV) Les références
class Exemple {
int x;
Exemple (int x){
this.x=x;
}
Exemple copie (){
Exemple temp;
temp = new Exemple (this.x);
return temp;
}
public static void main (String a[]){
Exemple b = new Exemple (2);
Exemple c = new Exemple (3);
System.out.println (b.x +" "+c.x);
b = c;
b.x = 1;
System.out.println (b.x+" "+c.x)
c.x=2;
System.out .println (b.x+" "+c.x);
b= c.copie(); b.x=1;
System.out.println (b.x+" "+c.x)
c.x=2;
System.out .println (b.x+" "+c.x);
2 3
Affectation : b et c sont maintenant le même objet 1 1
2 2
b et c sont 2 objets différents avec même contenu.
Le constructeur est appelé dans la méthode copie.
1 2
1 2
Pb 1: Les tableaux à 1 ou 2 dimensions sont des instances cachées de la classe Arrays
↳Si on a deux tableaux t1 et t2 contenant des données de même type. Si on écrit t1=t2, t1 et t2
désignent de le même tableau.
Pb 2: dans les méthodes la transmission des arguments se fait par référence (affectation).
↳ Toute modification de l'objet passé en paramètre, dans la méthode affecte l'objet initial.
class Maclasse {
void change (int t[]){
for (int i=0;i<t.length;i++){
if (t[i]==1)
t[i]=0;
}
public static void main (String a[]){
int b[]={1,2,1,3};
Maclasse m = new Maclasse (); Constructeur vide par défaut m.change(b);
for (int i=0;i<b.length;i++)
System.out.print(b[i]); 0203
}
}
V) Les static
- attributs
- méthodes Ne dépendent pas de l'objet
On les appelle avec le nom de la classe (quand on est à l'extérieur).
Ex: Math.random()
Integer.parseInt("3")
Classe.méthode
Ex:on va écrire une classe outil où on aura que des méthodes statiques.
Rq : ces classes n'ont pas d'attribut non static public class Outil {
static void multaffecation (double s, double
v[])
{
double temp[];
temp=v;
for (int i=0;i<v.length;i++)
temp[i]=s*v[i];
}
} // Outil
class Principale {
public static void main (String a[])
{
double b[]={1,2,3};
Outil.multaffecation(2,b);
for (int=0;i<c.length;i++)
System.out.print(b[i]);
}}
déclaration d'une
méthode static
Exemple – attributs static class Personne{
String nom;
static int cpt=0;
Personne (String n){
nom=n;
cpt=cpt+1;
}
Public static void main (String a
[])
{
Personne b = new Personne
("Rulliere");
Personne c = new Personne ("Rico";
System.out.println(Personne.cpt);
}
pour indiquer combien
d'objets Personne ont
été crées.
VI) Encapsulation des données
On met des étiquettes pour donner ou non accès aux attributs ou méthode.
public visible de partout, paquetage
private on n'a pas accès en dehors de la classe
protect on a accès dans la classe et dans les classes heritières
Remarque :
Tout ne peut pas être privé
on donne l'accès à l'aide de methode public qui vérifie le bon format des attributs
Ex: class Maclasse{
private int a;
Maclassse (int va){
a=va;
}
void public seta (int v){
a=v;
}
public static void main (String a[])
{
Maclass m= new Maclasse (2);
m.seta(3); Car le a est private
}
}
Chapitre IV : Héritage Toute classe peut hériter d'une autre classe. La classe qui hérite est la classe
dérivée. Elle ajoute des propriétés attributs ou méthodes.
Problèmes :
1) les deux classes ne sont pas dans le même fichier.
2) Constructeur par défaut. Ne prend pas de paramètre il crée un objet vide.
Si le constructeur de la classe 2 n'appelle pas un constructeur de la classe 1, il sera
appelé automatiquement. Il risque de ne plus exister.
B est une sous classe de A.
A est la super classe.
class A{
// attributs
// constructeurs
// méthodes
}
class B extends A {
// attributs
// constructeurs
// méthodes
}
A.java
Possède automatiquement les attributs et méthodes de A
Une classe a au plus une super classe.
Remarque :
Un tableau de complexe est une collection de complexes. "import"
Un complexe de module 1 est un complexe particulier. Héritage
Classe 1
Classe 2
Classe 3
Classe A A.java
Classe B B.java
class personne {
String nom;
Personne (String nom)
{ this.nom=nom;
}
void affiche (){
System.out.println(nom);
}
}
class Etudiant extends Personne {
String filière;
Etudiant (String nom, String filiere)
{
super(nom);
this.filiere=filiere;
}
void affiche (){
super.affiche();
System.out.println(filiere);
}
}// Etudiant
class Principale {
public static void main (String arg[]){
Personne p = new Personne ("Moi");
p.affiche();
Etudiant e= new Etudiant ("Rahis","Erwan");
e.affiche();
}
}
class client {
double t[];
client()
{
t=new double ((int)(Math.random()*20));
for(int i=0; i<t.length;i++){
t[i]=Math.random()*10;;
}
}
double prix () {
double s=0;
for (int i=0; i<t.length;i++)
s=s+t[i];
reutrn s;
}
}//
Le constructeur par défaut
n'existe plus
Appelle le constructeur de la
super classe (mot clé)
on appelle la méthode affiche de
la super classe
Un client fidèle est un client qui a un numéro de client de 20% de remise. Ecrire la classe Clientfidele
class clientfidfele extends Client {
int numero;
clientfidele (int n){
super();
numero=n;
}
double prix (){
double s=0;
s=super.prix()*0.8;
return s;
}
Un magasin est une collection de clients et clients fidèle.
- Créer une classe Magasin
ayant pour attributs un tableau de clients.
ayant un constructeur vide (le tableau est crée mais de taille 0)
- Ecrire une méthode qui ajoute dans le tableau un client passé en paramètre.
- Ecrire une classe Principale contenant le main. Dans ce main créer un lient fidèle et un magasin dont l'attribut
contient ces deux clients.
Remarque : Un client fidèle est un client
class Magasin {
Client t[];
Magasin (){
t= new Client [0];
}
void ajoute (Client c){
Client temp[];
temp=new Client [t.length+1];
for (int i=0;i<t.length;i++)
temp[i]=t[i];
temp[temp.length-1]=c; Affectation différent de copie, on garde
le type
t = new Client [temp.length];
t = temp;
}
class Principale {
public static void main (String a[])
{
Client a= new Client();
Client fidele b= new Clientfidele(1);
Magasin g=new Magasin ();
g.ajoute(a);
g.ajoute(b);
}
}
Rq : ABC (Transitivité)
Chapitre V : Les collections
Stockage dans les tableaux : lourd
Penser à aller voir la javadoc
I) Les vectors ↳ classe de Java
Import
Sous netbeans on vous le propose dès l'appel du constructeur de la classe Vector. On doit
indiquer le type des objets qu'on va stocker dans le constructeur.
Ce type est forcement une classe.
Pour des int on indique Integer
double Double
On peut mettre dans le Vector des objets du type indiqué ou d'un type dérivé (héritage), ou du
type primaire correspondant (s'il existe).
Toutes les classes en Java héritent de la classe Object. On peut faire des Vector d'object. On
fait des sacs de trucs. Quand on récupère il faut indiquer le type.
Tout cela reste vrai pour les autres classes (Arraylist,…)
Déclaration Vector < T >v;
Création v=new vector <T>( );
Exemple Vector <Double>v;
v = new Vector <Double> ( );
v.add(2.5);
v.add(3);
V.elementAt(1);
for (int i=0;i<v.size();i++)
System.out.println(v.elementAt(i));
Type, nom
vecteur de réels
méthode : add (Object) , renvoi un booléen
méthode : size ( ), renvoi un int , nombre
d'élément du vector. Quand on a appelé le
constructeur vide pour la création ce nombre
correspond à la taille du Vector. Les indices vont
de 0 à v.size () -1.
méthode : elementAt (int), renvoi un élément se
trouvant à l'indice passé en paramètre.
méthode : isEmpty(), renvoi un boolean
Exemple class Personne {
String nom;
Personne (String nom){
this.nom=nom;
}
void affiche(){
System.out.println(nom);
}
}
class Etudiant extends Personne {
int num;
Etudiant (String a, int b){
super(a);
num=b;
}
void affiche (){
super.affiche();
System.out.println(num);
}
}
Exemple class CollectionPersonnes { Vector <Personne>c; déclaration d'un vecteur de personne CollectionPersonnes ( ){ Constructeur qui crée le vector vide (on ajoutera plus loin avec une méthode ajoute) c=new Vector <Personne>( );
}
void ajoute (Personne p){ méthode qui ajoute dans c une personne passée en paramètre c.add(p);
}
void affiche( ){ méthode qui affiche le contenu de c for (int i=0; i<c.size();i++)
c.elementAt(i).affiche();
}
}
class Principal {
Chapitre VI : Les Exceptions
Bien lire le cours sur Héritage
Etudiant, Etudiant tricheur, collection : Javadoc
Le but du chapitre est de programmer nous-même des exceptions
Les exceptions se lancent quand une erreur se produit, par exemple lorsque l'on sort d'un tableau à cause
d'un indice trop grand, on divise par 0.
On récupère un message ainsi que la ligne de l'erreur.
Exemple:
La division par 0 class calculatrice {
double a, b ;
calculatrice(double a, double b){
this.a=a ;
this.b=b ;
}
double division () trhows Exception {
if(b==0) { throw new Exception(« division par 0 ») ;}
return a/b ;
}
}
public static void main (String arg[]){
calculatrice c = new calculatrice(2,1) ;
try{
System.out.println(c.division()) ;
}
catch(Exception e){
e.getmessage() ;
e.printStackTrace
}
Si une méthode appelle une méthode lançant une exception, on peut soit :
- relancer l'exception: throws dans la signature de la méthode
- traiter l'exception : try{…} puis catch (Exception e){…}
On doit toujours traiter une exception
On ne peut pas relancer indéfiniment une exception sans la traiter plus tard. Dans le main on sera bloqué (on ne
change pas sa signature) il faudra le try et le catch.
Dans la classe calculatrice, on ajoute une méthode pour afficher le résultat de la division.
Exemple :
Solution n°1 : void afficherresultat()throws Exception{ méthode qui lance une exception
System.out.println(division()) ;
}
Cette méthode sera appelée dans le try du main
Solution n°2 : void afficherresultat(){
try{
System.out.println(division()) ;
}
catch(Exception e){
e.printStackTrace() ;
}
}
Exemple :
- écrire une classe additionvecteur dont l'attribut est un tableau de double à une dimension
- constructeur
- affiche
- méthode qui ajoute à l'attribut un tableau de double passé en paramètre
t
t[0] t[1] t[2] …
u
u[0] u[1] u[2] …
Résultat :
t[0]+u[0] t[1]+u[1] t[2]+u[2] …
Si les deux tableaux n'ont pas la même taille , une exception sera lancée
- Main
class addition vecteur {
double t[] ;
addition(double tab[]){
t = newdouble[tab.length] ;
for(int i=0 ; i<t.length ;i++)
t[i]=tab[i] ;
}
void affiche(){
for(int i=0 ;i<t.length ;i++) ;
System.out.println(t[i]) ;
void ajoute(double u[]) throws Exception {
if(u.length != p.length) throw new Exception(«tailles incompatibles»)
;
for(int i=0 ; i<u.length ;i++)
t[i]+=u[i] ;
}
}
public static void main (String arg[]){
double a[]={1,2,3} ;
double b[]={1,1,1} ;
additionvecteur x = new additionvecteur(a) ;
try{
x.ajoute(b) ;
x.affiche() ;
}
catch(Exception e){
e.printStackTrace() ;
e.getmessage() ;
}
}