Lecture 1 

: Initiation
• Java Tutorials : https://docs.oracle.com/javase/tutorial/
• Type primitifs : int, short, byte, long, char, float, double, boolean
• Variable : portée (local, globale)
• Constante: (en majuscule), mot clé final
• Lectures/Ecriture: System.out.println()
• Structures conditionnelles: if else, assert , switch… case… break…. default,
• Structures Itératives :
o for, do..while, while, break, continue
o Accès lecture seulement, accès lecture et écriture
• Type évolués :
o String,
o Tableau statique 1D, 2D
o Type enveloppeur (Wrapper) : Integer, Double, Boolean
o Tableau dynamique (ArrayList) 1D, 2D,
• Méthodes
o Surcharge, retourne (void, type primitive, type évolué)
o Paramètres primitives (passage par valeur), évolués (passage par
adresse) (En TP)
• TP
o Résolution de l’Equation ax²+bx+c
o Jeu Puissance 4
Lecture 2 : Encapsulation/Abstraction
• Exemple : création d’une première classe (classe main) (mot clé class)
• Package : notion de package (mot clé package)
• Classe : instanciation, notion d’objet et d’instance (mot clé new)
• Attributs
o Initialisation par défaut des attributs (0, 0.0, false, null)
o Accès : modificateurs public et private
• Méthodes :
o Accès : modificateur public et private
o Test d’une méthode non public appelée dans un autre package (En
TP)
o Getters et setters public
• L’opérateur this pour l’accès aux attributs
• Différences entre attribut, paramètre de méthode et variable locale
• Constructeur
o Définition : méthode public qui a le même nom de la classe et qui n’a
pas de type de retour (En TP)
o Constructeur par défaut par défaut
o Constructeur sans paramètre remplace le constructeur par défaut par
défaut
o Constructeur avec paramètre annule la présence du constructeur par
défaut par défaut
o Le constructeur this()
o Constructeur de copie
• Relations entre classes:
o Association, et Composition (relation “à un” = “client/serveur”),
o Heritage (relation “est un”) voir plus tard.

Client Serveur
Association/ public class Cercle { public class Point { ... }
Aggregation private Point centre; .
…
}
Composition public class Cercle { public class Point { ... }
private Point centre;
Cercle {
centre = new Point(…)
}
}

• Opération sur les objets

o Affectation (=)
o Copie (new)
o Affichage (toString())
o Comparaison (==, equals(Object o))
• Enumérations
o Une classe contenant une liste de sous-objets, hérite de java.lang.Enum
 o Déclaré avec enum
• TP
o Jeu morpion
o Série1, Série2
Lecture 3 : Héritage et Polymorphisme

• Créer la classe Personnage.

o Pour pouvoir étendre une classe avec extends, il ne faut pas qu’elle
soit final
• Créer la classe Voleur fille de Personnage (Relation « est un »)
o Dans Voleur, on ne peut accéder aux attributs de la classe mère
(Personnage) s’ils sont private. Pour se faire, il faut les mettre
protected.
o Différence entre surcharge (overloading) et redéfinition (overriding).
o Une méthode final ne peut être redéfini dans une autre classe
(exemple méthode vieillir() de Personnage)
o Une classe peut appeler les méthodes de sa classe mère tant qu’elles
sont public ou protected (exemple Voleur)
o Les constructeurs ne sont pas hérités!. Par contre peuvent être
appelés à l’aide de super()  : attention doit être la première
instruction.
• Créer la classe Magicien fille de Personnage (Relation « est un »)
o Enrichissement : Magicien ajoute d’autre attributs et méthodes
o Shadowing (Masquage) : masquer un attribut (durreDeVie), et appelle
de l’attribut de la classe mère avec super.attribut
o Overriding (Redéfinition) : redéfinition de la méthode et appelle de la
méthode mère avec super.methode().
• Créer la classe Guerrier fille de Personnage
o Créer une classe Arme et instancier un objet de type Arme dans la
classe Guerrier (relation « a un »)
• L’héritage multiple impossible en Java (voir la notion d’interface plus tard)
• Créer la classe Sorcier fille de Magicien
o La méthode rencontrer() redéfini celle de Magicien qui redéfinit celle
de Personnage.
o Créer une classe Baton et instancier un objet de type Baton dans la
classe Sorcier (relation « a un »)
o Le constructeur super() référence celui de la classe mère Magicien.
• Polymorphisme
o Dans une hiérarchie de class, un objet peut avoir plusieurs types. Un
objet de type Personnage peut être de type Voleur, Magicien,
Guerrier, Sorcier.
 Personnage p = new Voleur() ;
o Deux manières de résolution :
▪ Résolution statique : type apparent qui est appelée
(Personnage)
▪ Résolution dynamique : type effectif qui est appelée (Voleur).
En Java la résolution dynamique est celle qui est adoptée.
o Cast : voir UpDownCasting.java
▪ UpCasting : effectué automatiquement
▪ DownCasting : à préciser explicitement
o Mot clé instanceof
• Méthode et classe abstract (Lecture33) :
o Une méthode abstract est une méthode sans corps, déclarée dans une
classe mère pour être redéfini dans toutes ses classes filles. Ces
dernières peuvent rester abstract dans le cas où elles choisissent de
ne pas redéfinir ces méthodes. (Voir exemple class FigureFermee)

o Une classe qui contient une méthode abstract doit absolument être
abstract

o Une classe abstract ne peut être instanciée tant qu’elle n’a pas
implémentée toutes ses méthodes abstract.

o Attention  : implémentation d’une méthode abstract dans un

constructeur, possible mais dangereux (voir exemple classes A et B)

• Class Object et objet final (Lecture34):

o Mère de toutes les classes : Object, (voir plus tard)

o Variables primitifs final  ➔ constante,

o Variables évoluées (objets) final  ➔ ne peut pas être ré-instancier

avec new (voir exemple classe F)

o Méthode final ➔ ne peut être redéfini (overriding),

o Classe final ➔ ne peut être étendue (exemple classe, C et D)

Lecture 4 : Static, inner class, lambda
• Attribut static :

o L’affectation d’une valeur à un attribut static modifie la valeur de

cet attribut dans toutes les instances de la classe, ce qui permet de
préserver la mémoire.

o Peut être appelé avec le non de la classe au lieu de son instance.

o Le plus souvent, les constantes sont déclarées final static.

o Résumé : Types des variables :

▪ Variables d’instance (attributs d’une classe),

▪ Variables locales  : (arguments d’une méthode, variables dans

une méthode),

▪ Variables de class (attributs static d’une classe).

• Méthode static

o Peut seulement accéder à d’autres méthodes static et à des variables

static (Donc pas d’opérateur this).

o Par exemple : public static void main(String[] args): ne peut contenir

que des variables et méthodes static et ne contient pas this.

• Class static: (Option): see Lecture 14 (nested classes)

Lecture 5 : Interfaces
• Les classes héritant d’une classe abstract doivent absolument implémenter
toutes ses méthodes abstraites pour pouvoir être utilisées  ! ➔ Solution :
interface.

• C’est une alternative de l’héritage multiples dans d’autres langages. (voir

exemple: Jeu de tennis)

• Une interface

o Ne contient pas de constructeur.

o Peut contenir des constantes final static

o Toutes les méthodes sont par défaut abstract

o Défini une relation « se-comporte-comme »

• Une classe implements une ou plusieurs interfaces. Elle doit dans ce cas
implémenter toutes les méthodes de ces interfaces ainsi que leurs
interfaces mères.

• Une hiérarchie d’interface donc est possible : une interface peut étendre
une autre interface comme le font les classes entre elles avec extends

• downCasting des interfaces

• Instanceof pour les interfaces

• Faire une classe C qui implémente deux interfaces A et B. Que se passe t-il
si les deux interfaces A et B déclarent une même méthode f()? Une même
constante x? Indication: pour le savoir, créer une classe Test qui utilise f() et
x. Pourquoi ne peut-on utiliser x? (réponse: La définition de x est dans les
interfaces. Non celle de f().)

• (année prochaine)
Lecture 6 : Exceptions
• Hiérarchie de Throwable. (https://docs.oracle.com/javase/7/docs/api/
java/lang/Throwable.html)

• try.. catch.. finally

• 3 types d’exceptions

o Checked: extends Exception et ses classes filles

o Unchecked: extends Error ou RunTimeException et ses classes filles

• Exemples de Error

o OutOfMemoryError : dépasser la taille maximal d’un entier

(TestOutOfMemoryError.java)

o StackOverflowError : méthode récursive

(TestStackOverflowError.java)

• Exemple de Exception

o (RuntimeException) ArithmeticException : division par zero

(TestArithmeticException.java)

o (IOException) FileNotFoundException : fichier non trouvé

(TestFileNotFoundException.java)

• Le traitement des exceptions se fait de bas en haut (ArithmeticException,

RuntimeException, Exception …) (TestHierarchyException.java)

o try (IOException | IndexOutOfBoundsException e) // (e est final)

• Le block finally est utilisé pour récupérer les resource (ex: fermé un stream)

• Propagation des exceptions d’une méthode à une autre

(TestPropagationException.java)

• Pour générer une exception, il suffit d'utiliser le mot clé throw, suivi d'un
objet dont la classe hérite de Throwable.

o ex: throw new MyException()

• Si l'on veut générer un objet exception dans une méthode avec throw, il faut
indiquer son type dans la déclaration de la méthode, en utilisant le mot clé
throws. (pas obligatoire pour unchecked exceptions)

o ex: public void myMethode() throws MyException

• On peut créer des classes d’exceptions personnalisées. Elles doivent

descendre des classes Exception ou RunTimeException mais pas de la classe
Error.
 • Il est préférable (par convention) d'inclure le mot « Exception » dans le nom
de la nouvelle classe.

• Checked Exceptions :

o extends Exception

o La méthode appelante doit être absolument déclarée avec throws

o La méthode qui la lance doit absolument être dans un bloc try…

catch

• Unchecked :

o Extends RunTimeException (déconseillé)

o Peut ne pas être déclarée avec throws dans la méthode appelante

o La méthode qui la lance peut ne pas être dans un bloc try… catch

New: try with resources syntax: see

https://stackoverflow.com/questions/10115282/new-strange-java-try-syntax?
utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa

https://docs.oracle.com/javase/tutorial/essential/exceptions/
tryResourceClose.html

!
Lecture 7 : Généricité (java generics)
• La généricité permet la construction des classes qui n'acceptent qu'un
certain type d'objets ou de données de façon dynamique.

• Le Jocker (wildcard): exemple (Camera extends Machine)

o ArrayList<?>

o ArrayList<? extends Machine>

o ArrayList<? super Camera>

Lecture 8 : Collections (java.utils.*)
• ArrayList: ArrayList<Integer>
o for(int i; …): parcourir pour lecture et écriture (lent)
o for(Object o: al): parcourir pour lecture seulement (rapide)
o Lecture avec Iterator
o Lecture et écriture avec ListIterator (spécifique pour les Objets List)
• Set est une collection qui n'accepte pas de doublons.
o Exemple : HashSet, TreeSet
o HashSet<Double>
o Parcours avec un tableau d'objet (conversion et parcours)
• Map est une collection qui fonctionne avec un couple (clé,valeur). La clé est
unique.
o exemple: Hashtable, HashMap, TreeMap, WeakHashMap
o Lecture avec Enumeration
o ils se diffèrent par leur rapidité, collisions (plusieurs threads) , tri..
o Hashtable<Integer,String>
• LinkedList: utilisé surtout pour l'insertion rapide des données au milieu de la
liste
o LinkedList <Double>
Lecture 9: ES et Sérialisation
Lecture 12: Java FX
• Install Scene builder 8

• Install e(fx)clipse sur eclipse

• JavaFX permet la séparation entre :

o Conception : .fxml :

▪ Parent root = FXMLLoader.load(getClass( ).getResource(‘ path

’)

o Style : .css

▪ scene.getStylesheets().add(getClass().getResource(‘path’)

o Algorithme : .java
Lecture 14: Nested classes

• non-static: inner classes

• static: nested classes

• Anonymous classes

• Lambda expression
Annexe : Java Keywords
abstract continue for new switch

assert*** default goto* package synchronized

boolean do if private this
break double implements protected throw
byte else import public throws

case enum**** instanceof return transient

catch extends int short try
char final interface static Void

class finally long strictfp** Volatile

const* float native super while

* not used (const replaced by final, goto obselete)

** added in 1.2
*** added in 1.4
**** added in 5.0

synchronized, volatile : see threads

native: applied to methods from other languages (see java native
interface JNI)
transiant: see serialization
strictfp: ensures that you will get the same result on every
platform for floating-point variables.