index.ad

= Cours de programmation orientée objet avec Java
:author: Arnaud Tournier
:email: ltearno@gmail.com
:toc: macro
:toc-title: Cours de programmation orientée objet avec Java

LTE Consulting (C) - 2016

toc::[]

Ce cours est open source et est disponible en ligne : https://github.com/ltearno/formation-programmation-java[github.com/ltearno/formation-programmation-java]

== Enjeux et Etat de l'art

== UML - conception objet

=== Modélisation objet

=== Diagramme de cas d'utilisation

=== Diagramme de classe

=== Diagramme de séquence

== Java - Les fondamentaux

=== Présentation de Java et JVM

=== Principes

=== Programme `HelloWorld`

Créez un projet vide et un fichier `HelloWorld.java` dedans avec le contenu suivant :

[source,language="java"]
----
public class HelloWorld
{
	public static void main( String[] args ) <1>
	{
		System.out.println( "Bonjour tout le monde !" ); <2>
	}
}
----
<1> Méthode principale du programme.
<2> Appel qui permet d'afficher "Bonjour tout le monde !" à l'écran.

Compiler ce code avec la commande

`javac HelloWorld.java`

Ceci produit un fichier `HelloWorld.class` contenant le byte-code issue de la compilation du code source.

Exécutez ce programme avec la commande :

`java HelloWorld`

Le programme écrit "Bonjour tout le monde !" sur la console.

=== Variables

Variable:: un emplacement en mémoire avec un _nom_ et un _type_.

==== Déclaration

Ceci déclare une variable nommée `i` de type `int`.

[source,language="java"]
----
int i;
----

==== Affectation

Ici nous affectons la valeur `42` à la variable `i`.

[source,language="java"]
----
int i; <1>
i = 42; <2>
----
<1> Déclaration
<2> Affectation

==== Utilisation

Pour utiliser la valeur contenue dans la variable, il suffit de mentionner son nom :

[source,language="java"]
----
int v = i; <1>

System.out.println( "La valeur de v est : " + v ); <2>
----
<1> Lecture de `i` pour affecter la variable ``v`
<2> Lecture de `v` pour construire la chaine qui va s'afficher dans la console.

=== Les types primitifs

Il existe en Java deux familles de type : les types primitifs et les types objet.

Les types primitifs portent des valeurs, en voici la liste : 

- valeur booléenne : `boolean`,
- valeurs entières : `byte`, `short`, `int`, `long`,
- valeurs flottantes : `float` et `short`,
- valeur caractère (unicode, 16 bits) : `char`.

=== Structures de controle

=== Ecrire une classe

==== Un fichier, une classe

Une classe java est écrite dans un fichier nommé par le même nom (et même casse) auquel on donne l'extension `.java`.

Ce fichier .java sera situé dans un sous-répertoire du répertoire `src/` du projet, et qui correspondra au chemin jusqu'au _package_ de la classe.

NOTE: Il est néanmoins possible de déclarer plusieurs classes dans un même fichier *.java*. Nous reviendrons sur ces cas plus tard dans le cours.

==== Déclaration d'une classe

Pour créer une classe, on utilise le code suivant :

[source,language="java"]
----
[public] class NomDeLaClasse
{
	// Corps de la classe (attributs et méthodes)
}
----

NOTE: Par convention les noms de classes commencent par une majuscule comme par exemple `NomDeLaClasse`.

==== Fully Qualified Name

Le véritable nom complet d'une classe s'appelle le _Fully Qualified Name_. Il est composé du _nom de package_ dans lequel se trouve la classe ainsi que du _nom de la classe_ lui-même.

Ainsi pour une classe déclarée ainsi :

[source,language="java"]
----
package fr.lteconsulting;

class MaClasse
{
	// ...
}
----

Le _FQN_ de cette classe est `fr.lteconsulting.MaClasse`.

NOTE: Par convention les noms de package sont tout en minuscule, comme par exemple : `fr.lteconsulting`.

==== Importation avec `import`

Lorsque l'on souhaite utiliser une classe qui n'est pas située dans le même package que celle qui l'utilise, on peut l'importer, de façon à ne pas avoir à rappeler le _FQN_ complet à chaque utilisation.

Ainsi, à la place de ceci :

[source,language="java"]
----
package fr.lteconsulting;

class MaClasse
{
	MaClasse()
	{
		fr.lteconsulting.outils.MonOutil outil;
		outil = new fr.lteconsulting.outils.MonOutil();
	}
}
----

On pourra écrire ceci :

[source,language="java"]
----
package fr.lteconsulting;

import fr.lteconsulting.outils.MonOutil;

class MaClasse
{
	MaClasse()
	{
		MonOutil outil;
		outil = new MonOutil();
	}
}
----

- écrire attribut
- écrire méthode
- constructeur
-- délégation
-- this et super

=== Classes abstraites

=== Classes finales

=== Champs et méthodes statiques

Attribut statique:: un attribut partagé par toutes les instances d'une classe.

Attribut d'instance:: chaque objet a SA propre valeur pour cet attribut

=== Héritage

==== Conversion de type (`instanceof` et transtypage)

Le système de typage de Java n'est pas unifié.

=== La classe `Object`

==== `equals()` et `hashCode()`

==== `toString()`

==== `getClass()`

=== Annotations introduction : @Deprecated, @Override

=== Interfaces

- séparer le contrat de l'implémentation
- écrire une interface
- implémenter une interface

*Exercice* : recoder l'exercice du jeu de cartes, en créant une interface `ICarte`, une classe de base `AbstractBaseCarte` qui contient le champ `protected` `cout`. Seules `Sortilege` et `Creature` héritent de `AbstractBaseCarte`. Les trois classes de cartes implémentent `ICarte`. Ceci nous montre comment bien séparer implémentation et contrat d'utilisation.

=== Les génériques

==== Classes génériques

==== Méthodes génériques

==== Spécifier des contraintes sur le type générique (ex: `<T extends ICarte>`...)

==== Problème de la covariance

*Exercice* : implémenter une classe `TableauDynamique<T>` permettant de stocker un nombre variable d'éléments de type `T`. La classe aura au moins les méthodes `T get(int index)`, `void set(int index, T value)` et `int size()`.

*Exercice* : utiliser la classe `TableauDynamique<ICarte>` dans le projet de cartes...

*Exercice* : refaire l'alogrithme du tri avec les génériques (interface `Triable` plus `<T extends Triable> T[] trier( T[] data )`). Attention, le tri ne fonctionnera plus sur les types primitifs (auto-boxing).

*Exercice* : si on implémente l'algorithme de tri en prenant des données triables (`<T extends Triable>`), par fois la hierarchie des classes ne permet pas de modifier celle-ci. On définit donc une interface `Comparateur<T>` dont on demande une instance dans la nouvelle méthode `trier` : `<T> T[] trier( T[] data, Comparateur<T> comparateur)`. Vérifier que la méthode `trier(...)` a bien été implémentée deux fois. Bien comprendre que la contrainte de type permet de garantir la correspondance entre les types d'entrée et de sortie.

=== Classes imbriquées

==== Classes imbriquées statiques

===  Classes imbriquées

=== Classes anonymes

=== Quelques classes du SDK : `Iterable<T>` et la boucle for, `Comparable<T>`, `ArrayList<>`, `List<>`, `StringBuilder`, ...

*Exercice* : implémenter `Iterable<T>` dans TableauDynamique et utiliser la forme _foreach_ de la boucle `for` dans le projet des cartes.

=== Les exceptions

=== Communication entre objets (patterns de communication)

== A suivre...

- Java EE - Architectures distribuées
- Java EE - Servlets, JSP, EJB
- Design patterns
- Spring IOC et TDD
- XML, DTD, XSL, XSLT
- SOA - Approche orientée services
- RIA - Rich internet applications

- Java : file system, threads, ...
- Tests unitaires
- Maven
- GWT
- Spring Boot -> les indispensables : JPA, IOC, conf discovery, ...
- Docker
- HTML5 CSS3 Javascript, Typescript

TOTAL = 8 semaines.