Arnaud Labourel
21 octobre 2019
Dans une classe, plusieurs méthodes peuvent avoir le même nom.
C’est ce qu’on appelle la surcharge de méthode.
Il est par contre nécessaire que la séquence dans l’ordre des types des arguments soit différente pour chaque méthode ayant le même nom.
La méthode est choisie par le compilateur de la façon suivante :
Si les types des arguments ne correspondent pas aux types des paramètres, les types des arguments sont promus en suivant les flèches :
Pour les instances de classe, c’est le type du conteneur à la compilation qui compte.
class Printer {
static void print(Object object) {
System.out.println("Object : "+object);
}
static void print(String string) {
System.out.println("String : "+string);
}
}
String string = "message";
Object object = string;
Printer.print(string); // → String : message
Printer.print(object); // → Object : message
C’est exactement les mêmes règles qui s’appliquent pour les constructeurs d’une classe.
Un programme peut être confronté à une condition exceptionnelle (ou exception) durant son exécution.
Une exception est une situation qui empêche l’exécution normale du programme (elle ne doit pas toujours être considérée comme un bug). Quelques exemples de situations exceptionnelles :
Java propose un mécanisme de gestion des exceptions afin de distinguer l’exécution normale du traitement de celles-ci afin d’en faciliter leur gestion.
En Java, une exception est concrétisée par une instance d’une classe qui étend la classe Exception
.
Pour lever (déclencher) une exception, on utilise le mot-clé throw
:
Pour capturer une exception, on utilise les mots-clés try
et catch
:
ArithmeticException
: opération arithmétique impossible comme la division par 0.IndexOutOfBoundsException
: dépassement d’indice dans un tableau, un vecteur, …NullPointerException
: accès à un attribut/méthodes/case pour les tableaux d’une référence valant null
, argument null
alors que ce n’est pas autorisé.FileNotFoundException
: échec de l’ouverture d’un fichier à partir d’un chemin.IllegalArgumentException
: argument incorrect (en dehors des valeurs autorisées) lors de l’appel d’une méthode.NoSuchElementException
: next
alors que l’itération est finie, dépilement d’une pile vide, …Il suffit d’étendre la classe Exception
(ou une classe qui l’étend) :
Pour capturer une exception, on utilise la syntaxe try
/catch
:
public static void test(int value) {
System.out.print("A ");
try {
System.out.println("B ");
if (value > 12) throw new MyException(value);
System.out.print("C ");
} catch (MyException e) { System.out.println(e); }
System.out.println("D");
}
test(11) |
test(13) |
---|---|
A B | A B |
C D | MyException: Error 13 |
D |
Une méthode doit préciser dans sa signature toutes les exceptions qu’elle peut lever et qu’elle n’a pas traitées avec un bloc try
/catch
:
public static void testValue(int value)
throws MyException {
if (value>12) throw new MyException(value);
}
public static void runTestValue(int value)
throws MyException {
testValue(value);
}
La méthode testValue
peut lever une exception de type MyException
.
runTestValue
doit indiquer qu’elle peut lever une exception car elle ne gère pas l’exception provoquée par l’appel testValue(value)
.
Si aucune des deux propriétés est vérifiée alors il y a une erreur à la compilation.
Error:(YY, XX) java: unreported exception MyException;
must be caught or declared to be thrown
La méthode runTestValue
peut lever une exception (de type MyException
).
Lorsqu’on fait un appel à la méthode runTestValue
, il est vérifié à la compilation que l’une des deux propriétés suivante est vraie :
runTestValue
est indiquée comme pouvant lever l’exception MyException
(en écrivant throws MyException
à la signature de la méthode).try
/catch
.Si aucune des deux propriétés est vérifiée alors il y a une erreur à la compilation.
Error:(YY, XX) java: unreported exception MyException;
must be caught or declared to be thrown
Une méthode doit donc préciser dans sa signature toutes les exceptions qu’elle peut lever et qu’elle n’a pas traitées avec un bloc try
/catch
On doit donc écrire :
public class Main {
public static void main(String[] args) {
try { Test.runTestValue(13); }
catch (MyException e) { e.printStackTrace(); }
}
}
Techniquement la méthode main
pourrait indiquer qu’elle génère l’exception MyException
mais cela n’aurait pas beaucoup de sens car cela voudrait dire qu’on ne gère pas vraiment l’exception.
printStackTrace
La méthode printStackTrace
permet d’afficher la pile d’appels :
RuntimeException
Une méthode doit indiquer toutes les exceptions qu’elle peut lever sauf si l’exception étend la classe RuntimeException
Bien évidemment, la classe RuntimeException
étend Exception
.
Quelques classes Java qui étendent RuntimeException
:
ArithmeticException
ClassCastException
IllegalArgumentException
IndexOutOfBoundsException
NegativeArraySizeException
NullPointerException
NoSuchElementException
Notez que ces exceptions s’apparentent le plus souvent à des bugs.
RuntimeException
dans la documentation JavaRuntimeException
is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
RuntimeException
and its subclasses are unchecked exceptions. Unchecked exceptions do not need to be declared in a method or constructor’s throws clause if they can be thrown by the execution of the method or constructor and propagate outside the method or constructor boundary.
RuntimeException
Lorsqu’on fait un appel à une méthode canThrow
pouvant lever une exception MyException
qui n’étend pas RuntimeException
, il est vérifié à la compilation que l’une des deux propriétés suivantes est vraie :
la méthode appelant canThrow
dans son code est indiquée comme pouvant lever une exception de type MyException
ou une de ces super-classes (en écrivant throws MyException
à la signature de la méthode).
l’exception potentielle est capturée par un bloc try
/catch
.
finally
On rajouter un bloc finally
après des blocs try
. Le bloc associé au mot-clé finally
est toujours exécuté :
public static void readFile(String fileName) {
try {
FileReader fileReader = new FileReader(fileName);
/* peut déclencher une FileNotFoundException. */
try {
int character = fileReader.read();// IOException ?
while (character!=-1) {
System.out.println(character);
character = fileReader.read(); // IOException ?
}
} finally { fileReader.close();/*dans tous les cas*/ }
} catch (IOException exception) {
exception.printStackTrace();
}
}
FileNotFoundException
étend IOException
et donc elle est capturée
try { FileReader fileReader = new FileReader(fileName);
try {
int character = fileReader.read(); // IOException ?
while (character!=-1) {
System.out.println(character);
character = fileReader.read(); // IOException ?
}
} finally { /* à faire dans tous les cas. */
fileReader.close();
}
} catch (FileNotFoundException exception) {
System.out.println("File "+fileName+" not found.");
} catch (IOException exception) {
exception.printStackTrace();
}
public class Stack<T> {
public void push(T object) throws FullStackException {
if (size == stack.length)
throw new FullStackException();
stack[size] = object;
size++;
}
public T pop() throws EmptyStackException {
if (size == 0) throw new EmptyStackException();
size--;
T object = (T)stack[size];
stack[size]=null;
return object;
}
}
public class StackException extends Exception {
public StackException(String msg) {
super(msg);
}
}
public class FullStackException extends StackException {
public FullStackException() {
super("Full stack.");
}
}
public class EmptyStackException extends StackException {
public EmptyStackException() {
super("Empty stack.");
}
}
En programmation, une énumération est un type spécial qui permet de définir des variables pouvant prendre des valeurs parmi un ensemble prédéfini de constantes.
Il est possible de définir des énumérations en Java grace au mot-clé enum
Une énumération est une classe avec des éléments prédéfinis et statiques.
On peut donc tester directement l’égalité avec l’opérateur égal car il n’y qu’un objet et donc qu’une référence qui correspond à chaque valeur possible.
public enum Suit {
SPADES("Pique", "Pi"), HEARTS("Coeur", "Co"),
DIAMONDS("Carreau", "Ca"), CLUBS("Trèfle", "Tr");
private final String frenchName;
private final String frenchSymbol;
Suit(String name, String symbol) {
this.frenchName = name;
this.frenchSymbol = symbol;
}
public String frenchName() { return frenchName; }
public String frenchSymbol() { return frenchSymbol; }
}
Enum
Toutes les énumération de java étendent la classe Enum
.
Quelques méthodes utiles :
String name()
: retourne le nom de la constante tel que déclaré dans l’enum
.int ordinal()
: retourne la position de la constante dans la déclaration de l’enum
(commençant par 0).Tout enum
définit aussi une méthode statique values()
renvoyant un tableau contenant les constantes dans l’ordre de leurs déclarations.
public static void main(String[] args) {
Suit[] values = Suit.values();
for (Suit suit : values)
System.out.printf("Le symbole de %s est %s.\n",
suit.frenchName(), suit.frenchSymbol());
}
Affichage :
Le symbole de Pique est Pi.
Le symbole de Coeur est Co.
Le symbole de Carreau est Ca.
Le symbole de Trèfle est Tr.
public static void main(String[] args) {
for (Suit suit : Suit.values())
System.out.printf("The position of %s is %d.\n",
suit.name(), suit.ordinal());
}
Affichage :
The position of SPADES is 0
The position of HEARTS is 1
The position of DIAMONDS is 2
The position of CLUBS is 3
switch
et enum
Supossons qu’on est une enum
pour les jour de la semaine :
switch
et enum
public void dayIsLike() {
switch (day) {
case MONDAY:
System.out.println("Mondays are bad.");
break;
case FRIDAY:
System.out.println("Fridays are better.");
break;
case SATURDAY:
case SUNDAY:
System.out.println("Weekends are best.");
break;
default:
System.out.println("Midweek days are so-so.");
break;
}
}
final
final
Mot-clé final
dans la déclaration d’un attribut : interdit la modification de la valeur de l’attribut après la construction de l’objet.
Exemple :
final
doit être initialisé après la construction de l’instancefinal
Mot-clé final
dans la déclaration d’une variable : interdit la modification de la valeur de la variable après la première affectation.
final
Mot-clé final
dans la déclaration d’une méthode : interdire la redéfinition d’une méthode dans une sous-classe
public class Integer {
/* ... */
final public Integer add(Integer val) {
return new Integer(this.value + val.value);
}
}
Integer
ne peut pas redéfinir (donner une nouvelle implémentation) la méthode add
final
Mot-clé final
dans la déclaration d’une classe : interdit l’extension de la classe
Integer
final
comme Math
, String
et System