Arnaud Labourel
17 ou 19 septembre 2018
Object
Par défaut, les classes étendent la classe Object
de Java et ont donc les méthodes suivantes que l’on peut redéfinir :
boolean equals(Object obj)
: Indicates whether some other object is “equal to” this one.String toString()
: Returns a string representation of the object.o1 == o2
: vrai si o1
et o2
sont le même objet et faux sinono1.equals(o2)
: vrai si o1
et o2
correspondent à deux objets considérés égaux (exemple : étudiant ayant le même id, chaîne de caractères ayant les mêmes caractères, … )En java, il existe des types primitifs qui ne sont pas des objets :
type | catégorie | taille | valeurs possibles | affichage |
---|---|---|---|---|
byte | entier | 8 bits | -128 à 127 | 0 |
short | entier | 16 bits | -32768 à 32767 | 0 |
int | entier | 32 bits | − 231 à 231 − 1 | 0 |
long | entier | 64 bits | − 263 à 263 − 1 | 0 |
float | flottant | 32 bits | 0.0 | |
double | flottant | 64 bits | 0.0 | |
char | caractère | 16 bits | caractère unicode | ‘\000’ |
boolean | booléen | non définie | false ou true |
false |
Lors d’un appel de méthode les arguments sont passés par valeur : une copie de la valeur de l’argument est créé lors de l’appel.
Pour les objets, cela signifie passer une copie de la référence : il est donc possible de modifier l’état de l’objet.
Pour les types primitifs, cela signifie que l’argument est un copie uniquement créée pour l’appel et toute modification de sa valeur n’aura pas d’impact en dehors de l’appel.
En Java, les tableaux sont des objets (et donc des références).
Déclaration d’une variable de type “référence vers un tableau” :
Construction d’un tableau :
Utilisation d’un tableau :
Déclaration :
Construction :
matrixOfInt = new int[10][];
for(int row = 0; row < matrixOfInt.length; row++)
matrixOfInt[row] = new int[5];
/* ou directement */
matrix = new int[10][5];
Que produit le code suivant (réponse au transparent suivant) ?
La classe String
permet de définir des chaînes de caractères invariables (immutable)
Déclaration et création :
Concaténation :
Affichage :
System.out.print(helloWorld); // affiche "Hello World !"
System.out.println(helloWorld); // affiche "Hello World !"
// avec retour à la ligne
Comparaison :
Les classes ArrayList
et LinkedList
: permettent de créer des listes en java.
if
La structure conditionnelle permet d’exécuter un bloc d’instructions que si une condition est réunie.
while(condition)
Le while
permet de répéter un bloc d’instructions tant que sa condition est vraie :
int count = 10;
while (count > 0) {
System.out.println(count + "...");
count = count - 1;
}
System.out.println("BOUM!!!");
Le test n’est effectué que juste avant d’effectuer la première instruction du bloc à chaque itération !
for(;;)
La boucle for(;;)
permet de répéter un bloc d’instructions tant qu’on ne quitte pas la boucle avec les instructions break
ou return
.
int count = 10;
for(;;) {
System.out.println(count + "...");
if (count <= 0) break;
count = count - 1;
}
System.out.println("BOUM!!!");
on peut avoir plusieurs instructions break
dans la même boucle.
for
Dans certains cas, il est plus direct d’utiliser une boucle for
, qui isole :
for (int count = 10; count > 0; count = count - 1) {
System.out.println(count + "...");
}
System.out.println("BOUM!!!");
On peut aussi utiliser break
et return
dans une boucle for
.
for
Pour les objets qui sont des collections, implémentant l’interface Iterable<Elt>
, on peut utiliser la boucle for
ainsi:
List<Elt>
Les structures de contrôles définissent des blocs d’instructions, entre {
et }
:
Un code non testé n’a aucune valeur.
Tout code doit être testé
Tester une unité de code : classe, méthodes, …
JUnit
assertTrue(boolean condition)
: vérifie que condition
est vraie.assertFalse(boolean condition)
: vérifie que condition
est faux.assertEquals(expected, actual)
: vérifie que expected
est égal à actual
equals
pour les objets et ==
pour les types primitifs.assertEquals(double expected, double actual, double delta)
: vérifie que |expected − actual| ≤ deltaassertNull(Object object)
: vérifie que la référence est null
assertNotNull(Object object)
: vérifie que la référence n’est pas null
assertSame(Object expected, Object actual)
: vérifie que les deux objets sont les mêmes (même référence).assertArrayEquals(Object[] expected, Object[] actual)
: vérifie si les deux tableaux contiennent les même éléments dans le même ordre.
fail()
: échoue toujours
Pour toutes les méthodes assert
, il est possible de mettre un message
en premier paramètre qui permet d’identifier l’assertion.
git clone adresse_projet
⇒ Clone un projet en local depuis un serveur
git add nom_de_fichier
⇒ Ajoute un fichier à la prochaine mise à jour.
git commit -m"commentaire"
⇒ Fait une mise à jour en local
git push
⇒ Pousse les mises à jour locales sur le serveur
git pull
⇒ Récupère les mises à jour du serveur en local
Stack
d’Object
Supposons que nous ayons la classe suivante :
Stack
d’Object
Nous rencontrons le problème suivant :
Stack stack = new Stack();
String string = "truc";
stack.push(string);
string = (String)stack.pop();
// Transtypage obligatoire !
Nous avons également le problème suivant :
Par conséquent, on souhaiterait pouvoir préciser le type des éléments :
Stack<String> stack = new Stack<String>();
String string = "truc";
stack.push(string); // Le paramètre doit être un String.
String string = stack.pop(); // retourne un String.
Java nous permet de définir une classe Stack qui prend en paramètre un type. Ce type paramétré va pouvoir être utilisé dans les signatures des méthodes et lors de la définition des champs de la classe.
Lors de la compilation, Java va utiliser le type paramétré pour effectuer :
La nouvelle version de la classe Stack :
Les types primitifs ne sont pas des classes :
Dans le cas d’un int
, on doit utiliser la classe d’emballage (wrapper class) Integer :
Interdit : Stack<int> stack = new Stack<int>();
Autorisé :
type | classe d’emballage | taille | valeurs possibles |
---|---|---|---|
byte | Byte | 8 bits | -128 à 127 |
short | Short | 16 bits | -32768 à 32767 |
int | Integer | 32 bits | − 231 à 231 − 1 |
long | Long | 64 bits | − 263 à 263 − 1 |
float | Float | 32 bits | |
double | Double | 64 bits | |
char | Character | 16 bits | caractère unicode |
boolean | Boolean | non définie | false ou true |
La classe Number
sert de base pour toutes les classes d’emballage.
Elle contient les méthodes suivantes :
public int intValue()
public long longValue()
public float floatValue()
public double doubleValue()
public byte byteValue()
public short shortValue()
Les classes d’emballage étendent Number
:
Byte
→ public static Byte valueOf(byte b)
Short
→ public static Short valueOf(short s)
Integer
→ public static Integer valueOf(int i)
Long
→ public static Long valueOf(long l)
Byte
→ public static Byte valueOf(byte b)
Ils existent des constructeurs mais ils sont dépréciés (et donc pas à utiliser).
Les classes d’emballage ne contiennent pas que des méthodes liées aux instances :
public static Byte valueOf(byte b)
public static char charValue()
public static boolean isLowerCase(char ch)
public static boolean isUpperCase(char ch)
public static boolean isDigit(char ch)
public static boolean isLetter(char ch)
public static boolean isLetterOrDigit(char ch)
public static char toLowerCase(char ch)
public static char toUpperCase(char ch)
public static char toTitleCase(char ch)
Depuis Java 5, il existe l’emballage et le déballage automatique :
Stack<Integer> stack = new Stack<Integer>();
int intValue = 2;
stack.push(intValue);
// → emballage automatique du int dans un Integer.
int otherIntValue = stack.pop();
// → déballage automatique du int.
Il est important de noter que des allocations sont effectuées lors des emballages sans que des new
soient présents dans le code.
On considère une liste chaînée de String
Nous la transformons en classe paramétrée de la façon suivante :