---
title: Glossaire Android DIM 2022
tags: glossaire, course, glossary
---

:::info
**A vous de compléter ce glossaire, nous avons déjà mis quelques mots à définir, mais c'est votre glossaire de promo, ajouter ce que vous voulez d'utile.**
Ce document sera autorisé lors de l'examen.
Cliquez sur l'aide en haut pour des infos sur le formattage du texte en Markdown
:::

1. **Henri** est aussi grand que **Gauthier**.
1. **Simon** est aussi beau qu'un **tractopelle cabriolet de combat 4 places avec climatisation et toit ouvrant**.
1. N'oubliez pas la **dame de la cantine** qui nous appelle "**Mon Loulou**".

### Moshi
Moshi est un Content negociator pour transformer le JSON en objet Kotlin
### Socket
Un socket est un flux de communication entre deux objets.
Exemple : serveur -> Client / Client -> Serveur

### WebSocket
L'API WebSocket est une technologie évoluée qui permet d'ouvrir un canal de communication bidirectionnelle entre un navigateur (côté client) et un serveur.

### Okhttp
OkHttp est une bibliothèque tierce développée par Square pour envoyer et recevoir des requêtes réseau basées sur HTTP. Il est construit au-dessus de la bibliothèque Okio, qui essaie d'être plus efficace pour lire et écrire des données que les bibliothèques d'E/S Java standard en créant un pool de mémoire partagée. Il s'agit également de la bibliothèque sous-jacente de la bibliothèque Retrofit qui fournit une sécurité de type pour la consommation d'API basées sur REST.

La bibliothèque OkHttp fournit en fait une implémentation de l'interface HttpUrlConnection, qu'Android 4.4 et les versions ultérieures utilisent désormais. Par conséquent, lors de l'utilisation de l'approche manuelle décrite dans cette section du guide, la classe HttpUrlConnection sous-jacente peut exploiter le code de la bibliothèque OkHttp. Cependant, il existe une API distincte fournie par OkHttp qui facilite l'envoi et la réception de requêtes réseau, qui sont décrites dans ce guide.

### Retrofit
Retrofit est une librairie qui permet d’accéder simplement à des web services et plus particulièrement dans le cadre d’API JSON. Elle permet de gérer l’envoi des requêtes et la réception des réponses jusqu’à leur conversion sous forme d’objets.

### Build System

Le système de **build Android** compile **les ressources d'application** et le **code source**, et les regroupe dans des ***APK*** ou des ***bundles d'applications*** Android que vous pouvez tester, déployer, signer et distribuer.
Chaque configuration de build peut définir son propre ensemble de code et de ressources, tout en réutilisant les parties communes à toutes les versions de votre application.

### Gradle

Android Studio utilise **Gradle**, une boîte à outils de génération avancée, pour automatiser et gérer le processus de génération, tout en vous permettant de définir des configurations de génération personnalisées et flexibles.

Gradle intervient seulement à la compilation et pas au run, il n'est donc pas possible que Gradle agisse sur le programme une fois que celui ci est lancé

Gradle va notamment compiler les interfaces XML en bytecode accessibles par votre code, s'occuper de gérer les assets et les rendre accessibles, dupliquer les images pour différentes tailles d'appareil, etc.


### Gradle Wrapper
La méthode recommandée pour exécuter n'importe quelle construction Gradle est à l'aide du Gradle Wrapper (en bref, juste "Wrapper"). Le Wrapper est un script qui invoque une version déclarée de Gradle, en la téléchargeant au préalable si nécessaire. En conséquence, les développeurs peuvent rapidement démarrer avec un projet Gradle sans avoir à suivre les processus d'installation manuelle, ce qui permet à votre entreprise d'économiser du temps et de l'argent.

### Inflater
Lors de la création d’une page .xml, elle est inflate par android, cela signifie qu’elle sera rendue en créent un objet de vue en mémoire

### Material Design
Le Material Design est un ensemble de règles de design proposées par Google et qui s'appliquent à l'interface graphique des logiciels et applications1. Il est utilisé notamment à partir de la version 5.0 du système d'exploitation Android.

Google a présenté le Material Design pour la première fois lors de la conférence Google I/O, le 25 juin 2014. En misant sur les motifs « carte », déjà utilisés dans Google Now, ces règles de design mettent l'accent sur une utilisation accrue des mises en page basées sur une grille, des animations et des transitions, des effets de profondeur tels l'éclairage et les ombres. Selon Google ce nouveau langage de design est basé sur le papier et l'encre.

Le designer Matías Duarte explique que « contrairement au vrai papier, notre matériau numérique peut s'étirer et se modifier de manière intelligente. Le matériau contextuel a une surface physique et des bords. Les superpositions et les ombres donnent des informations sur ce que vous pouvez toucher ».

Ce design d'interface utilisateur succède au design Holo utilisé par Android de la version 4.0 à la version 4.4.

L'implémentation du Material Design pour les interfaces utilisateur d'applications web est appelée Polymer paper elements. Il existe à travers la librairie Polymer qui fournit une API de composants web aux navigateurs qui n'implémentent pas nativement le standard ainsi que par une collection d'éléments appelée Paper elements collection.

### Live Data

La classe **LiveData** permet de créer des objets de données qui notifient les vues lorsque la base de données change. En effet cette classe est observable, un **observateur** comme une activité ou un peut être notifié lorsque les données détenues par l’objet LiveData changent, ainsi les interfaces utilisateur se mettent à jour automatiquement lorsque les données sont mises à jour. Cette classe est également sensible au **cycle de vie**, il ne met à jour que les observateurs qui sont dans un état de cycle de vie actif (started ou resumed).

* LiveData est une classe de détenteurs de données observables qui tient compte du cycle de vie, l'un des composants de l'architecture Android .
* Vous pouvez utiliser LiveData pour permettre à votre interface utilisateur de se mettre à jour automatiquement lorsque les données sont mises à jour.
* LiveData est observable, ce qui signifie qu'un observateur comme une activité ou un fragment peut être averti lorsque les données détenues par l' LiveDataobjet changent.
* LiveData contient des données ; c'est un wrapper qui peut être utilisé avec n'importe quelle donnée.

Pour ajouter des LiveData
* Modifiez le type des variables de données dans ViewModel en LiveData ou MutableLiveData.
* MutableLiveData est un LiveDataobjet dont la valeur peut être modifiée.
* MutableLiveData est une classe générique, vous devez donc spécifier le type de données qu'elle contient.
* Pour modifier la valeur des données détenues par le LiveData, utilisez la setValue()méthode sur la LiveDatavariable.

Pour encapsuler LiveData
* L' LiveData intérieur ViewModel doit être modifiable. En dehors du ViewModel, le LiveData devrait être lisible. Cela peut être implémenté à l'aide d'une propriété de support Kotlin .
* Une propriété de support Kotlin vous permet de renvoyer quelque chose d'un getter autre que l'objet exact.
* Pour encapsuler le LiveData, utilisez private MutableLiveDataà l'intérieur du ViewModel et renvoyez une LiveData propriété de support en dehors du ViewModel.

Données en direct observables

* LiveData suit un modèle d'observateur. "L'observable" est l' LiveDataobjet et les observateurs sont les méthodes des contrôleurs d'interface utilisateur, comme des fragments. Chaque fois que les données enveloppées à l'intérieur LiveDatachangent, les méthodes d'observation dans les contrôleurs d'interface utilisateur sont notifiées.
* Pour rendre l' LiveData observable, attachez un objet observateur à la LiveDataréférence dans les observateurs (tels que des activités et des fragments) à l'aide de la observe()méthode.
* Ce LiveData modèle d'observateur peut être utilisé pour communiquer du ViewModelaux contrôleurs d'interface utilisateur.

### Observable
Cette classe représente un objet observable, ou "données" dans le paradigme modèle-vue. Il peut être sous-classé pour représenter un objet que l'application veut voir observé.

Un objet observable peut avoir un ou plusieurs observers. Un observer peut être n'importe quel objet qui implémente l'interface Observer. Après la modification d'une instance observable, une application appelant la Observableméthode notifyObserversde entraîne la notification de la modification à tous ses observateurs par un appel à leur updateméthode.

### Backstack
Pile où l’on range les activités dans l’ordre dans lequel elles sont ouvertes.

### Kotlin Keywords
* **fun**

fun numberOfCharactersInString(inputString: String): Int {
    return parameter.length
}

* **val** :
* **var** :
* "**?**" : indique au compilateur que cette variable est parfois "null".

//On a rajouté un signe "?" derrière notre type.
class OtherClass(var myVar:String? = null)

* **let**

//Je veux récuperer la réponse du réseau si il y en a une
myNetworkResponse?.let {  
    //La fonction `let` permet de unwrap 🌮 votre variable
    //Elle produit une valeur non optionnel "it" par defaut
    saveNetworkResponseToDataBase(it) 
    //"it" est certain d'exister, et est non null
}

* **!!** : force le compilateur à ne pas vérifier si cette variable est vide avant de l’utiliser.

saveNetworkResponseToDataBase(myNetworkResponse!!)

* **\+ et $** : concatener une string
A l'intérieur des double quotes :
"Je concatene avec $maVariable".
"Je concatene avec ${maVariable.maProp}"
* **when** : équivalent du switch
* **data class** : type de classe dédié au stockage de la donnée. Le compilateur créé automatiquement les fonctions utilitaires. (equals(), toString(), copy(), ...)
* **lateinit** : permet d'initialiser une propriété non nulle en dehors d'un constructeur.

### Data Binding - Binding

Le binding dans le framework Android est le fait de lier la définition de l’interface de l’application au code. Cela permet au code de modifier l’interface dynamiquement et à l’interface d’envoyer des informations de saisies au code par exemple.

### Kotlin

**Kotlin** est un langage de programmation orienté **objet** et **fonctionnel**, avec un typage **statique** qui permet de compiler pour la machine virtuelle Java, JavaScript, et vers plusieurs plateformes en natif.
### Drawable
Un drawable est un fichier ressource qui peut être une icône, une image sous la forme d’un SVG. On peut ensuite utiliser ce drawable dans un layout.

### MVVM
Le **modèle MVVM** (Model-View-ViewModel) est un modèle de conception architecturale d'interface utilisateur permettant de découpler l'interface utilisateur et le code qui ne lui est pas associé

### ORM
Object Relationnel Mapping : est une interface entre le code métier et la base de données. Elle permet de transformer les données de résultat de requette SQL en objets utilisables dans le code métier.

### Lifecycle

Le **cycle de vie** est une série de rappels exécutés dans un certain ordre lorsque le statut de l'activité ou du fragment change.

Le cycle de vie est important car certaines actions doivent avoir lieu lorsque l'activité ou le fragment se trouve dans un état spécifique.

> [color=#50bfc9]
> * La méthode *onCreate()* se lance. C'est l'occasion pour vous de construire votre UI et d'initialiser votre activité.
> * A noter qu'il est possible à ce stade de récupérer les données issues d'un précédent lancement qui aurait été interrompu. Suite à cette méthode, *onStart()* sera lancée.
> * Vient la méthode *onStart()*. L'activité va devenir visible à l'utilisateur. Ca peut être l'occasion pour vous de charger les données en base de données, mais vous pouvez aussi choisir de le faire dans le *onResume()*
> * *onResume()* est lancée lorsque votre application est passée en avant plan, c'est à dire que l'UI est visible, et que l'utilisateur peut intéragir avec elle.
> * Quand une autre activité **demande** à s'afficher en avant plan, alors votre activité à vous passe dans la méthode *onPause()*. C'est l'occasion de sauvegarder tout ce qu'il y a à sauvegarder (BDD, Saisies utilisateurs).


### LifecycleOwner

Un propriétaire de cycle de vie est un composant qui implémente l'interface LifecycleOwner. Cette interface a une méthode que le propriétaire doit implémenter : Lifecycle.getLifecycle(). Fondamentalement, toute classe qui implémente cette interface peut être propriétaire du cycle de vie.

> La classe Fragment implémente déjà cette interface, c'est un LifecycleOwner

### Lifecycle aware

Un composant est **lifecycle aware** lorsqu’il exécute des actions en réponse à un changement d’état du cycle de vie d’un autre composant, comme les activités et les fragments.

### ConstraintLayout

Le **ConstraintLayout** est une façon d'afficher ses composants dans un Layout. Il existe aussi le ~~LinearLayout~~.

Comme son nom l'indique, il fonctionne sur un système de **contrainte**.


**!!ATTENTION!! L'image possède une erreur corrigée plus bas.**
> Le block "A" à pour contrainte la marge en haut ainsi que celle à droite.
>
> Le block "B" à pour contrainte la hauteur du block "A" ainsi que la marge à gauche sur le block "A" et la marge à droite.
>
> Le block "C" à pour contrainte la largeur à gauche et à droite du block "A".
>
> Toute fois le block "C" n'a pas d'hauteur, il devrait donc au lancement de l'application s'écraser contre le block "A".


Cette fois-ci le block "C" possède une contrainte de hauteur.

### String.xml
Une ressource "**String**" est une variable de texte pour votre application avec un style de texte et un formatage optionnels. Il existe **trois types** de ressources qui peuvent fournir des chaînes à votre application :

* **String** (Ressource XML qui porte un String)
* **String Array** (Ressource XML qui porte un tableau de Sting)
* **Quantity Strings** (Ressource XML qui porte différentes String pour la pluralisation)

**String.xml** correspond au fichier contenant toutes les ressources de type String.

<resources>
    <string name="app_name">SpaceDIM</string>
</resources>

**Utilisation des ressources :**
Ces ressources peuvent s'utiliser dans une Vue.xml de la façon suivante :

<TextView
          android:id="@+id/Id"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:text="@string/app_name"/>

### Intent
Permet de lancer l’activité

startActivity(Intent(this, OtherActivity::class.java))

### Activity
Un Activity est une chose unique et ciblée que l'utilisateur peut faire. Chaque application doit avoir au moins une activité comme point d'entrée. Considérez cette activité de point d'entrée comme la main()fonction d'autres programmes. Une activité est généralement associée à une mise en page qui définit la façon dont les éléments de l'interface utilisateur (UI) apparaissent sur un écran.

### Fragment

Un fragment sous Android est un composant d'interface qui s'intègre dans une Activity.
Un fragment possède son propre cycle de vie qui est dépendant du cycle de vie de l'activity qui l'héberge.

Il est en quelque sorte une "sous activité" qui peut contenir de la logique et est relié également à un XML d'interface.


### ViewModel

Le ViewModel est une représentation abstraite de la vue. Le VM ne gère qu'une vue, et il ne connait rien aux éléments de la vue. C'est la vue qui reçoit des événements du VM pour se garder à jour.

Le viewModel ne connait pas la vue, mais la vue s'abonne aux données du viewModel.

Il permet d'exposer les sources de données de manière réactive, ainsi une vue peut s'abonner à une ou plusieurs sources de données afin de mettre à jour l'interface.

La classe ViewModel est conçue pour stocker et gérer les données liées à l'interface utilisateur en tenant compte du cycle de vie. La classe ViewModel permet aux données de survivre aux changements de configuration tels que les rotations d'écran.

### ViewModel provider

C’est une classe qui fournit des ViewModels. ViewModelProvider renvoie un ViewModel existant s'il existe, ou en crée un nouveau s'il n'existe pas encore. Il crée une instance de ViewModel en association avec l'étendue donnée (une activité ou un fragment). Le ViewModel créé est conservé tant que l'étendue est vivante. Par exemple, si l'étendue est un fragment, le ViewModel est conservé jusqu'à ce que le fragment soit détaché.

### NavHost

Conteneur qui délègue la navigation du graphe à son NavController. Par défaut, ce fragment hérite de la classe NavHostFragment et servira de conteneur où les fragments seront placés.

### NavGraph

Fichier ressource XML de type Navigation qui contient les éléments du graphe de navigation de l’application.

### NavController

Objet qui gère et orchestre la navigation. Chaque NavHost détient un NavController, dont le rôle est de gérer la navigation dans le le NavHost.

### Recycler view
Un RecyclerView est une version avancée de ListView avec des performances améliorées. Lorsque vous avez une longue liste d'éléments à afficher, vous pouvez utiliser RecyclerView. Il a la capacité de réutiliser ses vues. Dans RecyclerView, lorsque la vue sort de l'écran ou n'est pas visible pour l'utilisateur, elle ne la détruira pas, elle réutilisera ces vues. Cette fonctionnalité permet de réduire la consommation d'énergie et d'offrir une plus grande réactivité à l'application.

### Coroutine

Une coroutine est un modèle de conception concurentiel que vous pouvez utiliser sur Android pour simplifier le code qui s'exécute de manière asynchrone.

Une coroutine est une instance de calcul suspendable. Elle est conceptuellement similaire à un thread, dans le sens où elle prend un bloc de code à exécuter qui fonctionne en même temps que le reste du code. Cependant, une coroutine n'est pas liée à un thread particulier. Elle peut suspendre son exécution dans un thread et la reprendre dans un autre.

### Thread

Un thread ou fil ou tâche est similaire à un processus car tous deux représentent l'exécution d'un ensemble d'instructions du langage machine d'un processeur. Du point de vue de l'utilisateur, ces exécutions semblent se dérouler en parallèle.

### Multi-Thread

Un processeur est dit multithread s'il est capable d'exécuter efficacement plusieurs threads simultanément.

### Jetpack

Ensemble d’outils et de bibliothèques qui aide les développeurs à suivre les meilleures pratiques, à réduire le code passe-partout (Jetpack gère les activités fastidieuses comme les tâches d'arrière-plan, la navigation et la gestion du cycle de vie) et à écrire un code qui fonctionne de manière cohérente, sur toutes les versions et tous les appareils Android, afin que les développeurs puissent se concentrer sur le code qui leur importe.

### AndroidX

Androidx comprend les bibliothèques Android Jetpack. Les packages Androidx remplacent entièrement la bibliothèque de support Android d'origine, en fournissant de nouvelles bibliothèques.

### AVD (Android Virtual Device)

**AVD** (Android Virtual Device) ou périphérique virtuel Android en français, simule les configurations d’un appareil pour être utilisé dans un émulateur Android.

### Room

C’est l’ORM d’Android. Il fournit une couche d'abstraction sur SQLite pour permettre un accès plus robuste à la base de données tout en exploitant toute la puissance de SQLite.

### Repository

### API REST

Avant tout, il faut savoir ce qu'est une **API**.

Voici un exemple d'API :

Il s'agit d'une page **Web** créé et disposant de toutes les **données** offerte par cette dernière. Ainsi vous pouvez **utiliser ces données** pour les afficher dans votre code.

Une **API REST** (également appelée API RESTful) est une interface de programmation d'application (API ou API web) qui respecte les contraintes du style d'architecture **REST** et permet d'interagir avec les services web **RESTful**. L'architecture REST (Representational State Transfer).

### Interface (POO)

une interface est un ensemble de signatures de méthodes publiques d'un objet. Il s'agit donc d'un ensemble de méthodes accessibles depuis l'extérieur d'une classe, par lesquelles on peut modifier un objet, ou plus généralement communiquer avec lui.

### Paradigme

Un paradigme de programmation est une façon d'approcher la programmation informatique et de traiter les solutions aux problèmes et leur formulation dans un langage de programmation approprié. Il s'oppose à la méthodologie, qui est une manière d'organiser la solution des problèmes spécifiques du génie logiciel.

### Permission explicite

Lorsqu'on demande à l'utilisateur de confirmer via une popup in-app s'il autorise une certaine permission.

### Vue

View is a basic building block of UI (User Interface) in android. A view is a small rectangular box that responds to user inputs. Eg: EditText, Button, CheckBox, etc. ViewGroup is an invisible container of other views (child views) and other ViewGroup.

### Binding

Binding refers to the process of converting identifiers (such as variable and performance names) into addresses. Binding is done for each variable and functions. For functions, it means that matching the call with the right function definition by the compiler. It takes place either at compile time or at runtime.

### DataBinding

En programmation informatique, la liaison de données est une technique générale qui lie les sources de données du fournisseur et du consommateur et les synchronise. Cela se fait généralement avec deux sources de données/d'informations ayant des langages différents, comme dans la liaison de données XML et la liaison de données UI. Dans la liaison des données de l'interface utilisateur, les données et les objets d'information du même langage mais avec une fonction logique différente sont liés ensemble.

### Serialisation

La sérialisation est le processus de conversion d’un objet en un flux d’octets pour stocker l’objet ou le transmettre à la mémoire, une base de données ou un fichier. Son objectif principal est de sauvegarder l’état d’un objet afin de pouvoir le recréer en cas de besoin.
On peut donc convertir un objet vers un format de données (Ex : JSON, XML, CSV.

### Deserialisation

Processus inverse de la sérialisation.
On peut convertir un format de données (Ex : JSON, XML, CSV) vers un objet.

### Content Negociator

Outil permettant d’appliquer la sérialisation et la désérialisation. (Ex : Moshi)

### View Binding

Dans le framework Android c'est le fait de lier la définition de l'interface de l'application au code. Cela permet au code de modifier l'interface dynamiquement et à l'interface d'envoyer des informations de saisies au code par exemple.

### Séparation des responsabilités

La séparation des responsabilités (ou des préoccupations) est un principe de conception permettant de séparer un programme informatique en sections distinctes. Cela signifie que chaque section aborde une préoccupation distincte. Une préoccupation est un ensemble d'informations, qui affecte le code d'un programme informatique.

### Composants
**build.gradle(Module:app)**
Contient les dépendances et les versions

Fichiers :
* **layout**: fichier contenant tous les fichiers layout qui définissent les différentes vues de l’application
* **values**: il contient différent fichiers, comme les couleurs de l’application, les traductions, les styles
* **drawable**:contient les images de l’application
* **strings**: contiens les chaines de caractères utilisé dans l’application
* **colors**: contient les couleurs que l’application va utiliser
* **styles**: contient les styles de l’application
* **java**: contient tous les fichiers de code sources de l’application, y compris les tests JUnit
* **generatedJava**: Contient les fichiers Java généré par Android Studio
* **AndroidManifest.xml**: Décrit les caractéristiques fondamentales de l’app et définit chacun de ses composants : nommer le paquetage Java, déclarer les composants, déclarer ce que contiendra l’app (activités, services, permissions…) et déclarer le niveau minimum de compatibilité du SDK

### Objet
Un objet est une entité avec une identité et un état.

### Orienté Objet
L’Orienté objet c’est de programmer en utilisant des objets et ses méthodes d’appels, et en utilisant
l’encapsulation.

### Fonctionnel
Le Fonctionnel quant à lui est basé sur les fonctions où la logique et l’état sont maintenu
séparément.
* Le fonctionnel peut effectuer des opérations sur des données fixes contrairement à l’orienté objet où les opérations ont un comportement commun et des variantes différentes.
* La programmation fonctionnelle consiste à avoir un modèle de programmation sans état car il n’existe pas. La programmation orientée objet consiste à avoir un modèle de programmation avec état.

On qualifie ces concepts en tant que paradigme de programmation

### POJO
POJO (Plain Old Java Object) est un mouvement pour simplifier le plus possible la conception
d’applications en Java. En soit un objet pur sans aucun héritage

### JVM
La Java Virtual Machine est une belle invention qui date de 1995, et qui permet de faire un développement multi-plateforme. C'est un langage qui est compilé et interprété.

### SOLID
Principes de base pour la programmation orientée objet, permettant le développement de logiciels plus fiables, plus robustes, plus maintenables, plus extensibles et plus testables.
* **Single Responsability Principle** *ou « principe de responsabilité unique »* : une classe doit avoir une et une seule responsabilité.
* **Open Close Principle** *ou « principe Ouvert / Fermé »* : une classe doit être ouverte à l'extension et fermée aux modifications
* **Liskov Substitution Principle** *ou « principe de substitution de Liskov »* : une instance de type T doit pouvoir être remplacée par une instance de type G, tel que G sous-type de T, sans que cela modifie la cohérence du programme.
* **Interface Segregation Principle** *ou « principe de ségrégation d’interface »* : recommande de découper de grosses interfaces en plus petites interfaces spécialisées.
* **Dependency Inversion Principle** *ou « principe d’inversion des dépendances »* : stipule que les objets doivent dépendre d'abstractions plutôt que d'implémentations.

### Langage interprété

Un langage interprété est un langage qui est lu ligne par ligne par un interpréteur. L'interpréteur va passer à travers chaque ligne de votre code Python pour le traduire en langage machine (votre ordinateur ne sait pas exécuter du code Python directement, il a besoin de langage machine).

### Langage compilé

Un langage compilé est un langage de programmation dont les implémentations sont généralement des compilateurs et non des interprètes. Le terme est quelque peu vague. En principe, tout langage peut être implémenté avec un compilateur ou avec un interprète.

### Pattern Adapter
Permet à l'interface d'une classe existante d'être utilisée comme une autre interface. Il est souvent utilisé pour faire fonctionner des classes existantes avec d'autres sans modifier leur code source.
-->Passerelle permettant de faire communiquer 2 modules qui "ne parlent pas la même langue"

### Interface

Une interface est un ensemble de signatures de méthodes publiques d'un objet. Il s'agit donc d'un ensemble de méthodes accessibles depuis l'extérieur d'une classe, par lesquelles on peut modifier un objet, ou plus généralement communiquer avec lui.

### Encapsulation

L'encapsulation est un moyen de restreindre l'accès direct à certains champs d'un objet. Lorsque vous encapsulez un objet, vous exposez un ensemble de méthodes publiques qui modifient les champs internes privés. En utilisant l'encapsulation, vous contrôlez la manière dont les autres classes manipulent ces champs internes.

#### MVVM + LiveData + Room + Retrofit

### DESIGN PATTERN
MVVM
MVP
MVC
### Entité o objet peuvent etre instancier
Class
### Deux class parents ou plus
Heritage multiple
### Methodes appelé automatiquement lors instanciation class
constructeur

### Methodes publique pour acceder a champs privé
accesseurs : getter setter
### instance class
objet
### interface
uniquement signature methode
### paradigm prog
heritage,encapsulation, polymorphisme
### possibilité enfant class avoir implent spé
surcharge

**MHF**