Le Paradigme objet doit disposer de plusieurs caractéristiques analytiques:

* L'abstraction : est la démarche consistant à ne retenir que les propriétés

(attributs et méthodes) pertinentes
d’un objet pour un problème précis

* Encapsulation : L’encapsulation est une technique qui consiste à considérer les

objets comme des « boites noires »,
dont on ne manipule les attributs que via l’appel de méthodes.

* Polymorphisme: c’est un mécanisme qui permet à une sous classe de redéfinir une
méthode dont elle a hérité tout
en gardant la même signature..

* Héritage : L'héritage permet à de créer des classes (désignées classes

enfants) en se basant les éléments d'une,
ou de plusieurs autres classes (désignée classes parentes) et en
les enrichissants.

* Le principe du typage dynamique, c'est de typer au besoin, pendant l'exécution du

programme : on fait ce que demande
le programme, et on vérifie à chaque opération que le
type correspond bien (ce qui peut se faire assez rapidement si le système des
types est
simple).
C'est le typage le plus utilisé par les langages de script.

* Un langage est typé statiquement si, avant de s'exécuter, le code source passe
par une
phase de vérification des types.
L'avantage du typage statique, c'est qu'il nous prévient de l'erreur avant
l'exécution.

Je trouve que get/set/friend/protected cassent l'encapsulation ..

- Methode Static :Ce sont des méthodes qui appartiennent à la classe mais pas aux
objets instanciés à partir de la classe.
Cette méthode ne peut pas accéder aux attributs de la classe.
- Variable Static : Un attribut déclaré comme statique se comporte comme une
variable globale, c'est-à-dire une variable
accessible partout dans le code.
on ne peut pas initialiser l'attribut statique dans la classe,il
faut le faire dans fichier.cpp.

- Une méthode virtuelle pure : est une méthode qui est déclarée mais non définie
dans une classe.
Elle est définie dans une des classes dérivées de
cette classe.
virtual type nom(paramètres) =0;
- Une classe abstraite :est une classe comportant au moins une méthode virtuelle
pure.
il est impossible d'instancier des objets pour ces classes.
En revanche, on pourra les référencer avec des pointeurs.

- Une fonction amie : d'une classe peut accéder à tous ses éléments, même les
éléments privés.

- Attention à ne pas confondre Interface et Class. Il faut bien faire la différence

entre le rôle de chacune.
- Interface : une interface est un contrat. Elle sert à spécifier un comportement
attendu sans préciser le code de ce comportement.

- Class : une classe définit le code d'un comportement. C'est dans une classe que
l'on trouve le code servant à faire fonctionner votre application.

- Une interface ne peut pas être instanciée.

- Pour tester generate , nous allons créer un faux Writer : un Writer qui
n'écrit rien du tout, mais qui stocke ce qu'il doit écrire.
Cela sera beaucoup plus simple pour tester. On appelle cela un Mock.

- Les inner classes : ce sont des classes déclarées dans d'autres. C'est rare d'en
trouver, mais parfois il y en a besoin.
Vous allez certainement en rencontrer un jour ou l'autre.

- les classes anonymes : c'est ce que nous allons utiliser. Cela consiste à faire
un héritage dans le code, sans créer de nouvelle classe.
On change le comportement de base de la classe sans en créer une nouvelle.

-Le mot clé super permet de :Appeler la méthode parente d’une méthode surchargée
(y compris le constructeur).

- Un programmeur crée un mock dans le but de tester le comportement d'autres

objets, réels, mais liés à un objet inaccessible ou non implémenté.
Ce dernier est alors remplacé par un mock.

-Un thread désigne un « fil d'exécution » dans le programme ; c'est-à-dire une

suite linéaire et continue d'instructions qui sont exécutées séquentiellement les
unes après les autres.
En fait, le langage Java est multi-thread, c'est-à-dire qu'il peut faire cohabiter
plusieurs fils d'exécution de façon indépendante.

-Une deadlock intervient lorsqu'un premier thread T1 se trouve dans un bloc

synchronisé B1, et est en attente à l'entrée d'un
Malheureusement, dans ce bloc B2, se trouve déjà
pouvoir entrer dans B1.
Ces deux threads s'attendent mutuellement, et ne
La situation est bloquée,
la seule façon de la débloquer est d'interrompre
autre bloc synchronisé B2.
un thread T2, en attente de
peuvent exécuter le moindre code.
un des deux threads .

- Synchronisation Java :
* On peut ajouter le mot-clé synchronized en tant que modificateur d'une méthode
statique.
Dans ce cas le paramètre de synchronisation est la classe qui possède ce bloc.

* On peut l'ajouter comme modificateur d'une méthode non statique. Dans ce cas, le
paramètre de synchronisation est l'instance de cette classe dans laquelle on se
trouve.
On peut accéder à cette instance par le mot-clé this.

* On peut enfin créer un bloc commençant par le mot-clé synchronized. Dans ce cas,
le paramètre de synchronisation doit être passé explicitement à l'ouverture de ce
bloc.
Ce peut être tout objet Java.

-Le bytecode est un code binaire, ce qui permet un traitement plus rapide que le
code source Java,
 et qui rassemble (compile) tous les codes dispersés dans différents fichiers lors
de l'écriture du programme.

-En programmation, la généricité (ou programmation générique), consiste à définir

des algorithmes identiques opérant sur des données de types différents.
On définit de cette façon des procédures ou des types entiers génériques.

-Une expression lambda permet d'encapsuler un traitement pour être passé à d'autres
traitements. C'est un raccourci syntaxique aux classes anonymes internes
pour une interface qui ne possède qu'une seule méthode abstraite. Ce type
d'interface est nommé interface fonctionnelle.

* Doctrine :
- Un mapping objet-relationnel (en anglais object-relational mapping ou ORM) est un
type de programme informatique qui se place en interface entre un programme
applicatif
et une base de données relationnelle pour simuler une base de données orientée
objet.
-L'utilisation de la programmation orientée objet avec une base de données
relationnelle nécessite de convertir les données relationnelles en objets et vice-
versa.
Ceci conduit à programmer cette conversion pour chaque objet et donc à dupliquer
énormément de code similaire.