Oral Java(miam)

Sommaire:
1. Vocabulaire :

2. Interface :
2.1. Définition
2.2. Syntaxe
2.3. Utilité :

3. Extends
3.1. Définition :
3.2. Exemple :

4. While/Do while:
4.1. While:
4.1.1. Grammaire:
4.1.2. La base:
4.2. Do while:
4.2.1. Grammaire:
4.2.2. La base:

5. (Array)List:
5.1. Avant propos:
5.2. List :
5.2.1. Méthodes générales:
5.2.2. Quelques méthodes du contrat List :
5.3. ArrayList :
5.4. LinkedList :
5.5. ArrayList VS LinkedList:

6. Visibilité :
6.1. Private :
6.2. Public :
6.3. Protected :
6.4. Package :
6.5. Intérêt ?

7. Encapsulation:
7.1. Définition :
7.2. Exemple :
7.3. Explication:

8. Assignation:

Black Widow’s so hot, her bone structure is giving my "bone" structure

9. Post-incrémentation :
9.1. Présentation :
9.2. Quelques exemples :

10. Tableau 1D:

10.1. Déclaration:
10.2. Création :
10.3. Complément:

11. Tableau 2D :

12. [Link]/out/err :
12.1. L’attribut in
12.2. L’attribut out
12.3. L’attribut err

13. Try Catch:

13.1. La base:
13.2. Type d’Exception:
13.3. Méthode:
13.4. Multiple catch:
13.5. Finally :
13.6. Try with resources :

14. For Each:

14.1. La base:
14.2. Grammaire :
14.3. L'intérêt du for each vis à vis du for:
14.4. Pourquoi le forEach est il plus rapide que le for?

15. If:
15.1. Grammaire :
15.1.1. if (Expression) Statement
15.1.2. If Then Else Statement
15.2. Les accolades:
15.3. Le dangling
15.4. Différents types:

16. Var args: méthodes à arguments variables

16.1. La base:
16.2. Notation:
16.3. Règles:

17. Grammaire (non fini):

17.1. Principe:
17.2. Compilation :

Black Widow’s so hot, her bone structure is giving my "bone" structure

 17.3. Fonctionnement :
17.4. Lexicale:

18. Trier

19. toString:
19.1. Pourquoi toString() et pas [Link]() ?

20. Flux englobant :

20.1. Le flux englobant :
20.2. Type primitif :
20.3. Les flux formatés :
20.4. Sortie standard :

21. this/super:
21.1. This:
21.2. Super:

22. Throw(s):
22.1. Throw
22.2. Throws
22.3. RuntimeException
22.4. En résumé

23. Expression régulière

23.1. Les métadonnées :
23.2. Les types génériques :
23.3. Les quantificateurs :

24. Filtrer(fonctionnel):
24.1. Le Stream:
24.1.1. Création d’un stream:
24.2. Les opérations intermédiaires(Filter):
24.3. Les opérations Terminaux:
24.4. itérer:

25. Wrapper, (Un)Boxing :

25.1. Problème avec liste :
25.2. Wrapping :
25.2.1. Les classes wrappers :
25.2.2. Les Wrappers et leurs membres:
[Link]. Integer :
[Link].1. Champs :
[Link].2. Méthodes :
[Link]. Double :
[Link].1. Champs :
[Link].2. Methodes :
Black Widow’s so hot, her bone structure is giving my "bone" structure
 [Link]. Float :
[Link].1. Champs :
[Link].2. Methodes :
[Link]. Boolean :
[Link].1. Champs :
[Link].2. Methodes :
[Link]. Character :
[Link].1. Champs :
[Link].2. Methodes :
[Link]. Number :
[Link].1. Méthodes concrètes :
[Link].2. Méthodes abstraites :
25.3. Boxing/Unboxing :

26. Break/Continue:
26.1. Label:
26.2. Break:
26.3. Continue:

27. Fichier binaire :

28. Fichier texte :

29. Classe abstraite :

29.1. Interface vs Classe Abstraite:

30. Polymorphisme :

31. For:

32. Constructeur:
32.1. Getter :
32.2. Setter :

33. Object:

34. Objects :
34.1. deepEquals:
34.2. compare:
34.3. hash:
34.4. isNull / nonNull:

35. Switch:
35.1. La base:
35.2. Syntax of switch case:

36. Path:

37. Collection(s):

Black Widow’s so hot, her bone structure is giving my "bone" structure

 37.1. Définition :
37.2. Collection VS Collections :
37.2.1. Collection :
37.2.2. Collections :

38. Codage Fichier Java:

39. Enumération:
39.1. De quoi s’agit-il ?
39.2. Normes d’écriture
39.3. Utilisation

40. Hashcode():

41. Equals:
41.1. De quoi s’agit-il?
41.2. Conventions/Utilisation
41.3. Exemple :

42. Static :
42.1. De quoi s’agit-il?
42.2. Attributs static
42.3. Méthode static
42.4. Constructeur static
42.5. Import static

43. Import:
43.1. De quoi s’agit-il ?
43.2. Grammaire
43.3. Import static

44. Sérialisation :
44.1. Introduction
44.2. Serialisation d’un objet :
44.3. Désérialisation :

45. Répartition mots :

46. ⚠Help, aidez à compléter:

47. Consignes :
47.1. Modules:
47.1.1. Code Blocks :
47.1.2. Table des matières :
47.2. Répartition :

Black Widow’s so hot, her bone structure is giving my "bone" structure

1. Vocabulaire :

Expression
Declaration
Assignation
Wrapper
Primitif
Priorités des opérations

faudrait mettre certain truc ici

2. Interface :

2.1. Définition
Type référence similaire aux classes, elle a la particularité d’être totalement ​abstraite​.
Par conséquent, toutes ses méthodes sont implicitement abstraites. (pas besoin de rajouter le
mot-clé ​abstract​)​.
Le principal objectif d’une interface est de définir un contrat. Celui ci consiste en un
ensemble de méthodes où ne sont écrites que les entêtes de celles ci. La définition du code
des méthodes de l’interface est la responsabilité de la classe qui va implémenter celle ci.

⚠​ il ne faut pas définir la visibilité car elle le sera par l’implémentation

Exemple en tête de méthode interface​ :
​void​ ​rollingStone​ (String name);

⚠ ​Les champs (attributs) ne peuvent être que static et final. Une interface ne peut posséder
de constructeur. Elle ne donc peut être instanciée.

( Les champs sont les membres qui permettent de stocker des valeurs de types de base ou des
objets. )

Une classe implémentant une interface doit implémenter (définir le code de) chaque
méthode de l’interface (elle peut cependant en rajouter). Pour implémenter une méthode il

Black Widow’s so hot, her bone structure is giving my "bone" structure

suffit de la définir comme on le ferait pour une méthode en général. On pourra ajouter
l’annotation @Override mais elle est facultative (vu qu’une méthode abstraite est toujours
override)
Exemple :

@Override​ ​//facultatif
public​ ​void​ ​rollingStone​(String name) { ​//attention à définir la
visibilité
[Link] (​"Angie..."​);
[Link] (name);
}

Plusieurs classes peuvent implémenter une interface et une classe peut implémenter une ou
plusieurs interfaces. Une interface peut également étendre une autre interface ( hériter d’une
interface mère).

2.2. Syntaxe
On déclare une interface comme on le fait pour une classe sauf qu’on remplace ​class​ par ​interface​.

​public​ ​interface​ ​Nirvana ​ pour un fichier ​[Link]

Pour indiquer qu’une classe implémente une autre il faut, à la suite de ​public class maClasse​,
indiquer ​implements monInterface.

public​ ​class​ ​ledZeppelin​ ​implements​ ​HardRock

Pour indiquer qu’une classe implémente plusieurs interfaces :

public​ ​class​ ​BlackSabbath​ ​implements​ ​Metal​, ​HardRock​, ​Blues​ , ​Rock

Pour indiquer qu’une interface étend (hérite) une autre interface :

public​ ​interface​ ​Aerosmith​ ​extends​ ​AC​/​DC

Comme l’héritage multiple est interdit en java, une interface ne peut étendre qu’une seule
autre interface.

Une classe qui implémente une interface possède toutes les méthodes et attributs de
l’interface implémentée.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Si on veut de l’héritage et de l’implémentation pour une classe : (toujours donner l’héritage d’abords
et ensuite les interfaces à implémentée).

public​ ​class​ ​Cream​ ​extends​ ​ChuckBerry​ ​implements​ ​Rock​, B

​ lues

2.3. Utilité :
Le polymorphisme

L’intérêt d’une interface est que son code n’est pas défini. Par conséquent, on va pouvoir
avoir plusieurs classes implémentant une interface et chacune des classes implémenetra
différemment la dite interface. Chaque classe ayant les mêmes en-têtes de méthodes, on va
donc pouvoir les appeler de la même manière.

Exemple avec des armes:

On souhaite représenter une série d’armes qui font des dégâts différents ou qui ont des
effets différents.

Pour cela on crée une interface Arme. Chaque classe représentant une arme devra
alors implémenter Arme. Une lance empoisonné pourrait alors définir une méthode attaque
comme infligeant 5 points de vie à la cible et chaque tour, draine la vie de la cible de 1 point.
Une attaque d’une hache pourrait infliger 10 points de dégâts et étourdir la cible.

Imaginons maintenant que notre arme puisse aussi être aussi un objet de soin (un sceptre par
exemple), il suffit d’implémenter dans la classe Sceptre, Arme et ObjetSoin(interfaces). Ainsi
le sceptre pourra utiliser la méthode attaquer() de Arme et la méthode soin() de ObjetSoin.
Et ceci n’aurait pas été possible avec une classe abstraite simple car une classe ne peut hériter
que d’une classe à la fois (pas d’héritage multiple).

3. Extends

3.1. Définition :
Le mot extends est un mot clé de java qui définit qu’une classe hérite d’une autre.
Une classe Enfant hérite d’une classe Parent -> ​Enfant ​extends​ ​Parent
La classe enfant qui hérite, récupère les attributs et les méthodes de la classe parents.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Toutes les classes héritent par défaut de la classe Object et donc des méthodes par défaut comme par
exemple toString(), equals(),hashcode(),...

3.2. Exemple :
Une classe Pion.

Un point est définit par une valeur de x et de y dans un plan. Nous pouvons choisir que certains pions
ont aussi une couleur. Nous créeront la classe PionColoré qui héritera de la classe Pion. Un pion
coloré aura donc une valeur x, une valeur y et une couleur car x et y sont hérité. Idem pour les
méthode​s

public​ ​class​ ​Pion​ {

private​ ​int​ x = 5;
private​ ​int​ y;
​public​ ​int​ ​getX​(){
return​ x;
}
}

public​ ​class​ ​PionColore​ ​extends​ ​Pion​ {

private​ String couleur ; ​// x et y sont 2 attributs hérité que
PionColore possède.
}

On pourra donc faire :

public​ ​static​ ​void​ ​main​ (String [] args)

PionColore p1 = ​new​ PionColore();
[Link]([Link]()); ​// fonctionne car un PionColore
hérite de pion.
}

L’héritage multiple est illégal en java. On ne pourra donc pas avoir un Enfant avec deux
Parents. Pour palier à ce problème on va utiliser des ​interfaces​.

Black Widow’s so hot, her bone structure is giving my "bone" structure

4. While/Do while:

4.1. While:
Le while traduit le concept du « tant que » en algorithmique. Contrairement au for il est
utilisé lorsqu'on veut arrêter le traitement à un moment donné mais qu'on ne connais pas le
nombre d'itération à l'avance. On quittera le while quand la condition ne sera plus respectée.

4.1.1. Grammaire:

while (Expression) Statement

​ ooléene, ou ​lorsque “compil-time error”
Expression est une expression de type booléene ou B
apparait​ .

La boucle ​while sera exécutée par le résultat de l​’Expression. ​Si le résultat est de type
Boolean​ (avec grand B!) alors il est sujet à la conversion de son type référent
(Wrapper → primitive type, cela signifie simplement que ​Boolean (wrapper) devient
boolean​ (primitif) ⇒ unboxing en termes java).

CONDITION D’ARRET:

● Si la conversion (wrapper → primitive type) s’interrompt de manière brutal (de

manière inattendu) alors la boucle ​while​ s’interrompt aussi.

● Sinon, l'exécution continue en se basant sur le résultat de l’​Expression​ :

○ Si la valeur est ​true alors le contenu du ​Statement est exécuté. Ensuite deux
possibilités peut survenir lors de cette exécution:
■ si l'exécution du ​Statement ​est exécuté normalement, alors le ​while ​se
re-exécute en commençant par ré-évaluer l’​Expression​.

■ si lors de l'exécution du ​Statement​ s’interrompt de manière brutal:

- suite à un ​break ​sans ​label alors le ​while ​s’interrompt
correctement
- suite à un ​continue​ ​sans label alors le ​while​ se ré-exécute
- suite à un ​continue ​avec un label qui pointe sur la boucle, alors
le ​while ​s’exécute à nouveau

Black Widow’s so hot, her bone structure is giving my "bone" structure

 - suite à un ​continue avec un label qui ne pointe pas sur la
boucle, alors le ​while​ s’interrompt brutalement
- suite un return avec ou sans valeur
- suite un throw dans le statement (par exemple division par 0)
- et enfin si l’exécution du ​Statement ​provoque une erreur qui
provoque l’arrêt brutal de la boucle.

○ Si la valeur est ​false alors aucune action du ​Statement est exécuté et la boucle
while​ s’arrête correctement.

Il est possible d’émuler (simuler) un ​for ​avec un ​while​ en respectant cette grammaire
init
while(Expression){
Statement
Update
}

En déclarant et assignant une valeur i (par exemple) avant le ​while ​et en mettant à jour cette
valeur dans la boucle; lors de l’évaluation de l’​Expression (si “i” en fait parti) on peut
reproduire le comportement du ​for. ​Cela est pratique lorsqu’on parcourt un tableau par
exemple à l’aide d’un ​while​ .

L'incrémentation est optionnelle, mais l’​Expression ​est obligatoire.

C'est dans le Statement qu'on trouve l'incrémentation qui est optionnelle.

Si il y a une incrémentation, elle doit également avoir une influence sur l'expression booléene
afin d'éviter les erreurs du type RunTimeException lorsque, par exemple, on dépasse un
tableau.
Contrairement au for, la déclaration de la variable qui s'incrémente ne se fait pas dans la
boucle while mais avant.

4.1.2. La base:
Une boucle commence par l'utilisation du mot clef, ici : ​while​. Cela veut dire, « tant que ».
Puis nous avons une condition : c'est elle qui permet à la boucle de s'arrêter. Une boucle n'est
utile que lorsque nous pouvons la contrôler, et donc lui faire répéter une instruction un certain
nombre de fois. C'est à ça que servent les conditions. ​Contrairement au ​for ​il est utilisé
lorsqu'on veut arrêter le traitement à un moment donné mais qu'on ne connait pas le nombre
d'itération à l'avance. ​Ensuite nous avons une ou plusieurs instructions : c'est ce que va
répéter notre boucle (il peut même y avoir des boucles dans une boucle).
On quittera le ​while q​ uand la condition ne sera plus respectée.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Exemple :
int​ [] tab = ​new​ ​int​ [6]
int​ n = 6, i=0 ;
boolean​ trouvé = true​ ;
while​ (i< n ET trouvé) {
​if​(tab[i]==2) {
trouve = faux ;
}
i++ ;
}
// Quand on atteins la fin du tableau ou qu'on trouve 2 dans le tableau, on s'arrête.

On peut effectuer le même traitement qu'un for avec un while en utilisant cette grammaire.

4.2. Do while:

4.2.1. Grammaire:
do ​Statement ​while ( ​Expression ​);
Le do while fait au moins une itération avant de vérifier la condition.

4.2.2. La base:
C’est un​ r​ épéter tant que. ​Le ​do while​ s’exécute au moins une fois.
Il effectue une fois puis fait le test ,donc au moins un tour de boucle puisque le test se fait
après.

Première différence

La boucle ​do… while s'exécutera au moins une fois, contrairement à ​while​. C'est-à-dire que la
phase de test de la condition se fait à la fin, car la condition se met après le ​while​.

Deuxième différence

C'est une différence de syntaxe, qui se situe après la condition du while. Il y a un « ;» après le
while. C'est tout ! Ne l'oubliez cependant pas, sinon le programme ne compilera pas.

Mis à part ces deux éléments, ces boucles fonctionnent exactement de la même manière.

Exemple :
int​ i = 9 ;
do​ {

Black Widow’s so hot, her bone structure is giving my "bone" structure

 i+=1 ;
} ​while ​( i == 10) ;

int​ nb;
do​ {
nb = clavier . nextInt ();
} ​while​ (nb<=0);

Scanner sc = ​new​ Scanner([Link]);

final​ String password = ​"Expelliarmus"​;
String userAnswer;
do​ {
[Link](​"Insérer votre mot de passe"​);
userAnswer = [Link]();
if​ () {
[Link](​"Faux recommencez!"​);
}
} ​while​ ();

Les conditions d’arrêt d’un boucle ​do...while​ sont les mêmes que celle de la boucle ​while.

5. (Array)List:

5.1. Avant propos:

Une ​collection​ représente un groupe d’objets, ses éléments.

● Tous les éléments sont de​ même type

● Certaines collections ​sont triées et d’autres ordonnées
● certaines collections ​permettent des doublons

Black Widow’s so hot, her bone structure is giving my "bone" structure

 5.2. List :
Collection ordonnées d’éléments (objets) accessibles par leurs indices (List étend
Collection) :
● Les doublons sont permis
● Une liste est Iterable (parcourable par un forEach)
● Pas de taille limite (enfin si limitée par la mémoire) , elle est égale au
nombre d’éléments de la liste (pas comme tableau qui a taille fixe)
● Elle ne contient que des objets. Elle ne peut contenir de types primitifs
donc ne peut pas avoir de int , char, double etc . Pour utiliser ces types
primitifs , on va passer par des ​wrapper​ .
● Ordonnée ( avec indice ), mais pas nécessairement trié
Doit remplir un ​contrat (quelques exemples) : pouvoir accéder à l’élément (get)
supprimer un élément (remove), remplacer un élément (set).
Comme List est une interface, chaque implémentation de List aura sa propre façon de
gérer les ajouts , les remplacement etc.

5.2.1. Méthodes générales:

5.2.2. Quelques méthodes du contrat List :

boolean add (E e) : ajoute l’élément e en fin de Liste. Retourne true lorsque

l’élément a été ajouté correctement.
void add(int index, E element) : ajoute l’élément element à la position
index(s’il y avait un élément auparavant, on décale la liste de 1 à partir de l’élément à
déplacer).
boolean addAll(Collection<? extends E> c) : ajoute la collection spécifiée en
paramètre à la fin de la liste courante (celle qui appelle la méthode addAll(c)). (ne pas
montrer ça à Codutti si vous ne savez pas expliquer la syntaxe des paramètre).
boolean addAll(int index, Collection<? extends E> c) : même chose que
premier addAll mais en plaçant la collection à l’index souhaité.
void clear()​ : vide la liste.
boolean contains (Object o) : renvoi un booléen indiquant si l’objet se trouve
dans la liste.
boolean containsAll(Collection<?> c) : renvoi un booléen indiquant si tous
les éléments de la collection se trouvent dans la liste.
E get (int index)​ : return the element at the specified position.
int indexOf(Object o) ​: retourne la position de la première occurrence de
l’Objet spécifié en paramètre (appel de equals) .
boolean isEmpty() ​: retourne un booléen indiquant si la liste est vide.

Black Widow’s so hot, her bone structure is giving my "bone" structure

 E remove (int index)​ : supprime un élément et retourne l’élément supprimé.
boolean remove (Object o) : supprime la première occurrence de l’objet passé
en paramètre.
E set (int index, E element) : remplace l’élément à l’indice spécifié par
l’élément passé en paramètre. retourne l’élément remplacée.
int size()​ retourne le nombre d’élément de la liste.
Connaître les erreur que renvoi les méthodes:

UnsupportedOperationException​ - if the operation is not supported by this list

ClassCastException - if the class of the specified element prevents it from being xxx
to this list
NullPointerException - if the specified element is null and this list does not permit
null elements
IllegalArgumentException - if some property of this element prevents it from being
added to this list

5.3. ArrayList :
Implémentation de l’​interface ​List​. L’arrayList a pour particularité d’être en fait un
tableau. Au début, la taille de ce tableau est de 10 et il ne contient rien. Ensuite quand on
souhaite ajouter un éléments, on crée un nouveau tableau d’une taille qui est double par
rapport à la taille de l’ancien tableau, on mets les éléments de l’ancien tableau dans le
nouveau tableau et finalement on rajoute le dernier élément.
Par conséquent, plus on va ajouter d’éléments plus la taille du tableau de notre ​List
sera grande. Si on ajoute un élément à une arrayList dont la taille du tableau est 5000 et que
toutes les 5000 cases du tableau sont occupées, on va passer d’un tableau de taille 5000 à un
tableau de taille 10000. Ce qui peut être une grosse perte de mémoire.
D’un autre côté supprimer et refaire un tableau à chaque fois que le tableau est plein
est coûteux en écriture.

5.4. LinkedList :
I​mplémentation de l’interface List. La LinkedList est un Objet. Contrairement à
l’arrayList, il n’y pas de tableau derrière une LinkedList.

Ici, on aura une tête (head) qui est le premier élément de la liste. On connaîtra les autres
éléments de la liste grâce à cette tête. En effet, celle ci pointe vers l’adresse de la valeur
suivante de notre liste. Cela implique qu’on ne pourra pas directement chercher des éléments
avec leur indice.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Ce que la linkedList va faire, c’est qu’elle va chercher la tête , le premier élément, si ce n’est
pas l’élément recherché, la liste va chercher le prochain élément grâce à la tête qui pointe vers
l’adresse du prochain élément.

5.5. ArrayList VS LinkedList:

Contrairement aux LinkedList, les ArrayList sont rapides en lecture, même avec un
gros volume d'objets (pour lire avec une LinkedList, il faut lire les éléments 1 par 1 jusqu’à
trouver l’Elu, avec une ArrayList , on va directement chercher l’élément au bon indice) .

Elles sont cependant plus lentes si vous devez ajouter ou supprimer des données au
milieu et au début (car beaucoup d’éléments à déplacer). Car il va falloir vérifier qu’ajouter
l’élément ne va pas dépasser la taille du tableau et ensuite il faut déplacer les éléments du
tableau à partir de l’indice souhaité pour pouvoir après insérer notre élément.
Avec une linked , il suffira de rajouter un noeud et de changer les références (même
si il va falloir parcourir toutes la liste pour tomber sur le bon élément ).

Pour résumer à l'extrême, si vous effectuez beaucoup de lectures sans vous soucier de
l'ordre des éléments, optez pour une ArrayList ; en revanche, si vous insérez beaucoup de
données au milieu de la liste, optez pour une Linkedlist

ArrayList LinkedList

utilise en interne un tableau pour stocker les

éléments

Black Widow’s so hot, her bone structure is giving my "bone" structure

 la manipulation d’une ArrayList est lente la manipulation est plus rapide qu’une
car elle utilise en interne un tableau, cela ArrayList car il suffit de
implique que si un élément est enlevé, tous référence/déréférencé pour
les bits sont décalés en mémoire ajouter/supprimer/déplacer

ArrayList est le meilleure choix lorsqu’on LinkedList est le meilleur choix lorsqu’on
veut stocker et accéder à des données veut manipuler des données

6. Visibilité :
La visibilité s’applique à un membre(attribut ou méthode) d’une classe. Il en existe 4 types.
- Private​ -
- Public​ +
- Protected​ (fait référence à l’héritage) #
- Package​ (Sans mot-clé) ~

6.1. Private :
Quand l’attribut private est appliquée sur un champ, il n’est pas accessible en dehors de cette même
classe sauf via un accesseur (getter) ou un mutateur (setter) (puisqu’ils sont public).

Exemple :
Un attribut nombre déclaré comme ceci :
private​ ​int​ nombre;

Pour y accéder les méthodes dans la classe en question sont public :

public​ ​int​ ​getNombre​() {
​return​ nombre;
}
public​ ​void​ ​setNombre​(​int​ nombre) {
​this​.nombre = nombre;
}

6.2. Public :
La visibilité Public permet d'accéder aux champs à partir de toutes les autres classes, on peut y
accéder comme on le souhaite autant pour lire que pour modifier !

Black Widow’s so hot, her bone structure is giving my "bone" structure

Pour y accéder on utilise la syntaxe (notation pointée): ​[Link]

Exemple :
Un attribut nombre déclaré comme ceci dans la classe Projet :
public​ ​int​ nombre;
Je peux y accéder via :
[Link]([Link]);

6.3. Protected :
La visibilité protected est utilisée en ​héritage lorsqu'on veut que les attributs et les méthodes de la
classe mère soit visibles dans la classe fille. Du coup, au lieu de mettre le membre comme étant
private ​dans la classe mère, on le met ​protected​.
Nous l’avons utilisé dans notre projet pour la classe Chest qui héritait de la classe Bag.

Exemple :
public​ ​class​ ​Employe​ {
​protected​ String nom;
​protected​ String prénom;
​protected​ ​int​ matricule;
​protected​ ​int​ salaire;
}

Lorsqu'on utilisera le mot clé extends, les attribut de la classe mère seront accessible pour la classe
fille et ​elle va donc pouvoir y accéder sans restriction via l'héritage, ce qui n'aurait pas été possible si
l'attribut était private.

public​ ​class​ ​Manager​ ​extends​ ​Employe​ {

​private​ ​int​ prime;
}
La classe Manager aura donc également accès aux méthodes et aux attributs déclarés en protected
dans la classe mère (Employé).

6.4. Package :
Pour la visibilité Package il n’y a pas de mot-clé. Elle permet de rendre les membres accessible par
l’entièreté du même package.

Exemple :
Créons une classe Esi.
public​ ​class​ ​Esi​ {
boolean​ isReussi;

Black Widow’s so hot, her bone structure is giving my "bone" structure

 int​ nombre;

​int​ ​somme​(​int​ value) {

​return​ value+value;
}
}

Toutes les classes qui se trouvent dans le même package auront accès aux attributs et aux méthodes de
la classe Esi.

6.5. Intérêt ?

L’intérêt de mettre des visibilités est de gérer la portée qu’aura notre champ et ainsi de pouvoir le
contrôler et empêcher que des actions non shouhaitées soient effectuées sur nos champs ( →
mécanisme d’​encapsulation​).

Exemple :
Nous avons un attribut publique qui indique le nombre de vies restantes du joueur. N’importe qui
pourrait, dans ce cas, modifier son nombre de vie restante comme bon lui semble. Alors qu’en private
c’est impossible.

La différence est qu’avec un attribut public, il est directement modifiable en le citant alors qu’avec un
attribut private, il est modifiable avec un setter on peut donc y ajouter un traitement c-a-d comme une
condition par exemple.
Exemple :
public​ ​void​ ​setNbJambes​(​int​ nbJambes) {
if​(nbJambes < 2) {
throw​ ​new​ IllegalArgumentException(​"AH !"​);
}
this​.nbJambes = nbJambes
}

7. Encapsulation:

7.1. Définition :
L'encapsulation est un concept consistant à rassembler des données et des méthodes dans une structure
en cachant l'implémentation de l'objet, c'est-à-dire en ​empêchant l'accès aux données​ ​par un autre
moyen que les méthodes proposées​ (getter, setter ou méthode définie par le programmeur ). Pour
empêcher l’accès des attributs on utilisera des visibilités différentes : public, private, protected,
package (cf: ​Visibilité​)

Black Widow’s so hot, her bone structure is giving my "bone" structure

L'encapsulation permet de garantir/contrôler l'intégrité des attributs contenus dans l'objet.
garantir/controller veut dire : faire en sorte qu’on ne puisse pas mettre n’importe quoi dans un attribut.
Par exemple pour une heure, on ne peut pas avoir 10h​83​ minutes​. 
 

7.2. Exemple :
public​ ​static​ ​void​ ​main​ ( String args []){
Personne pers = ​new​ Personne;
[Link](​"Gaïa"​); ​// <- encapsulation
[Link](​"nom : "​ + [Link]() ) ;
// affichera le nom :Gaïa
}
public​ ​class​ ​Personne​{
private​ String nom;
Personne(){ }; ​// constructeur vide
// méthodes proposées pour accéder à la donnée :
public​ String ​getNom​(){
return​ nom;
}
public​ ​void​ ​setNom​(String name){
this​.nom = name;
}
}

7.3. Explication:

C’est tout simple!

Prenez ces deux méthodes:

public​ v​ oid​ ​methodeA​(){

int i = 0;
i++;
}
public​ ​void​ ​methodeB​(){
int i;
i=0;
sout(i); //affiche 0 car il fait reference slmt au i de cette
méthode.
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

Ces deux méthodes appartiennent à la classe Explication ​donc à la même classe​. Que se passe-t-il
lorsque la ​méthode A​ sera utilisée après la ​méthode B​? La ​méthode A​ fera l’incrémentation toujours à
partir de 0 après avoir exécuté la ​méthode B​? (réponse NON)

L’encapsulation permet de dire que la variable i de la ​méthode A​ concerne uniquement cette méthode.
Pareil pour la ​méthode B​. Les deux ​i​ ne sont pas les mêmes!

Donc l’encapsulation permet ​d’encapsuler​ des choses qui ne seront donc pas modifié par un autre
endroit du code.

Black Widow’s so hot, her bone structure is giving my "bone" structure

8. Assignation:
Il existe deux sortes d’assignation :
- assignation simple (​=​)
- assignation composé (%=)

L’assignation est une expression (qui comprend une opération, ex : + - * / …).//encore définir
expression
En java, on l’utilise avec un opérateur d’assignation pour attribuer une valeur à une variable. Elle a un
type (celui de la variable) et une valeur (celle du left hand side) . ​On considère la variable de gauche
comme étant le premier nombre de l'opération mais aussi la variable dans laquelle il faudra mettre le
résultat​.

/*Dans le cas du " = ", l'expression n'est-elle pas considérée comme

indéfinie(null). En effet, je ne pense pas que le leftHandSide ait déjà une
valeur sauf si ce n'est pas la première assignation. */
Je pense que l’expression est indéfinie.

Exemple pour LeftHandSide

élément = 1 // element est le leftHandSide , = est l’AssignementOperator et 1 est l’Expression
éléments[i] = j //
Il existe d’autres opérateurs d’assignation, on parle alors d’opérateur d’assignation composé : = , *=
, /=, %=, +=, -=
ex:
element *= 2 ​//équivaut à
element = element*2

var += expr équivaut à var = (Type) (var + expr)

Prenons cet exemple pour illustrer:

int​ a = 1;
int​ b = 2;
int​ c = 3;

a = b = c;

Black Widow’s so hot, her bone structure is giving my "bone" structure

Que vaut a?

La grammaire nous apprend que l’assignation s’opère de droite à gauche. On pourra dès lors lire
l’instruction de cette manière

a = (b = c)

La valeur de c (=3) est assigné à ​b ​(b vaut maintenant 3) et ​b est assigné à ​a, ​donc ​a ​vaut maintenant
3.

DONC le résultat du premier opérande de l’assignement doit-être une variable, sinon cela ne
compilera pas.

exemple:
a = 2 = c; // ne compile pas

Autre cas;

prenons cette exemple :

int a,b,c,d,e;

a = b = c = d = e;

que vaut a?

Cette instruction ne compilera pas! Pourquoi? Parce que la variable e ​n’a pas été initialisé (aucune
valeur n’est assigné à ​e​). La variable ​ e ​est la seule minimum nécessaire afin que le code compile.

Autre cas;

Prenons le même exemple

int a,b,c,d;
boolean e = 2 == 2; //je sais c’est tordu, mais ça montre qu’on a compris les concepts

a = b = c = d = e;

que vaut a?

Réponse : ça compille pas!

Black Widow’s so hot, her bone structure is giving my "bone" structure

DONC l’assignation est avant tout une expression

→ elle a un type (celui de la variable)

→ elle a une valeur (celle left hand side)
la valeur est en soit aussi un type … Maintenant il est possible de faire un cast afin de tronquer une
valeur comme par exemple de double à int.

Autre cas;

Reprenons le même exemple

int a, b, c = 2; //j’en discute dans le cas suivant

final int d = 4;

d = b = c = a; //ne compilera pas car impossible de modifier une constante

par contre

a = b = c = d; //compile
4e DONC une constante ne peut pas se mettre dans le premier (elle ne peut se mettre que dans le
dernier, le principe est que sa valeur ne change pas) opérande de l’assignation.

Autre cas;

Comme il est possible de faire en une ligne plusieurs déclaration(séparée par une virgule):
int a,b,c;
il est aussi possible de faire plusieur assignation en une ligne:
int a, b, c = 2;
a, b et c ont 2 comme valeur.

Black Widow’s so hot, her bone structure is giving my "bone" structure

9. Post-incrémentation :
9.1. Présentation :
i++ (post-incrémentation) et ++i (pré-incrémentation) sont des expressions.
++ est un opérateur qui permet l’incrémentation d’une variable.

++i :
i = i + 1; ​// i est incrémentée
++i = i; ​// l'expression (++i prend la valeur de i)
// pré-incrémentation => l'incrémentation se fait PRÉcédemment à
l'assignation de l'expression

I est incrémenté puis donne sa valeur à l’expression, alors que dans le cas de la

i++:

i++ = i; ​// l'expression (i++ prend la valeur de i)

i = i + 1; ​//i est incrémentée
// post incrémentation => l'incrémentation se fait POSTérieurement à l'assignation de l'expression

post-incrémentation(i++) i donne sa valeur à l’expression avant d’être incrémenté.

⚠​ ​Remarquez que c’est toujours le i qui donne sa valeur à l’expression, jamais l’inverse.

9.2. Quelques exemples :

public​ ​static​ ​void​ ​main​(String[] args) {

​int​ i = 1;

[Link](i++); ​//affiche 1

[Link](i); ​//affiche 2
}

//réponse
1
2

public​ ​static​ ​void​ ​main​(String[] args) {

​int​ i = 1;

[Link](++i); ​//affiche 2

[Link](i); ​//affiche 2

Black Widow’s so hot, her bone structure is giving my "bone" structure

}
//réponse
2
2

public​ ​static​ ​void​ ​main​(String[] args) {

​int​ i = 1;
i = i++;

[Link](i); ​//affiche 1
i = 1;
i = ++i;

[Link](i); ​//affiche 2
}
//réponse
1
2

public​ ​static​ ​void​ ​main​(String[] args) {

​int​ i = 1;

[Link](i++); ​// affiche 1

[Link](i); ​// affiche 2

[Link](++i); ​// affiche 3

i = 1;

[Link](i++ + ++i); ​// affiche 4

}
//réponse
1
2
3
4

public​ ​static​ ​void​ ​main​(String[] args) {

​int​ i = 1;

[Link](++i); ​// affiche 2

[Link](i); ​// affiche 2

[Link](i++); ​// affiche 2

Black Widow’s so hot, her bone structure is giving my "bone" structure

 i = 1;

[Link](++i + i++); ​// affiche 4

}
//réponse
2
2
2
4

10. Tableau 1D:

Le tableau est une structure de donnée regroupant plusieurs éléments du même type (type
primitif ou une classe) accessible via un indice. Le premier indice est 0 et le dernier étant TAILLE - 1.
(un tableau est un objet puisqu’il hérite de [Link])

Une fois l’espace alloué en mémoire pour n composantes de type T, on ne peut pas la changer la taille
du tableau. Le tableau est de type référence.

[Link] → Si vous comprenez pas

10.1. Déclaration:
TypeName [] Name

Les crochets indiquent au compilateur que la variable représente un tableau. A ce moment là le

compilateur réserve un espace mémoire portant le nom du tableau.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Le type des éléments dans le tableau peut-être primitif (simple) ou référence. Dans ce cas, le tableau
d’objets stocke dans chacune de ses cases l’adresse d’un objet à mémoriser.

Après la déclaration, la variable tab existe , mais n’est pas encore initialisée à un tableau.
→ tab ne référence pas encore, elle contient la valeur null.

10.2. Création :
Deux manières de créer un tableau :

1) En l’initialisant manuellement

Exemple :

int[] tab = new {int, int, int} ou encore int tab[] = new {int, int, int}
Les deux manières sont correctes mais nous n’utilisons plus la syntaxe “int tab[]” car avec celle-ci
nous lisons directement que c’est un tableau d’entier.

2 ) En lui donnant sa taille initiale

ArrayCreationExpression:
new ​TypeName Dims ArrayInitializer
new ​TypeName DimExprs Dims

Le token ​new réserve autant de cases mémoires consécutives qu’il est indiqué entre les [], soit
tailleTableau. L’opérateur new détermine enfin l’adresse de la première case du tableau et la stocke
grâce au signe d’affectation, dans la case nomTableau créée à l’étape précédente.

Exemple :

new int [5] ;

Lors de la création les valeurs par défauts sont : Numérique : 0 Booléen : false Référence : null
Char : ’\0’

La déclaration et la création(+initialisation par défaut) du tableau peuvent se faire en même temps :

----> int [] tab = new int[3];

Black Widow’s so hot, her bone structure is giving my "bone" structure
10.3. Complément:
L'utilisation d'un tableau pour lequel l'espace n'a pas été alloué provoque la levée d'une exception:
NullPointerException
L’accès à un élément du tableau en dehors des bornes provoque la levée d’une exception:
ArrayIndexOutOfBoundsException

Les tableaux sont des objets donc il est possible d’utiliser leur attributs et leurs méthodes:
Exemple : [Link] = la taille du tableau

Les éléments d’un tableau sont indicés à partir de 0. Chaque élément peut être accédé
individuellement en donnant le nom du tableau suivi de l’indice entre [ ].

La classe ​utilitaire/statique​ [Link] n’est valable que pour les tableaux à une dimension :

● binarySearch( int [] a , int key) : a → Liste key → ce que tu cherches dans la liste
● copyOf, copyOfRange() : copie tout ou partie de tab
● fill() : remplit le tab
● hashCode() : calcul le hash
● sort() : trie le tab
● setAll(tab, opération) opération pour chaque valeur. Depuis jdk8 l'operation peut etre une
operation lambda.
● parrallelPrefix() : opération par paire.
● deep toString : représentation en profondeur
● equals​ : égalité des valeurs de deux tableaux
● deepEquals​ : égalité “ profonde”
● static <T> List <T> asList(T...a) : retourne une liste fixe (de taille fixe) à partir de l’array mis
en paramètre ou des valeurs mises en paramètre (voir ​var args​)
● static boolean[]​ copyOf​(boolean[] original, int newLength) : renvoie une copie du tableau
avec la taille spécifé. Si on à a = {vrai, faux}, et que la taille est 4 on va retourner {vrai,
faux,faux,faux} car on rajoute des éléments si il faut

On ne peut appliquer des opérations arithmétiques sur les tableaux, il est impossible
d’additionner deux tableaux par exemple.

Black Widow’s so hot, her bone structure is giving my "bone" structure

11. Tableau 2D :
Le tableau 2D est un tableaux qui contient des tableaux. Il gardent les mêmes
caractéristiques que les tableaux à une dimension. Lors de la définition de tableau, le
nombre de de crochets indique le nombre de dimensions du tableau. Un tableau à deux
dimensions s’organise non plus sur une seule ligne, mais sur des lignes et des colonnes.

Cette organisation correspond en réalité à un tableau à 1 dimension, dont chacune des

cases contiendrait un tableau à 1 dimension.

La déclaration et initialisation se base sur le même principe que le tableau à 1D :

TypeTab [][] nomTab = new TypeTab[nbLignes][nbColonnes]

Pour trouver le nombre de ligne → [Link]

Alors que pour trouver le nombre de colonnes → monTab[0].length

Différents cas :

int [][] test = new int [2]; // Ne fonctionne pas car tu déclares un tableau multidimensionnel et
tu ne donne la taille que d'une dimension.
int [][] test = new int [2][3]; Création avec 2 lignes et 3 colonnes

int [][] entiers = new int [] {1,2}; // Ne correspond pas à la grammaire java, il faut faire : int[][]
entiers = {{1}{2}};

int [][] entiers = new int [] {{1},{2}};// Aurait pu fonctionner si on avait déjà déclaré un tableau
avant

int [][] entiers = {{5,8,6,0,7},{3,3,2}};, //et si on avait mis deux paires de crochets vu que c'est
deux dimensions.

int [][] salut = new int [2][3]{3,2};// Ne fonctionne pas car on ne donne pas la taille et les
valeurs en même temps. c'est l'un ou l'autre.

Black Widow’s so hot, her bone structure is giving my "bone" structure

int [][] salut = new int [2][3]{null,null};// Ne fonctionne car on ne donne pas la taille et les
valeurs en même temps, c'est l'un ou l'autre.

12. [Link]/out/err :

System est une classe (package [Link], inclut par défaut dans chaque fichier) regroupant trois
attributs assez connus tels que in, out et err. Ceux-ci permettent à notre programme de pouvoir
communiquer avec l’utilisateur/développeur via la console.

12.1. L’attribut in
L’attribut “in” s’occupe du flux d’entrée et fait référence à la classe ​InputStream​. Typiquement ce
flux correspond à l’entrée au clavier ou à une autre source d’entrée qui doit être spécifiée.

12.2. L’attribut out

L’attribut “out” s’occupe du flux de sortie et fait référence à la classe ​PrintStream​. Il permet grâce à
des méthodes (exemple ci-dessous) de pouvoir afficher des informations sur l’écran.

12.3. L’attribut err

L’attribut “err” s’occupe par convention du flux de sortie correspondant à l’affichage de messages
d’erreur et fait également référence à la classe ​PrintStream. ​Il permet donc grâce aux mêmes
méthodes que l’attribut out utilise, d’afficher des erreurs ou informations importantes que l’utilisateur
ou développeur devrait voir.

Exemples :
//Exemple pour out

[Link](​"Hello World"​); ​// Affiche le message "Hello World"

suivi d'un retour à la ligne sur l'écran.

[Link](​"Hello World"​); ​// Affiche à nouveau "Hello World" mais

cette fois-ci sans retour à la ligne.

String hello = ​"Hello"​;

String world = ​"world"​;
[Link](​"%s %s"​, hello, world); ​// affiche de façon formaté
une variable ou plusieurs. Ici : Hello world.
/*
%s pour les string

Black Widow’s so hot, her bone structure is giving my "bone" structure

 %d pour les int
%x pour les entiers hex
%ld pour les long
%hd pour les short
*/

//Exemple pour in

Scanner sc = new Scanner([Link]);

String texte = nextLine();
[Link](texte);

try​{
​int​ a; ​// valeur décimale du premier caractère lu
a = [Link](); ​// lit le premier byte = caractère ASCII
[Link](​"Valeur: "​ + a); ​// affiche la valeur ASCII du
premier caractère
}​catch​(IOException e ){ ​//exception lancée si le premier byte ne peut
pas être lu pour une quelconque raison
[Link]([Link]());
}
/* Exemple pour err
L'attribut err reprend les mêmes méthodes que out vu qu'ils font
référence à la même classe (PrintStream).
*/

try​{
​throw​ ​new​ IllegalArgumentException(​"test"​);
}​catch​(IllegalArgumentException e){
[Link]([Link]()); ​//affiche l'exception via le flux
de sortie erreur (convention).
}

[Link](​"%3d"​, 12 ); ​// affiche 12 au bords droit de l'écran

[Link](​"%-3d"​, 12 ); ​// affiche 12 au bords gauche de l'écran

où 3 correspond au déplacement

Black Widow’s so hot, her bone structure is giving my "bone" structure

Exemple Scanner :

import [Link]; ​//entrée à préciser par cet import

public​ ​class​ ​Exemple​ {
public​ ​static​ ​void​ ​main​(String[] args) {
Scanner clavier = ​new​ Scanner([Link]);
​int​ i = [Link]();
}
}

la variable i va donc contenir l’entier que l’utilisateur entrera.

13. Try Catch:

try {
// code pouvant lancer une exception
} catch (IllegalArgumentException e){
// gestion de l ’ erreur
}

13.1. La base:
Les mots clé (token) ​try ​et ​catch ​sont utilisés pour traiter et gérer les exceptions qui
peuvent survenir dans un programme. Globalement, l'instruction try-catch se présente comme
ceci. On met les instructions qui peuvent mal se passer dans le bloc try{}et si une exception
survient, il y'a dans le catch {} les instructions qui vont régler le problème.
Ces deux mots clés sont indissociables les uns des autres, il ne peut y avoir de try sans catch
et inversement.
Exemple :
int​ a = 100 ;
try​ {
int​ b = [Link]() ;
int c = a/b ​// si on a rentré 0, il y'aura une exception car on ne peut
pas diviser par zéro
} ​catch​ (Exception e) {
[Link](« Division par 0 impossible ») ;
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

Quand une instruction se passe mal dans le try, le code du try est interrompu, et le code du
catch est exécuté. Une fois que le code du catch est terminé́, on exécute la suite du
programme qui se trouve après le bloc try-catch.

13.2. Type d’Exception:

On remarque que pour le catch, il faut définir le type et le nom de l'exception qui pourra être
attrapée. En ne précisant pas et en mettant Exception, on est certain que tout type
d'Expression sera catché car toutes les exceptions héritent de la classe Exception. Mais on
peut également choisir de n'attraper que les IllegalArgumentException, les
QuartoException(si elle a été créé) ou d'autres types d'exception, pour ce faire il suffit
simplement de modifier les parenthèses qui suivent le catch.
Exemple :
try​ {
...
} ​catch​ (IllegalArgumentException argu) {
...
}

13.3. Méthode:
Étant donné que l'Exception est un objet, elle a des méthodes. Pour pouvoir utiliser les
méthodes de l'Exception comme par exemple getMessage(), méthode ​printStackTrace ()
(montre le chemin que le programme à fait avant de tomber sur une erreur)​ on utilise :
[Link]()​ ;

13.4. Multiple catch:

Un try peut avoir plusieurs catchs afin de catcher plusieurs exceptions et réserver un
traitement spécial à chacune des exceptions. L'ordre ici est très important car il faut
commencer par le plus pertinent jusqu'au moins pertinent.
Exemple:
try​ {
...
} ​catch​(IllegalArgumentException e) {
...
} ​catch​(QuartoException ex) {
....
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

Quand le traitement à faire est le même pour plusieurs types d'expression qu'on veut catcher,
on peut utiliser les catchs multiples avec l'opérateur | pour déterminer séparer les types
d'Exception.
Exemple :
try​ {
...
} ​catch​(QuartoException | IllegalArgumentException e) {
...
}
On remarque qu'il n'y a qu'un seul Identifier qui est déclaré́ à la fin de la parenthèse. En
fonction de l'exception qui est catchée en premier, les méthodes renverront un résultat
différent.
Par exemple, si mon IllegalArgumentException affichait comme message « Pas de division
par zéro » et mon autre affichait « pas de pièce sélectionnée » et que c'est l’autre qui est
catchée alors lorsqu'on fera [Link], c'est le message de la QuartoException qui sera
sélectionné.

13.5. Finally :
Le mot clé́ (token) ​finally ​consiste à̀ exécuter une partie de code quoi qu'il arrive,
même si l'exception survient dans le try et que le try est interrompu ou même en cas
d'instruction break ou continue, la partie du code dans la clause ​finally ​sera exécutée. ​Finally
n'est pas indépendant, il doit être accompagné d'un ​try ​et donc d'un catch, il peut se placer
avant ou après le catch​.
​Ce mot clé́ est utilisé́ pour libérer les ressources. Les ressources sont des objets qu'on
peut ouvrir et qu'on doit fermer lorsqu'ils ne sont plus utilisés, comme par exemple des flux.
Avant ce moyen était le seul pour pouvoir s'assurer que ces ressources allaient se fermer
normalement. Maintenant il existe une alternative pour pouvoir fermer ces ressources quoi
qu'il arrive. On l'appelle try-with-ressources.

If your code has a return statement inside the try or catch block, the code inside the
finally-block will get executed before returning from the method.
You don't need both a catch and a finally block. You can have one of them or both of them
with a try-block, but not none of them. Due to the finally block the code still closes the filer
reader even if an exception is thrown.

Important: The finally block is a key tool for preventing resource leaks. When closing a file
or otherwise recovering resources, place the code in a finally block to ensure that resource is
always​ recovered.

Exemple:

Black Widow’s so hot, her bone structure is giving my "bone" structure

 public​ ​void​ ​openFile​(){
FileReader reader = ​null​;
try​ {
reader = ​new​ FileReader(​"someFile"​);
int​ i=0;
while​(i != -1){
i = [Link]();
[Link]((​char​) i );
}
} ​catch​ (IOException e) {
//do something clever with the exception
} ​finally​ {
if​(reader != ​null​){
try​ {
[Link]();
} ​catch​ (IOException e) {
//do something clever with the exception
}
}
[Link](​"--- File End ---"​);
}
}

If an exception is thrown inside a finally block, and it is not caught, then that finally block is
interrupted just like the try-block and catch-block is. That is why the example had the
[Link]() method call in the finally block wrapped in a try-catch block:

That way the [Link]("--- File End ---"); method call will always be executed. If
no unchecked exceptions are thrown that is. More about checked and unchecked in a later
chapter.

You don't need both a catch and a finally block. You can have one of them or both of them
with a try-block, but not none of them. Due to the finally block the code still closes the filer
reader even if an exception is thrown.

13.6. Try with resources :

Les try with ressources permettent de déclarer une ou plusieurs ressources, une ressource est
un objet ayant besoin d'être fermé lorsqu'il n'est plus utilisé. Any object that implements
[Link], which includes all objects which implement [Link], can
be used as a resource.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Grace au try with ressources, on est assuré que chaque ressource sera fermée lorsqu'elle ne
sera plus utilisée. Il n'est plus nécessaire de fermer les ressources grâce à la méthode close()
et il ne faut pas le faire.

Les ressources qui seront fermées se trouveront dans une parenthèse qui suit le try. On peut
toujours utiliser des clause finally mais la fermeture des ressources se fera avant l'exécution
de ces clauses. A noter qu'il est obligatoire de définir les ressources à fermer dans les
parenthèses qui suivent le try, sinon, erreur de compilation.
Exemple :
String path = ​"monfichier"​;
try​ (BufferedReader br = ​new​ BufferedReader(​new​ FileReader(path))) {
​return​ [Link]();
} ​catch​ (NoSuchFileException e){
// traitement de l ' absence du fichier
}

A la fin du bloc la ressource bufferedReader sera donc fermée sans qu'on ait besoin d'utiliser
la méthode close(). La ressource sera fermée à la fin des instructions, qu'elles se soient bien
passé (fin du try, pas besoin d'aller dans le catch) ou mal passée(passage par le catch).
The following example reads the first line from a file. It uses an instance of BufferedReader
to read data from the file. BufferedReader is a resource that must be closed after the program
is finished with it:
static​ String ​readFirstLineFromFile​(String path) ​throws​ IOException {
try​ (BufferedReader br =
new​ BufferedReader(​new​ FileReader(path))) {
return​ [Link]();
}
}

Because the BufferedReader instance is declared in a try-with-resource statement, it will be

closed regardless of whether the try statement completes normally or abruptly (as a result of
the method [Link] throwing an IOException).

Black Widow’s so hot, her bone structure is giving my "bone" structure

14. For Each:

14.1. La base:
Le foreach permet de parcourir toutes les valeurs d'un objet itérable.

14.2. Grammaire :

EnhancedForStatement:
for(Type Identifier : Expression) Statement

Type :

Doit être du même type que ce qui compose l'élément à parcourir sinon erreur de compilation.
(à noter que si un objet hérite d’une classe , il appartient aussi à cette classe)
(Donc pour un tableau 2D, vu qu'il est composé de tableau d'élément, il faudra qu'il soit un
tableau d'éléments, ensuite, on refera un foreach pour parcourir le tableau a une dimension).

Identifier :
Le nom de la variable du type précédemment écrit.

Expression :
Une expression itérable, comme un tableau qui a été initialisé précédemment ou encore une
liste.

A noter qu'on ne peut pas avoir accès au compteur dans le foreach, ni aux indice et on ne peut
pas modifier le contenu de l'élément Iterable dans le foreach. → OK pour consulter mais pas
pour modifier.

L'ordre dans lequel on va parcourir les éléments est l'ordre de l'élément en partant du début.

Exemple:
for (String mot : dictionnaire ){ ​//La variable mot prendra une valeur
qui est contenue dans le dictionnaire à chaque itération et cela jusqua
ce que tout le dictionnaire ai été parcourue.
[Link](mot);
}

ArrayList<Element> elements = ​new​ ArrayList<Element>();

Black Widow’s so hot, her bone structure is giving my "bone" structure

 ...
for​( Element element2 : elements) {
[Link]( element2 );
}

public​ ​void​ a
​ fficher​ ( Set<Integer> set ) {
for​( Integer val : set ) {
[Link]( val );
}
}

14.3. L'intérêt du for each vis à vis du for:

T​he only reason to use a traditional loop is when:
● the index of element is required, or
● the list has to be modified

For each:
● does not allow to modify the list
■ trying to do so will most likely result in ConcurrentModificationException
● you don't know the index of the element
■ you cannot refer to previous/next element
● efficient in all cases because uses Iterator specific for the collection
■ efficient in case of LinkedList
● works not only with every Collection, but with every Iterable
■ you can easily replace with your own class, it just has to implement Iterable
● more robust (less code, fewer special characters)

For:
● allows to modify the list, e.g.:
○ you can add extra element at the end of list and it will be also iterated
through
● you know the index
○ can be used to refer to another list of the same size
○ can be used to refer to previous/next element

Black Widow’s so hot, her bone structure is giving my "bone" structure

14.4. Pourquoi le forEach est il plus rapide que le for?
En résumé, le forEach utilise les éléments tant dis que for utilise les indices des éléments (à
développer)
Le forEach est plus rapide car on utilise directement les éléments et on les inspecte tous
(pas besoin de vérifier quand c’est terminé). On utilise un Iterator qui ne se base pas sur les
indices mais en utilisant les références.

15. If:

15.1. Grammaire :

IfThenStatement :
if ( ​Expression ​) ​Statement

IfThenElseStatement :
if ( ​Expression ​) ​StatementNoShortIf ​else ​Statement

IfThenElseStatementNoShortIf :
if ( ​Expression ​) ​StatementNoShortIf ​else ​StatementNoShortIf

15.1.1. if (Expression) Statement

L'expression doit obligatoirement être entre parenthèse et être de type booléen, sinon, erreur
de compilation. Si c'est une instruction vide alors il ne se passe rien dans le if.
Il est exécuté après avoir testé l'expression, si elle est vraie, il exécute l'instruction
(Statement), sinon, il ne l'exécute pas.

15.1.2. If Then Else Statement

if (Expression) StatementNoShortIf else Statement

Il est exécuté après avoir testé l'expression, si elle est vraie alors on exécute le bloc
d'instructions qui suis le if, si cette expression est fausse, on exécute l'instruction qui suis le
else.

Le if détermine le « si » en algorithmique, tandis que le else lui exprime le « sinon » vu en

algorithmique. A noter que le else ne peut exister sans le if. Le if est utilisé́ dans le cadre des
alternatives. C'est un mot clé́ (tout comme else).

Black Widow’s so hot, her bone structure is giving my "bone" structure

15.2. Les accolades:
Les accolades sont optionnelles, si on ne les met pas, ça compile quand même et les
instructions sont exécuté́. On met donc les accolades par convention.

Quand on exécute plus d'une instruction et qu'on omet les accolades, seule la première
instruction est considérée dans le if, ce qui n'est pas le but si par exemple, on les utilise afin
de rassembler un bloc d'instruction.

Les accolades {} permettent de délimiter un bloc, une ligne de code simple terminée par un ';'
(instruction) est un bloc. ​Si tu veux que dans ton bloc il y ait plusieurs instructions, il te faut
les accolades.
En fait, les accolades sont présentes dans la structure « normale » des conditions, mais
lorsque le code à l'intérieur de l'une d'entre elles n'est composé que d'une seule ligne, les
accolades deviennent facultatives.

Exemple:
if​ ([Link]())
[Link]();
[Link](​"Hello"​); ​//n'exécute que la première condition.
else
[Link]();

​if​ (ttc < 1000.)

tauxr = 0; ​// 1 instruction donc ok
else​ ​if​ (ttc < 2000.)
tauxr = 1.; ​// 1 instruction donc ok
else​ ​if​ (ttc < 5000)
tauxr = 3.; ​// 1 instruction donc ok
else
tauxr = 5.; ​// 1 instruction donc ok

if (ttc < 1000.) { ​//ici, on a plusieurs instructions donc il faut mettre des
accolades.
tauxr = 0;
tauxr2 = 1;
} ​else​ {
tauxr3= 0;
tauxr4 = 1;
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

15.3. Le dangling
Le problème du ​dangling else est un problème de ​programmation informatique qui résulte de
l'ambiguïté de l'interprétation de la clause ​sinon dans l'imbrication de deux instructions
conditionnelles de la forme ​si-alors-sinon​. Cela donne lieu à une ambiguïté d'interprétation
lorsqu'il y a des instructions imbriquées.
Consider the following statement.
if​ ( num > 0 )
​if​ ( num < 10 )
​ aaa"​ ) ;
[Link]( "
​else
[Link]( "​ bbb"​ ) ;

In the example above, the ​else is indented with the ​inner if statement. It prints ​"bbb" only if
num > 0​ and ​num >= 10​, which means it prints only if ​num​ is 10 or greater.

In the example below, the ​else​ is indented with the ​outer​ if statement.
if​ ( num > 0 )
​if​ ( num < 10 )
[Link]( ​"aaa"​ ) ;
else
[Link]( ​"bbb"​ ) ;

This prints if ​num <= 0​. Depending on which ​if the ​else is paired with, you can get different
results.
By now, you should know that Java doesn't pay attention to indentation. So both examples
above are the same to Java, which means that it must pick one version over the other.
Which one does it pick? It picks the first one. This phenomenon of having to pick between
one of two possible ​if​ is called the ​dangling else​.

An ​else​ matches with the nearest, previous, unmatched ​if​ that's not in a block.
By ​not in a block​, I mean that the ​else​ is outside the block that the ​if​ is inside.
Thus,
if​ ( num > 0 )
​if​ ( num < 10 ) ​// Previous unmatched if
[Link]( ​"aaa"​ ) ;
​else​ ​// Matches with previous unmatched if
[Link]( ​"bbb"​ ) ;

What if we wanted the ​else​ to match with the first ​if​?

Then, we need braces.
if​ ( num > 0 ) ​// Previous unmatched if

Black Widow’s so hot, her bone structure is giving my "bone" structure

 {
​if​ ( num < 10 ) ​// Unmatched, but in block
[Link]( ​"aaa"​ ) ;
}
else​ ​// Matches with previous unmatched if not in block
[Link]( ​"bbb"​ ) ;

The ​else matches with the previous, unmatched ​if not in a block. This happens to be the outer
if. There is an unmatched ​if that's the inner if, but that's in a block, so you can't match to it.
Notice the ​else sits outside of the block. An ​else can not match to a previous ​if if the ​else is
outside a block, while the previous ​if​ is inside.

Exemple:
if​ ([Link]())
if​ ( resident . isVisible ())
resident .greet(​"Hello"​);
else
[Link]();
//a quelle condition appartient le else? Comment résoudre le problème?

if​(x > 0) // first/outer unmatched if

if​(x < 10) ​// second/inner unmatched if
print(A)
else // matches with first unmatched if
print(B)

Solution:
if​(x>0){
if​(x < 10)
print(A)
else
print(B)
}

An ​else ​keyword always ​associates with the ​nearest ​preceeding ​if ​keyword that ​does
NOT cause​ a ​syntax error

15.4. Différents types:

L'expression booléenne dont on traite dans la grammaire peut être de différentes formes :
● un opérande unaire comme une négation (!) ou une variable (-x).
● un opérande ternaire/conditionnel “?” (​The conditional operator ? : uses the boolean
value of one expression to decide which of two other expressions should be
evaluated.)

Black Widow’s so hot, her bone structure is giving my "bone" structure

 ● les comparateurs ( <, > ≥= , ≤=,!=)
● le true et le false, classique
● un appel de méthode qui renvoie un booléen
● une variable booléenne
● les opérateurs logiques ||, &&.

Il est important de savoir que le if-else simple avec une instruction peut être remplacé par un
operateur ternaire “?”.
Exemple :
String salutation = (heure > 12) ? « Bonjour » : « Bonsoir»
Le premier choix sera effectué si la condition est vraie, sinon il ne sera pas effectué́.

Il existe une expression conditionnelle exprimée avec l'opérateur ternaire, (qui possède trois
opérandes) nous permettant d'obtenir la même structure et le même résultat. Voici une
deuxième version de la fonction max() en utilisant cet opérateur ternaire.

(a > b) ? a : b; is an expression which returns one of two values, a or b. The condition, (a > b),
is tested. If it is true the first value, a, is returned. If it is false, the second value, b, is returned.
Whichever value is returned is dependent on the conditional test, a > b. The condition can be
any expression which returns a boolean value.

Exemples:
if​ (i == 2) {
i = 6;

Black Widow’s so hot, her bone structure is giving my "bone" structure

 }

if​ (!n) {}

if​ (i == 3) {
i = 4 ;
} ​else​ {
i = 5 ;
}

if​ (i==1)
i = 2;
else
i = 3;

16. Var args: méthodes à arguments variables

16.1. La base:
Il est possible de définir une méthode dont le nombre d’arguments est variable. Varargs
donne une flexibilité sur la façon dont on utilise une méthode.

16.2. Notation:
La notation « … » utilisée dans un tel contexte est appelée « ellipse ». L’ellipse concerne des
arguments d’un type quelconque, primitif ou objet et peut être accompagnée d’arguments
classiques.

Exemples:

public​ ​void​ ​function​(​char​ c, ​int​... x) {...}

function(​'a'​, 1);
function(​'b'​, 1, 2);
function(​'c'​, 1, 2, 3);

Black Widow’s so hot, her bone structure is giving my "bone" structure

16.3. Règles:
Une ellipse est placée après le type de l’objet
Une ellipse est unique dans une méthode
Une ellipse est toujours le dernier argument de la méthode

​Exemples:
Valides:
public​ ​void​ ​parkPlanes​ (Plane... p) {...}

public​ ​void​ ​parkPlanes​ (​int​ nbrParkings, Plane... p) {...}

Invalides:
public​ ​void​ ​parkPlanes​ (Plane p...) {...} ​//bad syntax

public​ ​void​ ​parkPlanes​ (Plane... p, Helicopter... h) {...} ​//too many var-args

public ​void ​parkPlanes (Plane... p, ​int nbrParkings) {...} ​//var-arg must be

the last args

Utilisation:
​ nt​ s
public​ i ​ um1​(​int​[] numbers){...} ​//calcule une somme
public​ i​ nt​ s​ um2​(​int​... numbers){...} ​//calcule une somme

Les … représentent l’ellipse. Le type suivit de l’ellipse indique que la méthode peut accepter
un nombre variable d’arguments.
Quelle est la différence? L’appel de méthode.
Nous avons le tableau d’entier suivant: int [ ] Array = {2,3,4}; sum1 et sum2 sont capables de
faire la somme des éléments du tableau: sum1(Array), sum2(Array).
On pourrait aussi passer les éléments du tableau dans les params de la méthode sum2.
On ne sait pas le faire avec la méthode sum1.

sum1(2,3,4); ​//ne compile pas

sum2(2,3,4); ​//compile, la somme est 9

Black Widow’s so hot, her bone structure is giving my "bone" structure

17. Grammaire (non fini):

17.1. Principe:
La nécessité de pouvoir écrire un compilateur, la nécessité de pouvoir décrire le langage
imposent que les règles soient clairement décrites. C’est le rôle de la grammaire.

17.2. Compilation :

17.3. Fonctionnement :
Une grammaire est une description finie de l’infinité des programmes
Un mot (​token​) doit être légal, grammaire lexicale
Une séquence de mots doit être légale, grammaire syntaxique
Le tout doit avoir un sens, sémantique

Black Widow’s so hot, her bone structure is giving my "bone" structure

Exemple du français :
“dkfjklsdjflds”​ n’est pas un mot légal , il y a erreur de grammaire lexicale
“​Ce que tu as appris, désapprendre tu dois!​” n’est pas une séquence légale, on ne respecte
pas la grammaire
“​Loïc est modeste​” n’as pas de sens, erreur sémantique.

Fonctionnement d’une grammaire :

- symbole de départ : nom du nouveau token à créer. Il est en italique suivi de 2 points.
- règles de productions (productions) : l’agencement des symboles terminaux entre eux.
- symboles terminaux : les symboles de bases de la grammaires (les lettres et les
chiffres)
Un code est correct s’il peut être produit par la grammaire.
Exemple :
Un nombre décimal naturel

Nombre :
Chiffre
Chiffre Nombre
Chiffre​:
one of 0 1 2 3 4 5 6 7 8 9

Ici, Nombre est le symbole de départ, Chiffre et Nombre sont des symboles terminaux.
Chiffre est défini comme étant soit 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

La règle de production de Nombre est la suivante : Un nombre est un Chiffre (première ligne)
OU un Chiffre suivi d’un Nombre (deuxième ligne).

La deuxième ligne stipule en fait qu’un Nombre est un Chiffre suivi d’un Nombre et comme
Nombre est un Chiffre ou un Chiffre suivi d’un nombre, tout nombre peut être écrit grâce à
cette grammaire.

Exemple avec 1234:

1234 est le Chiffre 1 suivi du Nombre 234. 234 est le Chiffre 2 suivi du Nombre 23. 23 est le
Chiffre 2 suivi du Nombre 1. 1 est le chiffre 1. Par conséquent, il est possible d’écrire le
nombre 1234 (ainsi que tout autre nombres) avec la grammaire de Nombre.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Un palindrome binaire

Palindrome ​:
0
1
0 ​Palindrome ​0
1 ​Palindrome ​1

Explication :

Un palindrome peut être 0 OU 1 OU 0 suivi d’un Palindrome suivit de 0 OU 1 suivit d’un

Palindrome suivi de 1.

0 est donc un palindrome

1 est un palindrome
00 n’est pas un Palindrome selon cette grammaire car il faut être soit 0 , or il est 00 ou 0
Palindrome 0 , or dans ce cas là le palindrome est absent. => 00 n’est pas un palindrome
000 est un Palindrome car il commence et termine avec 0 et il possède un Palindrome en son
milieu qui est 0.
1111 n’est pas un palindrome car 11 n’est pas un palindrome (selon la définition de cette
grammaire)
11111 est un palindrome

17.4. Lexicale:
- Les symboles terminaux sont les caractères (characters of Unicode characters set).
- Les règles de production forment les mots (tokens), éléments d’entrée (input
elements) de la grammaire syntaxique.

UnicodeInputCharacter :
RawInputCharacter
UnicodeEscape

RawInputCharacter :
any Unicode character

UnicodeEscape :
\UnicodeMarker HexDigit HexDigit HexDigit HexDigit

UnicodeMarker :
u
UnicodeMarker u

Black Widow’s so hot, her bone structure is giving my "bone" structure

HexDigit​ :
one of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

InputElement:
Comment
WhiteSpace
Token

13.4. Syntaxique:

La grammaire syntaxique (syntactic grammar)

Les symboles terminaux sont les tokens
Les règles de production permettent de définir ce
qu’est un programme syntaxiquement correct

Parmi les éléments importants d’un programme, on

trouve :
I Les expressions
Représentent les « calculs »
Ont une valeur et un type
On y reviendra continuellement sans jamais tout faire en
une fois
Voir [jls8] p 462(482)
I Les instructions
I Les expressions-instructions

Black Widow’s so hot, her bone structure is giving my "bone" structure

18. Trier
Java permet déjà de trier des listes ou des tableaux mais si on cherche à trier des objets non
standardisé c’est plus compliqué (​Des objets qui ne sont pas inclus dans Java de base. Quand tu crées toi
même un nouvel objet en gros.)​.

Il existe la classe Comparable qui est une Interface ne possédant qu’une méthode et qui
définit un “ordre naturel”. (Seul méthode : compareTo)

int​ ​compareTo​(Object o)

Pour rendre un objet comparable on va le faire implémenter Comparable

public​ ​class​ ​Explorer​ ​implements​ ​Comparable​<​Explorer​> {

)

Ensuite on va définir le compareTo comme on le souhaite. Celui ci doit renvoyer un nombre

> 0 si l’objet qui appelle le compareTo est plus grand que l’objet mit en paramètre. S'ils sont
égaux, on renverra 0. Sinon on renverra un nombre < 0.

@Override
public​ ​int​ ​compareTo​(Explorer e) {
if​ (​this​.[Link]() > [Link]().getValue()) {
return​ 1; ​// si l'instance qui appelle la méthode est
supérieure à l'objet e
} ​else​ ​if​ (​this​.[Link]() < [Link]().getValue()) {
return​ -1; ​// si l'instance qui appelle la méthode est
inférieure à l'objet e
} ​else​ {

Black Widow’s so hot, her bone structure is giving my "bone" structure

 return​ 0; ​// si l'instance et e sont égales
}
}

Une fois le compareTo créé, on peut utiliser les méthodes de collections pour trouver le max ,
le min ou même trier une collection.

import​ [Link];
public​ ​class​ ​Game​ ​implements​ ​Model​ {

​private​ ​final​ List<Explorer> EXPLORERS;

​@Override
public​ List<Explorer> ​getWinners​() {
​return​ [Link](EXPLORERS);
}
}

Pour trier une Collection, on va utiliser la méthode sort de la classe static Collections ou celle
de Arrays.
static​ <T extends Comparable<? ​super​ T>> ​void​ ​sort​(List<T> list)

L’entête de cette méthode indique qu’elle a besoin d’une List Comparable. (ne suis pas sûr
mais autant dire ça à Codutti s’il demande)

Cette méthode va trier la liste passée en paramètre, (du plus petit au plus grand) selon
l’ordre définir par le compareTo. (avec une liste d'Explorateur, on aura l'explorateur avec la
plus petite fortune en premier et celui avec la plus grosse en dernier)

Si le compareTo n’est pas défini ou si on ne souhaite pas l’utiliser, on peut utiliser un

Comparator. Pour cela, il faudra créer une classe qui va implémenter Comparator.
Si on veut un ordre personnalisé (autre que l’ordre naturel), trié selon un critère choisis, on
aura recours à un comparator.

Par chance, Java nous fournit une interface Comparator.

Black Widow’s so hot, her bone structure is giving my "bone" structure

 public​ ​class​ ​VideoLikesComparator​ ​implements​ ​Comparator​<​Video​> {
@Override
public​ ​int​ ​compare​( Video o1, Video o2) {
​return​ [Link]([Link](),[Link]());
}
}

Integer retourne la valeur 0 si param1 == param2; une valeur inférieure à 0 si param1 <
param2 et une valeur > 0 si param1 > param2

L’entête de la méthode sort sera alors :

static​ <T> ​void​ ​sort​(List<T> list, Comparator<? ​super​ T> c)

Exemple :

public​ ​static​ ​void​ ​main​( String[] args) {

Video[] tab = {
new​ Video(​"Loic"​, ​"Le retour de Yugi Muto"​, 45),
new​ Video(​"Alexia"​, ​"E.T."​, 12),
new​ Video(​"Youri"​, ​"Sex Academy"​, 98 078),
new​ Video(​"Melvin"​, ​"La calculatrice tueuse"​, -56)
};
[Link](tab, ​new​ VideoLikesComparator()); ​//
instanciation de VideoLikesComparator en utilisant le constructeur qui
ne fait rien(Puisqu'on a juste besoin de compare)
[Link]([Link](tab));
}

Et là le tableau sera trié en fonction du nombre de like.

Si une classe n’est utilisée qu’une seule fois on peut utiliser une classe anonyme. C’est une
classe locale qui n’a pas de nom et qui est à usage unique. (comme en JavaScript)

Black Widow’s so hot, her bone structure is giving my "bone" structure

Exemple :
public​ ​static​ ​void​ ​main​(String [] args) {
//...Création du tableau
[Link](tab, ​new​ Comparator<Video>() {
​public​ ​int​ ​compare​ (Video o1, Video o2) {
​return​ [Link]([Link](), [Link]());
}
});
}

Explication :
[Link] permet de trier le premier paramètre (tab dans ce cas) de la manière du second
paramètre en créant un comparator d’objet Vidéo qui contiendra les 2 objets Vidéo à
comparer.
Le return va appeler la méthode compare de la classe Integer (class Integer car on ne peut
pas comparer des int, nous les transformons donc en Integer). Cela va donc comparer le
nombre de Likes de l’objet 1 par rapport à l’objet 2 et il va retourner :
- la valeur 0 si param1 == param2
- une valeur inférieure à 0 si param1 < param2
- une valeur supérieur à 0 si param1 > param2

19. toString:
En Java, la méthode toString() retourne une représentation d’objet sous forme de chaîne de
caractères.
Elle est définie dans la classe [Link] mais elle peut être Overridé dans une classe
enfant.

Exemple :
public​ ​Etudiant​ (​int​ unNumero, String unNom, int annéeEtude) {
numero = unNumero;
nom = unNom;
annéeEtude = 1;
}
@Override
public​ String ​toString​() {
return​ ​"nom + "​,​" + numero + "​,​" + annéeEtude"​;
}

Etudiant corentin = ​new​ Etudiant(45022, ​"Captain America"​, 1​);

[Link](corentin);
[Link](); //aReussi est une methode incrémentant le

Black Widow’s so hot, her bone structure is giving my "bone" structure

 nombre d’années
[Link](corentin);

Affichera :
Captain America, 45022, 1
Captain America, 45022, 2

Lorsque le ​[Link](corentin); est fait, il va rechercher la méthode toString() qui a été créée
dans la classe Etudiant car “captain” est un objet Etudiant.

19.1. Pourquoi toString() et pas [Link]() ?

La méthode toString() d’un objet sera déclarée dans sa classe et va donc permettre la même notation
pour chacun de ses objets. Un [Link]() par contre se placera généralement dans la main
(ou dans la view) afin d’afficher un texte personnalisable pour chacun des objets grâce à des getters.
Attention : Un [Link]() directement effectué sur un objet ([Link](vaisseau))
affichera la référence vers l’emplacement mémoire.
Exemple :
Avec toString()

@Override
public​ String ​toString​() {
​return​ ​this​.heure + ​":"​ + ​this​.minute + ​":"​ + ​this​.seconde;
}
public​ ​static​ ​void​ ​main​(String[] args) {
Moment moment1 = ​new​ Moment(3, 55, 12);
[Link](moment1);
}

Affichera : 3:55:12
Sans toString()
public​ ​static​ ​void​ ​main​(String[] args) {
Moment moment1 = ​new​ Moment(3, 55, 12);
[Link](moment1);
}

Affichera : Moment{heure=3, minutes=55, seconde=12}

Pourquoi ?!
Car un objet à un toString() de base. D’où le @Override du toString()

Avec [Link]()

Black Widow’s so hot, her bone structure is giving my "bone" structure

 public​ ​static​ ​void​ ​main​(String[]args){
Moment moment1 = ​new​ Moment(3,55,12)
[Link]([Link]() + ​":"​ + [Link]()
+ ​":"​ + [Link]());
}
Affichera : 3:55:12

20. Flux englobant :

A VÉRIFIER !
Une entrée/sortie en Java consiste en un échange de données entre le programme et une autre source,
par exemple la mémoire, un fichier, le programme lui-même… Pour réaliser cela, Java emploie ce
qu'on appelle un ​stream​ (qui signifie « flux »).

Il existe plusieurs flux :

F​lux standard / Flux binaire / Flux de caractère (texte) / Flux englobant / Flux formaté / Flux de
type primitif​.

20.1. Le flux englobant :

Le flux englobant se place autour d’un flux existant, il modifie son comportement. Cela
permet de faire de la bufferisation, compression, concaténation.

Observons un flux englobant ligne par ligne :

[Link] reader = ​new​ StringReader(​"Un\nDeux"​);
[Link] in = ​new​ BufferedReader(reader);
[Link] s = ​null​ ;
4.​while​((s = [Link]()) != ​null​) {
5. [Link]( s );
6.}
[Link] ();

Ligne 1 : L’objet reader est créé, il contient “Un/nDeux”

Ligne 2 : L’objet in est créé, il permet de bufferiser l’objet reader
Ligne 3 : L’objet s’est créé et initialisé à null
Ligne 4.5.6 : La boucle va boucler tant qu’il y a quelque chose à lire.
/ ! \ readLine permet de lire le retour de ligne mais ne le retourne pas et retourne null quand
il n’y a plus rien. / ! \
Ligne 7 : Ferme le in

Black Widow’s so hot, her bone structure is giving my "bone" structure

20.2. Type primitif :
Exemple de flux sur un type primitif :
DataOutputStream out = ​new​ DataOutputStream(
​new​ FileOutputStream(​"[Link]"​));
[Link](10);
[Link](1.2);
[Link] ();

20.3. Les flux formatés :

Les flux formatés permettent une grande liberté de format pour les entrée/sorties (I/O)
c’est-a dire qu’on peut définir complètement une sortie écran (exemple : centrer un texte à
l’écran)
Utilisation de la classe Scanner (scanner, nextInt, …) et de la classe printStream (print,
printf, prinIn, …)

Exemple :
PrintWriter out = ​new​ PrintWriter(
new​ FileOutputStream(​"[Link]"​));
[Link](10);
[Link]( ​"Hello"​ );
[Link] ();

20.4. Sortie standard :

Certains flux sont prédéfinis dans la classe System (in, out, err sont des flux)

Utilisation courante : [Link](“themeAvenger”);

Système -> classe
Out -> attribut de la classe
Println -> méthode de out

Black Widow’s so hot, her bone structure is giving my "bone" structure

21. this/super:

21.1. This:
This ​sert à référencer l’instance de l’objet en cours d’utilisation( à soi même) .Elle apparaît
dans différents contextes : constructeur, attribut et méthode

Il permet aussi de passer l’objet en paramètre

public​ ​void​ ​Hulktransfo​ (Action coup) ​throws​ IllegalActionException {
[Link](​this​);
}

Enfin il rend le code plus lisible car c'est un raccourci de langage !

On peut également utiliser this pour appeler le constructeur de la classe courante.
Exemple :

public​ c ​ lass​ ​Point​{

​private​ ​int​ x,y ;
​public​ ​Point​(​int​ x, ​int​ y){
​this​.x = x ; ​// Au lieu de x = x ;
​this​.y = y ; ​// Au lieu de y = y ;

Black Widow’s so hot, her bone structure is giving my "bone" structure

 }
​public​ P​ oint​(){
​this​(1,1) ; ​// Va faire appel au constructeur Point avec
deux entiers en paramètres
[Link](Coucou) ;
}
}

Je me permet de rajouter : Lorsque qu’un constructeur en appel un autre, l’instruction doit

bien être la première instruction du constructeur, comme illustré ci dessus. (hop 30
secondes d’oral de gagné)

21.2. Super:

Il fait référence au constructeur parent. Et doit être la première instruction dans un

constructeur enfant. On parle ici d’héritage car pour référencer d’un constructeur
parent on doit hériter de celui-ci, et on peut le faire grâce au mot clé extends où on va
récupérer les attributs et les méthodes du parent.

public​ ​class​ ​Point​ {

​public​ ​Point​ (​double​ x, ​double​ y) {...}
}
public​ ​class​ ​ColoredPoint​ ​extends​ ​Point​ {
​private​ Color color ;
​public​ ​ColoredPoint​ (​double​ x, ​double​ y) {
​super​(x,y) ; ​// on fait appel au constructeur de la classe
Point
​this​.color = [Link] ;
}
}

public​ ​ironMan​ (){

​super​.getThor () ; ​// va utiliser le getThor() qui se trouve
dans la classe thor. Classe parente de la classe courante
}

On peut également utiliser this comme pour appeler le constructeur de la classe

Dans un constructeur enfant , super(...) doit être la première instruction

Même si le constructeur n’a pas de paramètres → super(...) est obligatoire
Tout ceci apparaît dans le concept d’héritage.(seul les classes en public et en protected
peuvent être utilisée dans une classe héritée.

Black Widow’s so hot, her bone structure is giving my "bone" structure

22. Throw(s):

22.1. Throw
Permet de déclencher une exception.
Exemple :
if​([Link]()) {
​throw​ ​new​ SandException(​"...fuck..."​);
}
Dans cette exemple, quand [Link] sera true, une erreur va être envoyée et “...fuck…”
sera affiché à l’écran.

22.2. Throws
Permet à une méthode de lancer une exception contrôlée. Le throws doit apparaître dans l’entête de la
méthode.
public​ ​void​ ​methode​() ​throws​ OupsException {}

Le fait de déclarer une exception dans la signature de la méthode indique au compilateur

que la méthode peut renvoyer une exception, et il obligera les développeurs qui utilisent
cette exception à la traiter (ou à la renvoyer).

Quand on appelle une méthode qui peut lancer une exception contrôlée, on doit soit la gérer
par un “try-catch” soit déclarer qu’on la lance par un “throws” (on laisse passer l’exception).

public​ ​static​ ​void​ ​main​(String[] args) {

int​ a = 1;
int​ b = 5;

do​ {
if​(a==3) {
throw​ ​new​ IllegalArgumentException(​"message"​);
} ​else​ {
[Link](​"Valeur de a = "​ + a);
}
} ​while​(a++ < b);
}
Il va donc afficher :
Valeur de a = 1

Black Widow’s so hot, her bone structure is giving my "bone" structure

 Valeur de a = 2
Exception in thread ​"main"​ [Link] : message
blablablabla...

22.3. RuntimeException
Les ​RuntimeException ​sont un cas particuliers parmis les exceptions, puisqu'elles n'ont
pas besoins d'être déclaré ni traité.
En effet, il s'agit d'exception relative aux erreurs de programmation, et qui ne devrait
normalement pas arriver... Si on devait toutes les traiter on se retrouvera avec des try/catch
partout ce qui rendrait le tout complètement illisible.

Donc pour les ​RuntimeException ​le ​throws ​est inutile... mais il est bien de le préciser car
cela indique aux développeurs qui utilisent la méthode qu'elle peut renvoyer une telle
exception. Il est bien également de le préciser dans l'entête de la javadoc
/**
* ...
* ​@throws​ ArithmeticException si j == 0
*/
​public​ ​static​ ​double​ ​m​(​int​ i, ​int​ j) ​throws​ ArithmeticException {
​return​ i/j;
}

PS : Une ArithmeticException fait partie d’une RuntimeException

Petit rappel :

Toutes les exceptions héritent de la classe Throwable, c’est la classe qui permet la gestion
des erreurs.

Black Widow’s so hot, her bone structure is giving my "bone" structure

La classe ​Error ​représente un erreur grave. Le programme s'arrête instantanément dès
l'apparition d'une exception de la classe Error.
La classe ​Exception ​représente des erreurs moins graves. Les exceptions héritant de la
classe RuntimeException n'ont pas besoin d'être détectées impérativement par des blocs
try/catch.

22.4. En résumé
Throws permet de prévenir le compilateur qu’une erreur pourrait être levée dans la méthode
en question.
Throw par contre va permettre de lever et de gérer une exception “manuellement”.
Exemple :
Une classe A (la voiture) fait appelle à la classe B (le moteur) qui contient une erreur.
La classe B :
public​ ​class​ ​Moteur​ {
public​ ​void​ ​avancer​(){
//augmente la vitesse
if​(vitesse > 130) {
throw​ ​new​ codeRouteException(​"Tu vas trop vite connard
!"​);
}
}
}
La classe A va donc être “préparée” à recevoir cette erreur va donc la gérer.
La classe A :
public​ ​class​ V
​ oiture​ {
public​ ​static​ ​void​ ​main​(String [] args) {
​try​ {
[Link]();
} ​catch​(codeRouteException e) {
[Link]();
}
}
}

23. Expression régulière

Une expression régulière aussi appelé “regex” est une chaîne de caractères avec une
syntaxe précise permettant d’obtenir un ensemble de chaînes composés de caractères
possibles.

Exemple:

Black Widow’s so hot, her bone structure is giving my "bone" structure

[Link]@[Link]​ étant une adresse mail, un regex serait un algorithme
permettant de vérifier la syntaxe de l’adresse e-mail, il vérifierai s'il existe bien une chaîne
de caractères avant et après le @ (et que @ existe), si la chaîne de caractères qui précède
le @ contient des caractères tels que le . ou encore _ et que cette chaîne peut être
composée de l’alphabet qu’il soit en majuscule [A-Z] ou minuscule [a-z] et pour finir qu’elle
puisse également contenir les chiffres [0-9].

Le regex pour l’adresse mail donnerait ceci:[]

^[a-z0-9._-]+@[a-z0-9._-]{2,}\\.[a-z]{2,4}$

Chaque caractère permettant de réaliser notre regex tels que ​^​,​$​,​*​,​+​,​{}​,​[]​, … sont appelés
métadonnées.

^​ ce caractère spécifie le début d'une chaîne de caractères.

$​ celui-ci y spécifie la fin.

L'intervalle ​[a-z0-9._-]+​ représente dans un premier cas a-z toutes les lettres de l'alphabet
minuscules (il ne contient pas les caractères accentués) ensuite 0-9 représente donc les
chiffres de 0 à 9 et pour finir nous autorisons que notre chaîne se compose de . _ et -
Le + se trouvant à la fin de l'intervalle signifie que ce qu'il le précède (donc l'intervalle) peut
être répété 1 ou plusieurs fois.

Après le @ nous avons donc le même intervalle que celui qui précède le @ à l'exception du
+ qui devient ​{2,}​ cela signifie "au moins 2 fois ou plus".

Nous avons ensuite ​\\.​ qui permet de définir le point pour domaine ([Link]), on y
ajoute devant 2 anti-slash car le caractère . dans un regex correspond à "tout caractère".
(Par exemple, le regex "[Link]" on pourrait mettre n'importe quel caractère à la place du point).
Un anti-slash suffirait pour spécifier qu'on veuille le symbole point mais le deuxième
anti-slash permet déspécialiser le premier car un \ est également un caractère ayant une
signification dans un regex.

Et pour finir nous nous occupons du nom de domaine, il peut donc contenir les minuscules
a-z mais seulement de 2 à 8 caractères car le minimum de caractères que peut contenir un
nom de domaine est 2 et son maximum donc 8. (exemple: [Link] [Link])

Exemple avec un code java :

import​ [Link];

String regex = ​"^[a-z0-9._-]+@[a-z0-9._-]{2,}\\.[a-z]{2,4}$"​;

String mail = ​"[Link]@[Link]"​;

Black Widow’s so hot, her bone structure is giving my "bone" structure

 [Link]([Link](regex, mail)); ​// retourne vrai

23.1. Les métadonnées :

23.2. Les types génériques :

23.3. Les quantificateurs :

*: ce caractère signifie une apparition de son précèdent au moins 1 fois ou plus.

+ : ce caractère signifie une apparition de son précèdent 0, 1 ou plusieurs fois.
? : celui-ci signifie une apparition de son précèdent 0 ou 1 fois.

Black Widow’s so hot, her bone structure is giving my "bone" structure

24. Filtrer(fonctionnel):
JAVA 8 introduit les expressions lambda :

ps : Un itérateur est un objet permettant de parcourir différent élément d’une collection et est
muni des méthodes hasNext(), next(),previous(). Il est utilisé implicitement par le foreach

→ Utiliser avant .

24.1. Le Stream:
Depuis Java 8 , on nous propose l’API Stream pour simplifier des traitements sur des
collections ou des tableaux ! ( Stream est un objet ! )

Un stream se construit à partir d’une source de données et possède un certain nombre de

propriétés spécifiques :

Le stream ne stocke pas de données. Il ne fait que transférer d’une source vers une
suite d’opérations

Un stream peut ne pas être borné (il a pas de limite , il est infini). ( mais Il faudra
cependant veiller à ce que nos opérations se terminent en un temps fini )

Black Widow’s so hot, her bone structure is giving my "bone" structure

Un stream n’est pas ré[Link] on veut réutiliser les données de la source sur laquelle il
avait été construit, nous serons obligés de reconstruire un nouveau stream sur cette même
source

Un stream ne modifie pas les données de la [Link] il doit modifier les données
pour les réutiliser, il va construire un nouveau stream à partir du stream initial. ( Important
pour la cohérence du parallélisme !!)

Le chargement des données pour des opérations sur un stream s’effectue de façon
lazy. Cela permet d’optimiser les performances de nos applications. Par exemple, si l’on
recherche dans un stream de chaînes de caractères une chaîne correspondant à un certain
pattern, cela nous permettra de ne charger que les éléments nécessaires pour trouver une
chaîne qui conviendrait, et le reste des données n’aura alors pas à être chargé.

Les données passant par le stream peuvent être parcouru de 2 manières différentes.

Séquentiellement : un à un
Parallèlement : plusieurs à la fois
En fonctionnel il existe 2 type de méthode : intermédiaire et terminal (voir 24.2 et 24.3)

On peut appliquer à un stream plusieurs méthodes intermédiaires mais une seul terminale

24.1.1. Création d’un stream:

De nombreuses possibilités d’en créer un : via une liste, via un tableau et vias des méthodes
de générations

24.2. Les opérations intermédiaires(Filter):

Les opérations intermédiaires ([Link] ou [Link] par exemple) sont effectuées de
façon lazy et renvoient un nouveau stream, ce qui crée une succession de streams que l’on
appelle stream pipelines. Tant qu’aucune opération terminale n’aura été appelée sur un
stream pipelines, les opérations intermédiaires ne seront pas réellement effectuées

Exemple d’utilisation du Filter​( méthode permettant de garder que certains éléments) :

Black Widow’s so hot, her bone structure is giving my "bone" structure

Black Widow’s so hot, her bone structure is giving my "bone" structure
limit (ne garde que les premiers éléments

sorted(trie le stream)

map (applique une méthode sur chaque élément )

24.3. Les opérations Terminaux:

Quand une opération terminale sera appelée ([Link] ou [Link] par
exemple), on va alors traverser tous les streams créés par les opérations intermédiaires,
appliquer les différentes opérations aux données puis ajouter l’opération terminale.

Exemple :

forEach ( équivalent du for each)

collect ( convertit le stream en liste )
any / all /noneMatch ( teste le stream )

findFirst/Any (cherche un élement)

count (compte le nombre d’éléments)

sum/average (somme / moyenne sur des numériques)

max/min( chercher le max / min)

Black Widow’s so hot, her bone structure is giving my "bone" structure

24.4. itérer:

on pourrait utiliser un for each, mais les expressions fonctionnelles nous permettent déjà de
faire un .forEach.

cependant, on aura préférence à utiliser un ​stream​ pour que ça soit plus performant:

25. Wrapper, (Un)Boxing :

à compléter avec
[Link]
ccU/edit?ts=5ae5befa
rajouter le troncage

25.1. Problème avec liste :

Les listes n’admettent que des objets comme élément. Il est alors impossible de mettre un type primitif
dans une liste. Comment faire pour tout de même avoir des listes de booléen , d’int ou de char? La
solution est de transformer un type primitif en objet. C’est le wrapping!

Black Widow’s so hot, her bone structure is giving my "bone" structure

25.2. Wrapping :
Wrap : enveloppe en anglais.
Le wrapping consiste à envelopper un type primitif dans un objet. Un int sera enveloppé dans Integer,
un boolean dans Boolean , char dans Character etc

List <​int​> list = ​new​ ArrayList<>(); ​// Attention, notation illégale ,

on ne peut créer une liste composée d'éléments de type primitif.

List <Integer> list = ​new​ ArrayList<>(); ​//Notation valide.

[Link](1); ​// Valide car 1 va être enveloppé par Integer.

int​ nombre = [Link](0); ​// Valide car même si la liste renvoie un

integer , on peut le convertir en int une fois sorti de la liste.

Integer nombre2 = [Link](0); ​// Valide aussi

int n1 = 7; // valeur 7 stocké directement dans la pile.

Integer n2 = 8 // Integer est un type référence.

la valeur 8 est stockés dans les attributs de l'instance n2 de type Integer. L'objet est stocké
sur le tas et une référence pointant vers cet objet est stockée dans la pile.

Attention , il faut savoir que Byte, Short, Integer, Long,Float et Double (tous les Wrappers qui
représentent des nombre) font partis de la classe Number qui fait partie de la classe Object

25.2.1. Les classes wrappers :

Les classes wrapper sont toutes "final":

Black Widow’s so hot, her bone structure is giving my "bone" structure

 ​ inal​ ​class​ ​Integer​ ​extends​ ​Number​ ​implements​ ​Comparable​<​Integer​>
public​ f
{
​// ...
}
Cela veut dire qu'on peut les utiliser tel quel mais on ne peux pas en hériter.
(pas de ​public class MonInteger extends Integer {}​)

25.2.2. Les Wrappers et leurs membres:

Attention cette partie n’est pas spécialement à connaître par coeur , seuls quelques
méthodes et attributs suffisent. Je n’avais pas assez de matière si jamais Codutti nous
interrogeait sur ça donc j’ai rajouté cela .

[Link]. Integer :

[Link].1. Champs :
MAX_VALUE : valeur maximale d’un Integer 2^31 (exposant)
MIN_VALUE : valeur minimale d’un Integer, -2^31
SIZE : le nombre de bits utiliser pour représenter un int en complément A2
TYPE : le type que représente Integer (c-a-d int)

[Link].2. Méthodes :
static int parseInt(String s) : converti un string en int decimal. (pas sûr)
static Integer valueOf (String s) : return an Integer object holding the value of the specified String.
static String toBinaryString(int i) Returns a string representation of the integer argument as an
unsigned integer in base 2.
double doubleValue() : retourne la valeur de l’Integer en double.
int intValue() : retourne la valeur de l’Integer en int.

[Link]. Double :

[Link].1. Champs :
(je comprends pas les tailles help)
static int SIZE : nombre de bits pour représenter un double
static Class<Double> TYPE : l’instance représentant le type primitif de double (no idea what
it means)

[Link].2. Methodes :
boolean isInfinite() : dis si le Double est infini en magnitude (?)
booblean isNaN() : dis si le Double n’est pas un nombre.
static boolean isNan (double v) : dis si le double en paramètre n’est pas un nombre

[Link]. Float :
(plus tard besoin de repos)

Black Widow’s so hot, her bone structure is giving my "bone" structure

[Link].1. Champs :

[Link].2. Methodes :

[Link]. Boolean :

[Link].1. Champs :
static Boolean FALSE : the Boolean object corresponding to the primitive value false.
static Boolean TRUE : the Boolean object corresponding to the primitive value true.
static Class<Boolean> TYPE : the Class object representing the primitive type boolean

[Link].2. Methodes :
boolean booleanValue() : retourne la valeur booléenne de l’objet
static Boolean valueOf (boolean b) : retourne un Booléen représentant la valeur booléenne
mis en paramètre

[Link]. Character :

[Link].1. Champs :
static int SIZE : the number of bits used to represent a char value in unsigned binary form,
16
static Class<Character> Type : The Class instance representing the primitive type char

[Link].2. Methodes :
char charValue() : retourne la valeur de l’objet Character courant.
static boolean isAlphabetic (int codePoint) : détermine si codePoint fait parti de l’alphabet.

[Link]. Number :

[Link].1. Méthodes concrètes :

byte byteValue() : retourne la valeur d’un nombre en byte.
short shortValue() : retourne la valeur d’un nombre en short

[Link].2. Méthodes abstraites :

abstract double doubleValue() : retourne la valeur du nombre en double, peut engendrer un
arrondissement (?)
abstact float : floatValue : retourne la valeur du nombre en float, peut engendrer un
arrondissement.
abstract int intValue() : retourne la valeur d’un nombre en int , possibilité de tronquage ou
d’arrondissement

Black Widow’s so hot, her bone structure is giving my "bone" structure

abstract long longValue() : retourne la valeur d’un nombre en long , possibilité de tronquage
ou d’arrondissement

25.3. Boxing/Unboxing :
Exemple :

int​ n1 = 7; ​// valeur 7 stocké directement dans la pile.

Integer n2 = 8 ​// Integer est un type référence.

La valeur 8 est stockés dans les attributs de l'instance n2 de type Integer. L'objet est stocké
sur le tas et une référence pointant vers cet objet est stockée dans la pile.
Normalement on aurait dû écrire (car Integer est un objet):

Integer n2 = ​new​ Integer(8);

ou encore
Integer n2 = [Link](8);

Mais le compilateur s'en occupe automatiquement.

C'est le principe d'​auto-boxing​.

Le boxing est l’enveloppement d’un type primitif dans un Objet.

exemple :
List <Integer> list = ​new​ ArrayList<>();
int​ blackWidow<3 = 5;
[Link](blackWidow<3); ​// pour ajouter blackWidow<3 qui est un int dans list, le compilateur va
envelopper blackWidow<3 dans un Integer. C'est le phénomène de boxing

L’unboxing est le phénomène inverse. C’est quand on va sortir le type primitif de son wrapper.
exemple :
List <Integer> list = ​new​ ArrayList<>();
int​ blackWidow\<3 = 5;
[Link](blackWidow\<3); ​// pour ajouter blackWidow<3 qui est un int dans list, le compilateur va
envelopper blackWidow<3 dans un Integer. C'est le phénomène de boxing
int​ loki = [Link](0) ​// loki est un entier mais va recevoir un Integer. Le compilateur s'occupe donc
d'unboxer l'élément de la liste d'Integer pour pouvoir donner sa valeur à loki.

Black Widow’s so hot, her bone structure is giving my "bone" structure

26. Break/Continue:

26.1. Label:
Toute instruction peut recevoir une ​étiquette (​label​)

LabeledStatement :
Identifier ​: ​Statement

· Permet de nommer (étiqueter) une instruction

· N’est connue que dans l’instruction qui la suit
· Permettra de quitter brutalement (​break​) ou de réitérer (continue​) certaines instructions

26.2. Break:
BreakStatement ​:
break ​Identifier​(opt)​;
· Permet d’​arrêter brutalement une instruction :
Si étiquette →arrête l’instruction étiquetée
Si pas d’étiquette →arrête l’instruction englobante
· Il est associé à une structure conditionnelle (boucle for, while), sans laquelle la boucle ne
ferait jamais plus d'un tour.
· L'identifier est optionnel car si on ne le met pas, il arrête l'instruction en cours. Si on met
l'identifier il arrête le label qui est trouvé en remontant le code, cette utilisation peut-être
intéressante lorsqu'on veut arrêter des boucles imbriquées.

Exemple:

Black Widow’s so hot, her bone structure is giving my "bone" structure

 for​(​int​ x=1; x <= 10; x++){
a = x-7;
​if​(a == 0){
[Link](​"division par 0"​);
​break​; ​//break la boucle si on tombe sur a == 0 donc si x vaut 7
}
[Link](1.0/a); ​//n'affichera pas 7 car le break aura break la
boucle for
}

int​ nb;
entrée : while​(​true​) {
nb = clavier . nextInt ();
​if​ (nb > 0) {
​break​ entrée; // break la boucle entrée quand le nombre entré est
supérieur à 0.
}
[Link](​"Veuillez donner un nb positif"​);
}

int​ i =1 ;
lab1 : ​if​ (i==1) {
​break​ lab1 ;
[Link] (2); ​//ne va pas être affiché car le break à briser le
bloc d'instruction lab1
}
[Link] (3); ​// affiche : 3

int​ nb;
while​(​true​) {
nb = clavier . nextInt ();
​if​ (nb>0) ​break​; /
​ / on casse le while si nb >0
[Link]( ​"Mauvais nb. Recommencer."​); ​// ne va pas
être afficher si le nombre est >0
}

26.3. Continue:
ContinueStatement :
continue ​Identifier(opt) ​;

· Permet de passer ​directement à​ l’itération suivante :

Si pas d’étiquette → recommence l’instruction répétitive englobante
Black Widow’s so hot, her bone structure is giving my "bone" structure
Si étiquette → recommence la boucle étiquetée
· Le continue est utilisé dans le cas d'une boucle (for et while) et d'un arrêt inconditionnel.
Si il n'y a pas de label il réitère l'instruction en cours, si il y'en a un, il réitérer l'instruction
étiquetée par le label.

continue​ est un saut inconditionnel. Associé à une structure conditionnelle, il permet de

passer aux instructions suivantes sans mettre fin à la boucle, ou la suite d'instruction.

Exemple:
int​ x = 1;
for​(​int​ x = 0; x <= 10 ; x++){
​if​(x == 7){
[Link](​"Division par zéro!"​);
​continue​; ​// on va réitérer la boucle et donc incrémenter la valeur de x
}
​double​ a =1.0/(x-7); ​//1 ne sera jamais divisé par 0
[Link](a);
}

for​ (​int​ i=0; i<10; i++) {

​if​ (i%2== 0) ​continue​; ​// on va réitérer la boucle si i est pair et
donc incrémenter la valeur de x
[Link]( i ); ​// affiche 1, 3, 5, 7, 9
}

bcli : ​for​ ( ​int​ i=0; i<10; i++) {

bclj : ​for​ ( ​int​ j=0; j<10; j++) {
​if​ ( ( i_j)%2==0 )
[Link]( j );
​continue​ bcli; //on incrémente
}
[Link]( i );
}

[Link] (​"starting loop:"​);

for​ (​int​ n = 0; n < 7; ++n) {
[Link] (​"in loop: "​ + n);
​if​ (n == 2) {
​continue​;
}
[Link] (​" survived first guard"​);
​if​ (n == 4) {
​break​;
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

 [Link] (​" survived second guard"​);
​// continue at head of loop
}
// break out of loop
[Link] (​"end of loop or exit via break"​);

This will lead to following output:

starting loop:
in loop: 0
survived first guard
survived second guard
in loop: 1
survived first guard
survived second guard
in loop: 2
in loop: 3
survived first guard
survived second guard
in loop: 4
survived first guard
end of loop or exit via ​break

You can label a block, not only a for-loop, and then break/continue from a nested block to an outer
one. In few cases this might be useful, but in general you'll try to avoid such code, except the logic of
the program is much better to understand than in the following example:

first: ​for​ (​int​ i = 0; i < 4; ++i) {

second: ​for​ (​int​ j = 0; j < 4; ++j) {
third: ​for​ (​int​ k = 0; k < 4; ++k) {
[Link] (​"inner start: i+j+k "​ + (i + j + k));
​if​ (i + j + k == 5)
​continue​ third; //incremente k
​if​ (i + j + k == 7)
​continue​ second; //incremente j
​if​ (i + j + k == 8)
​break​ second;
​if​ (i + j + k == 9)
​break​ first; //incremente i
[Link] (​"inner stop: i+j+k "​ + (i + j + k));
}
}
}

27. Fichier binaire :

Black Widow’s so hot, her bone structure is giving my "bone" structure

L'avantage des fichiers binaire est qu’ils possèdent une taille réduite. Nous pouvons grâce à
des classes de bas niveau tels que ​FileInputStream​, ​FileOutputStream​ (Bas niveau) ou
encore ​DataInputStream​, ​DataOutputStream​ (Haut niveau) écrire/lire dans un fichier
binaire.

La différence entre ses classes est que ​DataInputStream​/​DataOutputStream​ permettent

de gérer les données directement en tant que types de données primitifs (int, long, char, …)
contrairement à ​FileInputStream​/​FileOutputStream​ qui gère les octets du flux.

FileInputStream​ et​ FileOutputStream​ héritent respectivement de ​InputStream​ et

OutputStream. ​Ces deux classes s’occupent donc des lectures et écritures des fichiers.

Il n’est pas possible d’instancier ​InputStream​ et ​OutputStream​ directement, cependant il

existe des classes qui le font comme ​Files ​(classe utilitaire ) avec ça méthode
newInputStream(Path, option) ​et ​newOutputStream(Path, option)​.

Exemple avec FileInputStream/FileOutputStream :

File file = ​new​ File(​"fichier"​);

try​{
OutputStream out = ​new​ FileOutputStream(file);
[Link](10); ​//On ne pourra écrire que des bytes.
[Link](); ​//libère les ressources quand on a fini d'écrire.

InputStream in = ​new​ FileInputStream(file);

[Link]([Link]()); ​//On lit le premier byte. [Link]()
retourne -1 une fois arrivé à la fin du fichier.
[Link](); ​//libère les ressources quand on a fini de lire.
}​catch​(IOException e){
[Link](​"Erreur lors la lecteur/écriture"​ +
[Link]());
}

Exemple avec DataInputStream/DataOutputStream:

try​{
DataOutputStream out = ​new​ DataOutputStream(​new
FileOutputStream(file));
[Link](​true​); ​//permet d'écrire des données primitives.
[Link]();

Black Widow’s so hot, her bone structure is giving my "bone" structure

 DataInputStream in = ​new​ DataInputStream(​new​ FileInputStream(file);
[Link]([Link]()); ​//affiche 1
}​catch​(IOException e){
[Link]([Link]());
}

28. Fichier texte :

Les fichiers texte sont sur le même principe que les fichiers binaires mais avec des classes
adaptées :

FileReader ( pour lire un fichier texte ) : int read() → lit un caractère (-1 si fin du
fichier)
FileWriter ( pour écrire un fichier texte) : void write(int c ) → écrire le caractère stocké
dans c
BufferedReader (lire ligne par ligne ( et pas seulement byte par byte ) →
BufferedReader reader = ​new​ BufferedReader(
​new​ InputStreamReader(
​new​ FileInputStream(fichier)));
String ligne1 = [Link]();
​// readLine() retourne null quand on est à la fin du fichier.
[Link]();
[Link](​"ligne 1 : "​ + ligne1);

29. Classe abstraite :

Une classe abstraite est une classe dont l’implémentation n’est pas complète et qui n’est pas
instanciable (on ne peut pas directement créer un objet de cette classe, elle ne possède pas de
constructeur). Elle sert de base aux autres classes qui vont en héritées.

Les méthodes d’une classe abstraites sont justement abstraites. C’est à dire qu’il ne faut spécifier, à
l’intérieur de la classe, que l’en-tête de la méthode.
Exemple :
abstract​ ​void​ ​crier​(); ​// pas de visibilité, ajout du mot clé abstract et non définition du code de la
méthode

L’implémentation de la méthode se fera dans la classe qui va héritée de notre classe abstraite.
public​ ​class​ ​Lion​ ​extends​ ​Felin​ {

Black Widow’s so hot, her bone structure is giving my "bone" structure

 ​public​ ​Lion​(){

​public​ ​Lion​(String couleur, ​int​ poids){

​this​.couleur = couleur;
​this​.poids = poids;
}

​void​ ​crier​() {
[Link](​"Je rugis dans la savane !"​); ​//Ici on défini la méthode crier de Animal qui est
étendu par Félin
}
}

Une classe abstraite est comme une ​Interface​ sauf que toutes ses méthodes ne sont pas implicitement
abstraites. Il faudra alors spécifier le mot clé abstract quand on voudra créer une méthodes abstraites.

Une classe abstraite peut, contrairement à une interface, posséder des méthodes non abstraites et donc
directement implémentées dans la classe.
Elle peut aussi posséder des attributs autres que static et final.
Attention. Comme les classes abstraites se transmettent par héritage et non par implémentation, il
n’est pas possible pour une classe enfant d’avoir deux parents abstraits. Car l’héritage multiple est
interdit en Java.

29.1. Interface vs Classe Abstraite:

Une classe abstraite peut définir des méthodes non abstraites (il faudra alors donner une
visibilité protected à ces classes pour qu’elles puissent être utiliser par les enfants). Par
conséquent, on peut directement définir le code de certaines méthodes si celles ci agissent
de la même façon peut importe la classe qui va les invoquer.

Exemple :

Partons du principe que tous les animaux mangent de la même façon , considérons donc
qu’ils soient vegan. Par contre, ils se déplacent tous différemment, les uns avec leurs pattes,
les autres avec leurs ailes.

Il sera alors plus judicieux d’utiliser une classe abstraite vu que l’implémentation de
manger() est commune à toute les classe. (La méthode se comporte de la même façon) Et
de mettre en abstract la méthode seDeplacer() (car celle ci voit son implémentation modifiée
en fonction de la classe qui l’invoque)

Black Widow’s so hot, her bone structure is giving my "bone" structure

 abstract​ ​class​ ​Animal​ {
protected​ ​void​ ​manger​() {
[Link](​"je mange"​);
}

abstract​ ​void​ ​manger​();

}

30. Polymorphisme :
Le polymorphisme :
poly, grec : plusieurs
morph, gerc : forme
Le polymorphisme est la capacité d’une méthode à avoir plusieurs formes. C’est à dire qu’elle peut
avoir plusieurs comportements. Exemple : [Link]() lance un Kamehameha et Vé[Link]()
lance un Final Flash. La méthode attaquer() est appelée de la même manière mais réagit différemment
en fonction de l’objet (et surtout de la classe qui l’invoque).

Il peut y avoir différents polymorphismes :

Override:
toString () : redéfini le toString d’un objet. La méthode possédait un code auparavant mais on l’a
anéanti et remplacer par un autre.
@Override
public​ String ​toString​() {
" "​ + monAttribut
}

Classes abstraites/​Interfaces​:
Une méthode abstraite n’a pas de code. Il ne sera défini que quand on va implémenter l’interface ou
hériter de la classe.
L’annotation Override est optionnelle dans ce cas. (Vu qu’il n’y a rien à réécrire)

Black Widow’s so hot, her bone structure is giving my "bone" structure

31. For:
Définition :

C'est un mot réservé du langage qui permet de définir des boucles. Il sert à coder le "pour".
Si on connaît le nombre de récurrence, on utilisera souvent un for classique. Sinon on se
contentera en général d'un while ( moins depuis java 8 vu qu’on peut mettre plusieurs
expressions dans un for) . Il existe deux variantes pour le for : le for classique et le ​foreach

Exemple d'utilisation :

for​(​int​ i = 0; i<10; i++){

[Link](i);
}

Grammaire :

Le for est composé de trois parties (dans la parenthèse) qui sont toutes facultatives.

for (ForInit(opt); Expression(opt); ForUpdate(opt)){

Statement;
}

Que se passe-t-il si on omet un de ces éléments ?

→ for(;;) c’est une boucle infini

ForInit :

Il permet d'initialiser la boucle et elle est facultative (​pas d'initialisation si elle est absente​); Il
y a 2 possibilités de déclarations. Une déclaration de une ou plusieurs variables locales ou
une liste d'assignations. (int i=1,j=5,k=N).

Exemple d’un cas où on n’aura pas de forInit :

/**
* Add explorers until there's no need to
*/
private​ ​void​ ​addMultipleExplorers​() {
int​ nbExplorer = 1;
for​ (; ![Link](); nbExplorer++) {
[Link]([Link](nbExplorer));
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

 if​ ([Link]() == ​true​) {
do​ {
[Link]([Link](nbExplorer));
nbExplorer++;
} ​while​ ([Link]() == ​true
&& [Link]());
}
}

On n’utilise pas le for init car on veut que la variable incrémentée par la boucle puisse être
utilisée dans un autre endroit que la boucle. Ici, on l’utilise dans le do while.

Expression :

L'expression doit être de type booléen qui permettra de mettre fin à la boucle et elle est
facultative (​une boucle infinie aura lieu si l'expression est absente à moins d'avoir un break
ou return dans la boucle​).

ForUpdate :
Cette partie a pour but de mettre à jour les indices avant de tester à nouveau la condition.
On peut y trouver une liste d’expressions instructions (comme le second cas de la partie
ForInit).Les mêmes exemples sont donc valides. (​Si elle est omise, pas de mise à jour​).

Statement :

C'est le corps de la boucle et est obligatoire. Ca représente une instruction ou un bloc

d'instructions. (Si on a plusieurs itérations, on pourrait utiliser la notion de break afin d'arrêter
la boucle au moment souhaité).

Un exemple récapitulatif :

for​(​int​ i=0, j=10 ; (i<10 && j>i) ; i++, j--){

int​ somme = i+j ;
[Link](somme) ;
}

Compléments :

Il n’y a qu’une seule instruction dans la boucle. Mais si on examine ce qu’est une instruction
dans la grammaire, on trouve, dans la liste des possibilités, le block. Un block est une suite
d’instructions entre accolades qui a donc le statut d’instruction unique. Ce qui permet de le

Black Widow’s so hot, her bone structure is giving my "bone" structure

retrouver comme corps du for tout en respectant la grammaire qui impose une seule
instruction.

Peut-on écrire un while en for et vice-versa ?

Oui ==>
-------------------------------------------------------------------------------------------------------
For ( init,expr,update){
init statements;
while(expr){
}
statements;
update;
}
-------------------------------------------------------------------------------------------------------
while(expr){
for(expr){
statements;
statements;
}
}

32. Constructeur:
Un constructeur a pour but d’instancier un objet.
Instancier un objet correspond à le construire en mémoire :

-lui réserver de l’espace en mémoire

-initialiser son état (ses attributs)

Pour instancier un objet, il faudrait faire appel au constructeur via la combinaison de

mots-clé : new NomClasseObjet(param)
Le constructeur aura pour but de définir l’état de l’objet via ses attributs. Il s’occupera donc
de définir la valeur de ces attributs.

Un constructeur se définit comme une méthode standard, mais ne renvoie aucune valeur.
Ainsi, le constructeur d'un objet porte le même nom que la classe et ne possède aucune
valeur de retour (même pas void).

- un constructeur porte le même nom que la classe dans laquelle il est défini.
- un constructeur n'a pas de type de retour (même pas void).
- un constructeur peut avoir des arguments.

Black Widow’s so hot, her bone structure is giving my "bone" structure

 Voyons sur un exemple comment se déclare un constructeur :

class​ ​Toto​{
private​ ​int​ age;
private​ ​char​ sexe;
private​ ​float​ taille;
Toto(​int​ age, ​char​ sexe, ​float​ taille){
this​.age = age;
this​.sexe = sexe;
this​.taille = taille;
}
}

Définir plusieurs constructeurs :

Comme pour n'importe quelle méthode, il est possible de surcharger les constructeurs,
c'est-à-dire définir plusieurs constructeurs avec un nombre/type d'arguments différents.

Ainsi, il sera possible d'initialiser différemment un même objet, selon la méthode de

construction utilisée.

Imaginons par exemple que pour l'exemple précédent on veuille pouvoir définir le sexe de
Toto grâce à un entier valant 0 ou 1, ainsi qu'avoir la possibilité de passer en paramètre la
lettre 'M' ou 'F', on peut alors définir deux constructeurs pour lesquels le type du second
argument sera différent. De plus, on va montrer de quelle manière il est possible de
contrôler le caractère entré en paramètre :

class​ ​Toto​{
int​ age;
char​ sexe;
float​ taille;
Toto(​int​ age, ​char​ sexe, ​float​ taille){
this​.age = age;
if​ ((sexe==​'M'​)||(sexe==​'F'​)) {
this​.sexe = sexe;
}
else​ {
[Link](​"Erreur d'initialisation"​);
}
this​.taille = taille;
}

Toto(​int​ age, ​int​ sexe, ​float​ taille){

this​.age = age;

Black Widow’s so hot, her bone structure is giving my "bone" structure

 switch​ (sexe) {
case​ 0 :
this​.sexe = ​'F'​;
break​;
case​ 1:
this​.sexe = ​'M'​;
break​;
default​ :
[Link](​"Erreur d'initialisation"​);
break​;
}
this​.taille = taille;
}

On peut placer des sécurités dans un constructeur pour le rendre robuste.

public​ ​class​ ​ElevePoudlard​ {

private​ String maison;
private​ ​int​ année;
private​ ​int​ moyenne;
public​ ​ElevePoudlard​ (String maison, ​int​ année, int moyenne) {
if​ (![Link](​"Gryffondor"​) || ![Link](​"Serpentard"​) ||
![Link](​"Serdaigle"​) || ![Link](​"Poufsouffle"​) {

throw​ ​new​ IllegalArgumentException(​"Il n y a que Gryffondor(Captain

America), Serpentard(BlackWidow), Serdaigle(ironMan) et Poufsouffle à Poudlard comme
maison!!"​);

} ​else​ ​if​ ([Link](​"Poufsouffle"​) {

[Link](​"Tu es un raté, Harry!"​);
} ​else​ ​if​ (année > 6 || année < 1) {
​throw​ ​new​ IllegalArgumentException(​"Il n'y a pas d'année en
dessous de 1 ou au dessus de 6"​);

} ​else​ ​if​ (moyenne > 100) {

​throw​ ​new​ IllegalArgumentException(​"Une moyenne ne peut dépasser
100 à moins de s'appeler Miss Granger"​);

} ​else​ {
this​.maison = maison
this​.année=année
this​.moyenne=moyenne
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

 }

32.1. Getter :
Le getter permet de retourner la valeur d’un attribut private

public​ String ​getMaison​() {

return ​this​.maison;
}

32.2. Setter :
Le setter permet de modifier la valeur d’un attribut static.
L’intérêt d’avoir un Setter est de pouvoir appliquer son action que d’une certaine façon,
définie par le programme. Si un setter est défini, on ne pourra pas modifier l’attribut
autrement que par son setter.

public​ ​void​ ​setMoyenne​(​int​ newMoyenne) {

​if​ (​this​.[Link](​"Poufsouffle) && newMoyenne > 50 ) {
throw new IllegalArgumentException("​Un Poufsouffle ne peut avoir une
moyenne supérieure à 50”);
} ​else​ {
​this​.moyenne = newMoyenne;
}
}

33. Object:
Un langage orienté objet permet de créer ses propres types, liés au problème à résoudre.
Il est apparu suite aux limites de la programmation procédurale (crise du logiciel) et permet
d’écrire des programmes plus lisibles, compactes et robustes.

Un objet représente un élément du ​problème​ à résoudre.

Exemples : un étudiant en particulier, un produit bien précis, une vidéo donnée. . .
Un programme peut créer et manipuler les objets.
Un type de données OO est défini par une classe
Un objet est une instance² d’une classe :

■ construit à partir de la définition donnée par la classe ;

■ appartenant au type défini par la classe.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Exemple : dev2 est un objet, instance de la classe UniteEnseignement.
Un objet se caractérise par :
■ son état ³ :
■ stocké dans des attributs (des variables liées à l’objet)

■ son comportement (ce qu’on peut en faire):

○ défini par des méthodes (du code)

Représentation graphique d'une classe:

(ne pas oublier que: - privé

# protégé
~ package
+ publique)

Représentation graphique d'un objet :

Ne pas confondre attributs et variables locales

un attribut est visible dans tout le contexte de l'objet

Black Widow’s so hot, her bone structure is giving my "bone" structure

variable locale est visible dans le bloc courant.​ (ref:
[Link]

Une classe d'objet ne comprend pas de méthodes static (voir mot static)

Exemple code de classe :

public​ ​class​ ​Video​ {

private​ String auteur;

private​ String titre ;
private​ ​boolean​ publiée ;
private​ ​int​ nbLikes;

public​ ​void​ ​liker​ () {

nbLikes++;
}

public​ ​void​ ​publier​ () {

publiée = ​true​;
}

Instancier un objet c’est le construire en mémoire :

■ lui réserver de l’espace en mémoire (sur le tas)

■ initialiser son état (ses attributs)

Initialisation prise en charge par un constructeur. (voir mot constructeur)

Exemple :

public​ ​Video​ ( String unAuteur, String unTitre) {

auteur = unAuteur;
titre = unTitre;
publiée = ​false​;
nbLikes = 0;
}

Pour instancier un objet :

■ On utilise l’opérateur new
■ On fournit les paramètres au constructeur

exemple :​ Video kaamelott = ​new​ Video(​"Alexandre Astier"​, ​"Kaamelott"​);

■ Crée un nouvel objet kaamelott de type Video

Black Widow’s so hot, her bone structure is giving my "bone" structure

 ■Appelle le constructeur pour l’initialiser
5​
Une classe est un type référence ​ (comme les tableaux) :
Le constructeur peut vérifier la validité des paramètres:
Exemple, permettrait de refuser :
​ ew​ Video(​""​, ​"Kaamelott"​); ​// refusé
Video kaamelott = n
Video kaamelott = n​ ew​ Video(​null​, ​"Kaamelott"​); ​// aussi
null :
■ littéral de type référence
■ indique qu’il n’y a pas d’objet (référence vers rien)

ne pas confondre null avec ""

pour vérifier la validité des paramètres, il suffit d’ajouter des tests en début de constructeur ,
exemple :

public​ ​Video​ ( String unAuteur, String unTitre) {

if​(unAuteur==​null​ || [Link]()==0) {
throw​ ​new​ IllegalArgumentException(​"Auteur invalide : "​ +
unAuteur);
}

auteur = unAuteur;
titre = unTitre;
publiée = ​false​;
nbLikes = 0;
}

Un objet est toujours créé dans un état valide

(à mon avis valide signifie simplement que tous les attributs sont correctement initialisés,
c'est ce que je pense donc pas sûr à 100%, j'ai pas réussi à trouver rapidement l'info​)

Utilisation de la notation pointée (opérateur .)

Par exemple, l’abscisse du point p est [Link] et son ordonnée est [Link].

Impossible d’accéder aux attributs (privés) exemple :

Black Widow’s so hot, her bone structure is giving my "bone" structure

 [Link]. println (kaamelott. titre ); ​// ne compile : attribut privé

Cela permet d'éviter de donner des valeurs invalide, pour palier à ce problème on utilise des
méthodes publiques.

Ces méthodes publiques sont des accesseurs(getter) et des mutateurs(setter)

l'accesseur d'un attribut (d'un objet), (par défaut get/is(booléen)Attribut ) donne la valeur de
ce dernier
Exemple : ​[Link]. println ([Link] ());

Le mutateur d'un attribut (d'un objet)(setAttribut) permet de modifier sa valeur, exemple :

public void setTitre ( String unTitre) { titre = unTitre;}

Le mutateur peut vérifier le paramètre, exemple:

public​ ​void​ ​setTitre​ ( String unTitre) {

if​(unTitre==​null​ || unTitre. length()==0) {

throw​ ​new​ IllegalArgumentException(​"Titre invalide : "​ +
unTitre);
}

titre = unTitre;
}

Un objet reste toujours dans un état valide

Chaque membre (membres = attributs + méthodes) peut avoir comme visibilité :
public, privé, paqueté, protégé.

(les attribut sont normalement en visibilité privé)

(pour plus d'info voir mot visibilité)

Même si les attribut ne sont pas initialisé dans le constructeur il existe une valeur par défaut:
■ 0 pour les nombres ;
■ null pour les références ;
■ false pour les booléens.

Il existe même un constructeur par défaut, il est sans paramètre et ne fait rien. Il n'est plus
disponible si un autre constructeur est fourni.

Un classe d'objet peut posséder plusieurs constructeurs, on appel ça la surcharge

(overloading).
(pour plus d'info voir le mot constructeur)

Black Widow’s so hot, her bone structure is giving my "bone" structure

La surcharge est permise aussi pour les méthodes.
Il faut néanmoins que les méthodes 4​​ aient des paramètres différents, exemple :
public​ ​void​ ​liker​ () {
liker (1);
}

public​ ​void​ ​liker​ (​int​ nbFois) {

nbLikes = nbLikes + nbFois;
}

Le constructeur, les méthode et les attribut d'un objet peuvent être représenté par "this" (voir
le mot this)

1​ ​
Problème: Question à résoudre par des méthodes logiques, rationnelles, dans le domaine
scientifique.​(petit Larousse 1998).

²​ En , on appelle instance d'une​ classe​, un objet avec un comportement et un état, tous deux définis
programmation​ orientée objet​s par la classe. Il s'agit donc d'un objet constituant un exemplaire de la
classe. Dans ce contexte, instance est un​ anglicisme​, qui signifie « cas », « exemple ». ​(wikipédia)

³​ L’état d'un objet est sa forme à un instant donné, telle que décrite par les valeurs de l'ensemble de ses
propriétés.​(j'ai oublié la source, sorry )

4​ ​
Une méthode est un morceau de code réutilisable qui effectue une action bien définie. Elles se
définissent dans une classe.​ Il y a deux « familles » : les natives et les nôtres​. Le principal avantage
des méthodes est de pouvoir factoriser le code : grâce à elles, vous n'avez qu'un seul endroit où
effectuer des modifications lorsqu'elles sont nécessaires. ​( OpenClassRooms:
[Link]

5​
Les types primitifs et référence :

Les types primitifs sont des types natifs de java , cela comprend byte, int, char, double, boolean.
Lors de la déclaration d'un type primitif (ex: int i) ,un espace mémoire est allouée directement variable
i. Lors de son assignation: la valeur de i vient se mettre à l'emplacement de la mémoire correspondant
à la variable. (ex: i = 1), Dans cet espace mémoire est écrit un encodage de l’entier « 1 ».

Type référence : Lors de la déclaration d'un type (ex : p = Pays) , il y a un espace mémoire permettant
de stocker une référence. Au moment de l'assignation (ex: p = new Pays()), un espace mémoire est
alloué permettant de stocker un objet de type de Pays et l'adresse de cet espace est ensuite référencé
par la variable p.

Black Widow’s so hot, her bone structure is giving my "bone" structure

(sources ​que je vous invite vraiment à lire, très bien expliquées​ :
[Link] )

⚠​Je pensais qu’il fallait juste parler de “l’objet”, pas de la classe

entière, ne m’en voulez donc pas si je n’ai pas encore ajouté les
méthodes se rapportant à Object :
[Link]

protected​ ​Object​ ​clone​()

protected Object clone() : renvoie une copie de l’objet
boolean​ equals (Object o) : retourne vrai si les deux objets sont égaux.
int hashCode() : retourne un ​hashCode​ pour l’objet
String ​toString()​ : retourne une représentation textuelle de l’objet

34. Objects :
Objects est une classe comprenant uniquement des méthodes utilitaires statiques qui
servent à la manipulation d’objets. (utilitaire signifie static).

Cette classe comprend notamment les méthodes :

- static <T> int compare
- static boolean deepEquals
- static boolean equals
- static int hashCode
- static boolean isNull
- static boolean nonNull

Black Widow’s so hot, her bone structure is giving my "bone" structure

 - static String toString

34.1. deepEquals:
public static boolean deepEquals (Object a, Object b) :​ retourne vrai si les deux objets
sont profondément égaux.

Deux objets null sont profondément égaux. Si les deux arguments sont des Array, alors c’est
la méthode [Link]() qui va déterminer l’égalité profonde. Sinon l’égalité est
testée par l’equals du premier argument.
Deux Arrays sont profondément égaux s’ils références vers des tableaux de même taille et
dont les éléments aux même indices sont deepEquals. Le equals, lui va comparer
strictement les éléments d’un tableau (s’il tombe sur des références ,à l’intérieur, du tableau,
il va comparer les références et non les éléments pointés par les références).

Exemple :
public​ ​static​ ​void​ ​main​(String[] args) {

String st1 = ​"coucou"​;

String st2 = ​"coucou"​;
​int​[] tab1 = {1, 2, 3};
​int​[] tab2 = {1, 2, 3};
​int​[][] tab2D1 = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
​int​[][] tab2D2 = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
​int​[][][] tab3D1 = {{{1, 2, 3}, {1, 2, 3}, {1, 2, 3}}, {{1, 2, 3}, {1, 2,
3}, {1, 2, 3}}, {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}}};
​int​[][][] tab3D2 = {{{1, 2, 3}, {1, 2, 3}, {1, 2, 3}}, {{1, 2, 3}, {1, 2,
3}, {1, 2, 3}}, {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}}};

[Link]([Link](st2, st1)); ​//affiche vrai

[Link]([Link](tab2, tab1)); ​//affiche vrai

[Link]([Link](tab1, tab2)); ​//affiche vrai

[Link]([Link](tab2D1, tab2D2)); ​// affiche faux car il y

a un tableau à l'intérieur de tab2D1 et tab2D2 et le equals compare les références
de ces tableaux. Comme ils n'ont pas les mêmes, on renvoie faux.

[Link]([Link](tab2D1, tab2D2)); ​//affiche vrai car

le deepEquals vérifie que les éléments d'un tableau sont profondément égaux. Quand
il va comparer les tableaux à l'intérieur de tab2D1 et tab2D2 , il ne va pas
regarder les références mais va rechercher les valeurs à l'intérieur des tableaux
contenu dans ces derniers.

Black Widow’s so hot, her bone structure is giving my "bone" structure

 [Link]([Link](tab3D1, tab3D2)); ​// même chose
retourne vrai
[Link]([Link](tab2D1, tab2D1)); ​// affiche faux
}

34.2. compare:
public static <T> int compare(T a,T b,​ ​Comparator<? super T> c)
Retourne 0 si les 2 arguments sont identiques (donc aussi tout les deux null) et [Link]()
au sinon. On choisit avec le comparateur si un paramètre null renvoie une
nullPointerException.
Elle reçoit en paramètre les objets à comparer et le comparateur.

Différence avec compareTo → compareTo renvoie une erreur pour les objets null.

34.3. hash:
public static int hash(​Object​... values):

Génère un hash code pour les valeurs entrée en paramètre. Le code de hachage est généré
comme si toutes les valeurs d'entrée étaient placées dans un tableau, et que ce tableau était
haché en appelant [Link] (Object []).
Cette méthode est utile pour implémenter [Link] () sur des objets contenant
plusieurs champs. Par exemple, si un objet a trois champs, x, y et z, on pourrait écrire:

@Override
public​ ​int​ ​hashCode​() {
return​ [Link](x, y, z);
}

⚠​ Lorsqu'une seule référence d'objet est fournie, la valeur renvoyée n'est pas égale au
code de hachage de cette référence d'objet.

Black Widow’s so hot, her bone structure is giving my "bone" structure

34.4. isNull / nonNull:
public static boolean isNull(​Object​ obj)
isNull:
Renvoie true si la référence fournie est null, sinon renvoie false.

public static boolean nonNull(​Object​ obj)

nonNull:
Renvoie true si la référence fournie est non nulle sinon renvoie false.

35. Switch:

35.1. La base:
Java offre la possibilité d’effectuer des actions quand certaines conditions sont remplies. Ce
sont des instructions et ces instructions sont :

si...alors
si...alors...sinon….
si... sinon si … alors... sinon...

selon que...
switch...case

Ici nous allons voir comment utiliser l’instruction switch. Une instruction switch vérifie si
une variable est égale à une liste de variables. La variable dans le switch peut être un byte,
short , int ou char. Cependant depuis Java 7, le switch supporte aussi le String.

35.2. Syntax of switch case:

La syntaxe du switch case Statement est la suivante
SwitchStatement:
switch (Expression) SwitchBlock
SwitchBlock:

{{SwitchBlockStatementGroup} {SwitchLabel}}

SwitchBlockStatementGroup:
SwitchLabels BlockStatemens
SwitchLabel:

Black Widow’s so hot, her bone structure is giving my "bone" structure

 case ConstantExpression :
case EnumConstantName :
default :

switch ​: le mot clé switch est suivi d’une expression mise en paramètre. Cette expression est
testée avec les différents cas. Il n’y a pas de limite théorique vis à vis du nombre de cases
dans une instruction switch.

case ​: le mot clé case est suivit par la valeur avec laquelle l’expression doit être comparée. Sa
valeur est du même type que celle de l’expression exécutée.

default​: si aucun case ne correspond, on finira sur default (optionnel) qui exécutera le cas par
défaut. C’est l’équivalent du “else”. En général il est écrit en après le dernier case. Dans ce
cas, il ne sera pas suivi d’un break. Si il n’y a pas de default après le dernier case, le switch
passera à la prochaine instruction (une fois toutes les case parcourus).

break​ : le break permet de sortir du switch quand on passe dessus. Tant qu’il n’y a pas de
break, même si on a trouvé un case correspondant , on va executer les instructions du cas
suivant .

Example of switch case:

[Link]

package​ [Link];

​ lass​ ​SwitchCaseExample​ {
public​ c
public​ ​static​ ​void​ ​main​(String[] args) {

grading(​'A'​);
grading(​'C'​);
grading(​'E'​);
grading(​'G'​);
}

public​ ​static​ ​void​ ​grading​(​char​ grade) {

int​ success;

Black Widow’s so hot, her bone structure is giving my "bone" structure

 switch​ (grade) {
case​ ​'A'​:
[Link](​"Excellent grade"​);
success = 1;
break​;
case​ ​'B'​:
[Link](​"Very good grade"​);
success = 1;
break​;
case​ ​'C'​:
[Link](​"Good grade"​);
success = 1;
break​;
case​ ​'D'​:
case​ ​'E'​:
case​ ​'F'​:
[Link](​"Low grade"​);
success = 0;
break​;
default​:
[Link](​"Invalid grade"​);
success = -1;

passTheCourse(success);

​ tatic​ ​void​ ​passTheCourse​(​int​ success) {

public​ s
switch​ (success) {
case​ -1:
[Link](​"No result"​);
break​;
case​ 0:
[Link](​"Final result: Fail"​);
break​;
case​ 1:
[Link](​"Final result: Success"​);
break​;
default​:
[Link](​"Unknown result"​);

Black Widow’s so hot, her bone structure is giving my "bone" structure

Dans ce code nous observons deux instructions switch, une utilisant char et une autre utilisant
int.

package​ [Link];
public​ ​class​ ​StringSwitchCase​ {
public​ ​static​ ​void​ ​main​(String args[]) {
visitIsland(​"Santorini"​);
visitIsland(​"Crete"​);
visitIsland(​"Paros"​);
}
public​ ​static​ ​void​ ​visitIsland​(String island) {
​switch​(island) {
​case​ ​"Corfu"​:
[Link](​"User wants to visit Corfu"​);
​break​;
​case​ ​"Crete"​:
[Link](​"User wants to visit Crete"​);
​break​;
​case​ ​"Santorini"​:
[Link](​"User wants to visit
Santorini"​);
​break​;
​case​ ​"Mykonos"​:
[Link](​"User wants to visit
Mykonos"​);
​break​;
​default​:
[Link](​"Unknown Island"​);
​break​;
}
}

}
Output:

User wants to visit Santorini

User wants to visit Crete
Unknown Island

Black Widow’s so hot, her bone structure is giving my "bone" structure

36. Path:
présent dans [Link]

C’est un objet utilisé pour localiser un fichier, il est composé de nom de dossier et d’un nom
de fichier, ces noms et fichiers sont séparé par un séparateur(différent en fonction du
filesystem). Il représente généralement un chemin de fichier dépendant du système. Un
composant racine peut y être présent.
Exemple :

/Poudlard/Maison/Serpentard/[Link]

Un chemin peut être relatif ou absolu.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Un path peut être composé de plusieurs éléments noms, le nom le plus éloigné du
composant racine peut être le nom d’un dossier ou d’un fichier, les autres sont des noms de
dossiers.
Avec l’exemple de poudlard, [Link] est un fichier mais Serpentard, Maison et Poudlard
ne pourrait pas être des fichiers.

Un path est considéré vide si le path est constitué d’un élément nom (name) vide. Accéder à
un fichier avec un path vide est la même chose que se diriger vers le dossier par défaut du
système de fichier. (comme avec cd sur linux)

Dans l’interface path on peut:

- créer un path
- utiliser l’information contenue dans un path
- convertir un path
- comparer deux path
- combiner deux path grâce à des méthodes prévue à cet effet.

La classe paths est une classe contenant toutes les méthodes statique qui retourne un path.
Donc on peut créer un path.

Exemple :
import​ [Link];
import​ [Link];

public​ ​class​ ​PathExample​ {

​public​ ​static​ ​void​ ​main​(String[] args) {

Path path = [Link](​"c:\\data\\[Link]"​);

}
}

37. Collection(s):

37.1. Définition :
Collection est une Interface qui représente une collection.
Une collection représente ensemble d’objets (ceux ci seront ses éléments).
- tous les éléments d’une collection sont de même type

Black Widow’s so hot, her bone structure is giving my "bone" structure

 - certaines collection sont triées et/ou ordonnées
- certaines permettent les doublons

Comme une collection n’admet que des objets, il est impossible d’y placer directement des
types primitifs. Pour baiser le système, on va utiliser des ​wrappers​.

Attention Collection != Collections !!!

37.2. Collection VS Collections :

37.2.1. Collection :
Interface étendue par List. Elle reprend toutes méthodes de List telles que :

boolean add(E e) ​: ajoute un élément à la collection si possible. L’élément peut ne

pas être ajouté si la collection n’admet pas de doublon et que l’élément est déjà présent
dans la collection. Si la collection a été modifiée par la méthode , le booléen retourne vrai.

int size()​ : retourne la taille de la collection (nombre éléments)

Object[] toArray()​ : retourne un tableau contenant tout les éléments de la

collections. L’ordre des éléments du tableau sera de la responsabilité de
l’implémentation de Collection.

37.2.2. Collections :
Classe static correspondant à Collection. Elle permet d’appliquer des méthodes statiques en
rapport aux Collection

static int frequency(Collection <?> c, Object o) : ​ retourne la fréquence absolue

(nombre d'occurrences )de l’objet o dans la collection c.

static <T> ​List​<T>​ ​nCopies(​ int n, T o)​ : Returns an immutable list consisting of n
copies of the specified object.

Les méthodes de collections propose des service pour des collection.(comme les listes)

Les méthodes de cette classe lancent une ​NullPointerException si les collections ou

objet (!!!)(​class objects)​ sont null.

Cette classe possède aussi des algorithmes destructifs, ces algorithmes sont des
algorithmes qui modifient la collection qu’ils reçoivent (exemple tri), ils lanceront une
UnsupportedOperationException si la collection ne supporte pas l’opération, la

Black Widow’s so hot, her bone structure is giving my "bone" structure

méthode peut (mais le ne fera pas toujours) lancer cette exception si l’opération ne
changera rien à la collection

Cette class fait partie de Java Collections Framework.

Package (à importer): [Link];

38. Codage Fichier Java:

Le codage de l’information peut être fait de deux manières:

- binaire - représentation en mémoire
- texte - utilisation d’une suite de caractère

pour stocker le nombre 16 :

en binaire : 0x10
ne prend qu’un byte

en texte : 3136
le fichier fera 2 bytes car il stocke le 1 et le 6 et non un 16. Le 31 vient du fait que 1
dans le code unicode correspond au numéro 31 et le numéro 6 dans le code unicode
correspond au numéro 36.

java encode ses fichiers en unicode, l’unicode peut être encodé avec plusieurs encodage de
la norme UTF , comme ici utf8.

Black Widow’s so hot, her bone structure is giving my "bone" structure

39. Enumération:

39.1. De quoi s’agit-il ?

Une énumération est un ensemble fixe et relativement petit de valeurs ayant un nom et étant
sémantiquement liées. Réunir ces valeurs permets de mieux structurer le code et d’y

Black Widow’s so hot, her bone structure is giving my "bone" structure

accéder plus facilement. Les valeurs de l’énumération ne changeront pas durant la durée de
vie du programme.

39.2. Normes d’écriture

Le code est composé de 4 éléments. Tout d’abord, on annonce la visibilité de l’énumération
(public, private, protected ou rien si package).
Ensuite vient le mot-clé « enum » qui indique que nous sommes bien dans une énumération.
Suivra le nom de l’énumération. Ce nom respecte les normes de nommage de classes,
c’est-à-dire qu’il commence par une majuscule et est en CamelCase(c’est à dire que le nom
peut être composé de plusieurs mots mais ils doivent être collé et une majuscule doit
apparaître à chaque début de nouveau mot. Exemple : CeciEstUnCamelCase).
Enfin, les valeurs de l’énumération se placeront entre { }. Elles seront écrites en majuscules
par convention étant donné qu’il s’agit de constantes, et séparées par une virgule, la
dernière valeur sera suivie d’un point-virgule.

Exemple :
public​ ​enum​ Saisons {
PRINTEMPS, ÉTÉ, AUTOMNE, HIVER ;
}

39.3. Utilisation
L’énumération agit comme une classe. Elle peut avoir un constructeur, des attributs et des
méthodes. Les paramètres du constructeur (les valeurs de ces parametres) se placeront
entre parenthèses après chaque valeur de l’énumération.
Exemple :
public​ ​enum​ Saisons {
PRINTEMPS(​"pluie"​), ÉTÉ(​"soleil"​), AUTOMNE(​"pluie"​),
HIVER(​"neige"​) ;
​private​ String temps ;
​public​ ​Saison​(String temps) {
​this​.temps = temps ;
}
​public​ String ​getTemps​() {
​return​ temps ;
}
}

La méthode getTemps() s’appellera via la commande :

[Link]()

Elle possède également des spécificités qui lui sont propres.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Ainsi, les valeurs d’une énumération sont automatiquement converties en chaînes. Pour y
accéder, il suffit d’utiliser la méthode name().

Exemple :
[Link]() retournera la chaine « PRINTEMPS ».

La méthode values() permet de fournir un tableau contenant les valeurs de l’énumération.

Cette méthode est très utile, notamment pour parcourir ce tableau via un foreach.
Exemple :
for​(Saisons saison : [Link]()) {
[Link](​"Actuellement c’est la saison"​ + saison) ;
}

Il est également facile d’utiliser une énumération dans un switch.

Exemple :
public​ ​enum​ Saisons {
PRINTEMPS, ÉTÉ, AUTOMNE, HIVER ;
}
public​ ​class​ ​EnumTest​ {
Saisons saison;
​public​ ​EnumTest​(Saisons saison) {
​this​.saison = saison;
}

​public​ ​void​ ​infoSaison​() {

​switch​ (saison) {
​case​ PRINTEMPS:
[Link](​"Au printemps la vie se réveille"​);
​break​;
​case​ ETE:
[Link](​"L'été il fait chaud"​);
​break​;
​case​ AUTOMNE:
[Link](​"En automne la nature s'endort"​);
​break​;
​case​ HIVER:
[Link](​"En hiver on fête Noël"​);
​break​;
}
}
}

Black Widow’s so hot, her bone structure is giving my "bone" structure

40. Hashcode():
La méthode hashcode() retourne un int généré par un algorithme de hachage (algorithme
qui, à partir d’une donnée fournie en entrée, calcule un code qui servira à identifier
rapidement cette donnée).
Le but étant d’être plus efficace dans le stockage et l’identification de données.

Une méthode hashcode() est également fournie par défaut dans la classe Object. Si la
méthode equals() est Override, il faut également Override la méthode hashcode() vu que
ces deux méthodes sont étroitement liées.

Peu importe le nombre de fois que la méthode sera appelée sur un même objet durant une
exécution, la valeur du hashcode sera identique (consistante). Par contre elle pourra
changer d’une exécution à l’autre.

Deux objets égaux (donc avec la méthode equals() ) doivent retourner le même hashcode()
et ce peu importe le nombre de fois que la méthode est appelée sur ces objets (consistante)
(​attention​, les deux hashcode restent égaux mais la valeur du hashcode peut changer
d’une exécution à l’autre. La valeur du hashcode n’a pas d’importance, c’est l’égalité qui
l’est).
Par contre, il n’est pas nécessaire que deux objets différents retournent différents hashcode.
C’est mieux car cela améliore la performance mais ce n’est pas nécessaire.

41. Equals:

41.1. De quoi s’agit-il?

La méthode equals() est une méthode permettant de comparer deux objets entre eux. Elle
renvoie un booléen selon que ceux-ci sont égaux (même type, même valeur et même
hashcode() ) ou non. Une méthode equals() est fournie par défaut dans la classe Object
mais elle ne compare que les références des objets.

Ainsi, lors de la création d’une nouvelle classe, il est de bonne pratique de réécrire la
méthode equals (avec un @Override) pour l’adapter. Lorsque la méthode equals est
adaptée il ne faut pas oublier d’également adapter le hashcode().

Black Widow’s so hot, her bone structure is giving my "bone" structure

Cette méthode est surtout utilisée pour comparer des objets (notamment dans les listes, les
méthodes contains() et remove() utilisent la méthode equals(),…) mais aussi pour comparer
des String vu qu’il ne s’agit pas d’un type primitif (comparer à l’aide de « == » ne suffit pas).

41.2. Conventions/Utilisation
La méthode equals() doit être :
- réflexive : un objet est toujours égal à lui-même.
- symétrique : si a = b alors b = a.
- transitive : si a = b et b= c alors a = c.
- consistante : peu importe le nombre de fois que la méthode est utilisée sur les mêmes
objets, tant que ceux-ci ne sont pas modifiés le résultat de la méthode sera toujours le
même.
- gérer les null : tout est différent de null (et donc chaque fois que quelque chose est
comparé à null la méthode renverra false ou un nullPointerException). Deux null comparés
ensemble renverront également un nullPointerException ou un false. Pour comparer deux
null il vaut mieux utiliser “==”.

41.3. Exemple :
@Override
public​ ​boolean​ ​equals​(Object o) {
​// self check
​if​ (​this​ == o) {
​return​ ​true​;
}
​// null check
​if​ (o == ​null​) {
​return​ ​false​;
}
​//vérifie si pas même classe
​if​ (getClass() != [Link]()) {
​return​ ​false​;
}

Person person = (Person) o;

​// comparaison des attributs
​return​ [Link](firstName, [Link]) && [Link](lastName,
[Link]);
}

Person elliot = ​new​ Person(​"Elliot"​, ​"Alderson"​);

Person mrRobot = ​new​ Person(​"Elliot"​, ​"Alderson"​);
boolean​ equal = [Link](mrRobot);

Black Widow’s so hot, her bone structure is giving my "bone" structure

package​ [Link];

public​ ​class​ ​Vehicle​ {

private​ String model;
private​ ​int​ yearOfProduction;
private​ String manufacturer;

public​ ​Vehicle​() {}

public​ ​Vehicle​(String model, ​int​ yearOfProduction, String manufacturer) {

this​.model = model;
this​.yearOfProduction = yearOfProduction;
this​.manufacturer = manufacturer;
}
@Override
public​ ​boolean​ ​equals​(Vehicle v) {
if​ (v == ​null​) {
return​ ​false​;
}
return​ ((​this​.model).equals([Link])
&& (​this​.yearOfProduction == [Link])
&& (​this​.manufacturer).equals([Link]));
}

}
//​The explanation of why the == can’t compare 2 strings is that the ​==​ operator compares the references of
the String objects rather than the values they store internally and it often also leads to unexpected and
unwanted behaviour.

42. Static :

42.1. De quoi s’agit-il?

Static est un mot-clef utilisé pour la gestion de la mémoire. Il peut être appliqué aux
membres, c’est-à-dire aux attributs, méthodes et constructeurs.

Lorsqu’il est utilisé, cela indique que le membre en question appartient à la classe plutôt
qu’à une instance de la classe ; ce qui veut dire qu’un seul exemplaire du membre est créé
et partagé à travers toutes les instances de la classe.

Black Widow’s so hot, her bone structure is giving my "bone" structure

42.2. Attributs static
Si un attribut est static cela signifie que, peu importe le nombre de fois que la classe sera
initialisée, une seule copie de cet attribut sera créée. La valeur de l’attribut sera partagée
entre tous les objets. Il est donc intéressant de déclarer un attribut static lorsque sa valeur
est indépendante des objets et qu’elle sera partagée à travers eux.

On accède à un attribut static directement à partir du nom de la classe, il n’est pas

nécessaire d’initialiser un objet ou d’en utiliser un déjà créé (et c’est même déconseillé,
même si cela reste possible, pour éviter les confusions entre les attributs de classe et
d’instance de classe).
[Link] ​// retourne l'attribut static

Exemple :
public​ ​class​ ​Person​ {
​private​ String firstName;
​private​ String name;
​public​ ​static​ ​int​ numberOfPeople;
​public​ ​Person​(String firstName, String name) {
​this​.firstName = firstName;
​this​.name = name;
numberOfPeople++;
}
}

Dans cet exemple, à chaque fois qu’une nouvelle personne est créée, la même copie de la
variable « numberOfPeople » est incrémentée.

42.3. Méthode static

Même principe que les attributs static, appartiennent à la classe plutôt qu’à l’objet. Encore
une fois, pas besoin de créer un objet pour l’utiliser, la méthode est indépendante.

Attention, les méthodes static ne peuvent pas être Override. En effet, elles sont lancées lors
de la compilation et un Override est utilisé lors de l’exécution (runtime polymorphisme).

Les méthodes abstract ne peuvent pas être static étant donné que le but d’une méthode
abstract est d’être Override (impossible donc avec une static).
Elles ne peuvent pas utiliser les mots-clefs this ou super (qui permettent d’utiliser la méthode
de la classe parente du même nom ou identifier une méthode entre 2 du même nom ; ce qui
n’a pas de sens dans un static étant donné qu’il n’y a qu’une seule méthode).

Black Widow’s so hot, her bone structure is giving my "bone" structure

Les méthodes static peuvent accéder directement aux attributs et méthodes static mais pas
les non static (elles ont besoin d’un objet pour ça). Les méthodes d’instance peuvent
accéder directement à tout, static ou non.

42.4. Constructeur static

Un constructeur static est utilisé pour initialiser des attributs static. Il est certes possible de
les initialiser static lors de la déclaration mais il y a des cas où il est plus judicieux d’utiliser le
constructeur. Par exemple lorsque l’initialisation des attributs pourrait engendrer des erreurs,
demande une logique supplémentaire ou nécessite de gérer des exceptions.

42.5. Import static

Un import static permet d’accéder aux membres d’une classe sans devoir spécifier le nom
de la classe (voir import).

43. Import:

43.1. De quoi s’agit-il ?

Le mot-clé import permet, comme son nom l’indique, d’importer dans une classe une ou
plusieurs classes contenues dans un autre package que celui courant. Cela permet par la
suite d’appeler des méthodes sans devoir spécifier leur chemin complet. Import est donc
une sorte de raccourci améliorant la lisibilité du code, il n’est pas obligatoire de l’utiliser
(mais c’est une bonne pratique si utilisé judicieusement).

Toujours dans ce but d’amélioration de la lisibilité, il faut faire attention de ne pas avoir des
import inutiles.
Cas particulier : le package [Link] est importé implicitement. Les classes qui le
composent peuvent donc être utilisées directement sans devoir les importer.

43.2. Grammaire
Les import se placent au début du programme, après avoir (optionnel) déclaré le package
dans lequel la classe se trouve.
Il est possible d’importer une classe spécifique :

package ​monPackage;
import​ j​[Link];

Ou un ensemble de classes :

Black Widow’s so hot, her bone structure is giving my "bone" structure

 import​ [Link].*;

Le caractère * étant un joker signifiant que toutes les classes du package [Link] doivent
être importées. C’est particulièrement utile si il est prévu d’utiliser plusieurs classes du
même package, sinon il vaut parfois mieux importer uniquement les classes dont on a
besoin pour éviter d’alourdir le programme.
Il est obligatoire de spécifier le nom du package que l’on souhaite importer, ‘import *’ ne
compilera pas.

43.3. Import static

Il est possible d’importer en utilisant le mot-clé static. Attention, l’import static doit désigner
un membre de la classe, pas la classe en elle-même.
Utiliser ce mot-clé permet par la suite de pouvoir utiliser le membre directement sans devoir
spécifier la classe à laquelle il appartient.

Exemple :
import​ ​static​ [Link];

Cet import permet d’utiliser uniquement ‘PI’ dans la suite du code au lieu de ‘Math().PI’
Attention, le membre appelé doit être également static (voir static). De plus, ce type d’import
doit être utilisé avec parcimonie. Il est en effet parfois beaucoup plus parlant de spécifier le
nom complet d’une variable de classe.

44. Sérialisation :

44.1. Introduction
La sérialisation est la conversion de l’état d’un objet en un flux de byte; la désérialisation fait
l’opposé. Elle convertit un flux en l’état d’un objet. Formulé différemment, la sérialisation est
la conversion d’un objet java en une séquence static de byte qui peuvent être sauvegardé
dans une base de donnée ou transféré sur un réseau.

Black Widow’s so hot, her bone structure is giving my "bone" structure

Si un objet est sérialisable,il pourra être transformé en une suite d'octets.
Sérialiser un objet consiste à le convertir en un tableau d’octet que l’on peut ensuite écrire
dans un fichier, envoyer sur un réseau etc…

Ce mécanisme existe depuis les débuts de l’API Java I/O. Pour sérialiser un objet, il faut le
passer à une instance de ObjectOutputStream (l’objet doit préalablement implémenter
l’interface Serializable). Cependant cette interface ne possédant aucune méthode, il ne
faudra donc pas définir de code.

Si notre classe possède des champs non sérialisables, il faudra accompagner les attribut du
mot-clé ​transient​ (ça les retire du flux sérialiser et après être désérialiser, les champs seront
null.)
Tout wrapper est Serializable

// Création d'une classe Serializable

​public​ ​class​ ​BlackMirrorEP​ ​implements​ ​Serializable​ {

​// La classe String est Serializable, donc ces champs sont légaux.
​private​ String nomEpisode, nomActeur1 ;

​// En revanche la classe Connection ne l'est pas,

​// Il faut donc retirer ce champ de la serialization
​private​ ​transient​ Connection con ;
}

Pour des raisons d’optimisation , ne se trouve dans le flux sérialisé, que le minimum
d’information requis pour reconstruire l’objet. Typiquement, on y trouve donc :
le nom complet de la classe de l’objet
les noms de ses champs, et pour chacun de ces champs, son type et sa valeur

44.2. Sérialisation d’un objet :

La sérialisation d’un objet consiste à passer un objet à la méthode writeObject(Object) de la
classe ObjectOutputStream
Exemple :

Black Widow’s so hot, her bone structure is giving my "bone" structure

 public​ ​class​ ​BlackMirrorEp​ ​implements​ ​Serializable​ {

​ rivate​ ​static​ ​final​

p ​long​ serialVersionUID =
1350092881346723535L;

​private​ String nomEpisode, nomActeur1;

​private​ ​int​ duree ;

​public​ ​BlackMirrorEp​(String nomEpisode, String nomActeur1) {

​this​.nom = nomEpisode ;
​this​.prenom = nomActeur1 ;
}

​public​ String ​toString​() {

StringBuffer sb = ​new​ StringBuffer() ;
​return​ [Link](nom).append(​" "​).append(prenom).toString() ;
}
}

La valeur de serialVersionUID est générée par l’IDE. Lorsqu’une classe implémente

Serializable, l’IDE met une alert si on ne donne pas la valeur explicite de ce nombre.

// Dans une méthode main

// On simplifie le code en retirant la gestion des exceptions
File fichier = ​new​ File(​"tmp/[Link]"​) ;

// Ouverture d'un flux sur un fichier

ObjectOutputStream oos = ​new​ ObjectOutputStream(​new
FileOutputStream(fichier)) ;

// création d'un objet à sérializer

BlackMirror b = n​ ew ​BlackMirror(​"Noel"​, ​"Jon Hamm"​) ;

​ / sérialization de l'objet
/
[Link](b);

​// fermeture du flux dans le bloc finally

Black Widow’s so hot, her bone structure is giving my "bone" structure

Si l'on ouvre le fichier tmp/[Link], on peut lire dedans les informations suivantes en
clair :
● le nom complet de la classe ;
● la liste des champs sérialisés, avec leur type et leur valeur.
On notera qu'il est donc facile de recréer un objet Java à partir d'un flux sérialisé, même
quand on ne possède pas la classe qui a servi à créer cet objet. Il suffit de lire le flux, de
créer une classe de même nom, avec les bonnes caractéristiques.
En aucun cas le flux sérialisé d'un objet Java ne doit être considéré comme une donnée
sécurisée !

La désérialisation est le processus inverse.

44.3. Désérialisation :
// dans une méthode main
// on simplifie le code en retirant la gestion des exceptions
File fichier = ​new​ File(​"tmp/[Link]"​) ;

​ / ouverture d'un flux sur un fichier

/
ObjectInputStream ois = ​new​ ObjectInputStream(​new
FileInputStream(fichier)) ;

​ / désérialisation de l'objet
/
BlackMirrorEp b = (BlackMirrorEp)[Link]() ;
[Link](b) ;

​// fermeture du flux dans le bloc finally

Si jamais notre classe a changé, ou que du moins son serialVersionUID a changé, alors
l'exception [Link] sera jetée.
Dans certains cas applicatifs, le mécanisme standard de sérialisation proposé par Java peut
se révéler inadapté, ou tout simplement ne pas convenir. Il est possible de le surcharger de
trois manières.

Black Widow’s so hot, her bone structure is giving my "bone" structure

45. Répartition mots :
AVIS A TOUTES LES PERSONNES QUI ONT UN MOT QUI A UN RAPPORT AVEC
LES FONCTIONNELS
Compléter le point 25 ce sera beaucoup plus facile ! J'explique déjà pas mal de chose a
vous de rajouter pour pouvoir expliquer votre mot . Mettez le mot en gras comme ça on
sait à quelle partie il appartient et ajouter le entre parenthèse dans le sous titre merci !

Loic (aussi égocentrique que Tony Stark):​ ​implements​, ​while/do-while​,

wrapper/boxing​, ​(Array)List, ​Grammaire ​, ​Polymorphisme
Alexia (aussi bonne (et utile <3) que Black Widow):​ ​forEach​, ​try-catch​,
while/do-while​, ​var args​, i​ f,​ ​break/continue​, ​switch
Corentin (aussi (vieux ?) que Captain America):​ ​Visibilité​, ​Trier​, t​ oString​,​ Flux
englobant​, ​throw(s)
Florian : ​Filtrer​, fichier texte, ​tableau2D​, ​tableau1D, this/super
Cédric : ​Fichier binaire​, ​[Link]​ , ​expression régulière
Youri: ​assignation​, ​object ​, ​objects​, ​post-Incrementation​,
Elodie : ​enum, equals , static, import
Quentin :​ Codage fichier​, ​path(s) ​, ​collections​ , (pour codage fichier vous
pouvez toujours remplir, je n’ai pas su ajouter plus)
Ali : ​sérialisation​, ​constructeur
Loic n°2 : ​extends​, ​encapsulation​, itérer(fonctionnel) et Aide (point 23)
Khalid : Grammaire
Yassine Choq : Grammaire
Younes Kardillo : import, Aide (point 23)
Yassine Akchar : Aide (point 23) , itérer

Reste : Sérialisation, constructeur, codage de fichier, fichier binaire/texte

46. ⚠Help, aidez à compléter:

assignation, grammaire, Flux englobant,sérialisation, constructeur

Black Widow’s so hot, her bone structure is giving my "bone" structure

47. Consignes :

47.1. Modules:
Attention il faut télécharger les modules dans modules complémentaires!

47.1.1. Code Blocks :

Utiliser le langage “java” et le “thème” dracula puis sélectionner le texte et cliquer sur
Format.

47.1.2. Table des matières :

Pour que les mots se trouvent dans la table des matière, il faut remplacer Normal par Titre 1,
les sous-titres seront Titre2 etc. Puis il faut lancer le module Table of Content et cliquer sur
l'icône de refresh. Une fois ça de fait, il faut aussi le faire tout en haut du document , au
niveau du sommaire.

47.2. Répartition :
Mettre en bleu les mots en cours d’écriture et barrer les mots finis (alt + Maj + 5). Si on a
besoin d’aide pour un mot, le mettre en rouge.
Si vous voyez des choses étranges ou expliqué étrangement, ajoutez un commentaire

Black Widow’s so hot, her bone structure is giving my "bone" structure