La compilation est la phase de traduction d'un programme d'un langage de haut niveau (VB, C...) vers un langage de bas niveau (langage machine). Il s'agit d'une étape indispensable avant de pouvoir exécuter son programme.
|
Langage compilé / interprété |
Un langage interprété (javascript par exemple) est un langage ne nécessitant aucune compilation, c'est-à-dire que le programme n'est pas traduit dans un autre langage plus proche de la machine pour pouvoir être exécuté. A contrario, un langage compilé (C, Delphi...) nécessite l'intervention d'un compilateur, c'est-à-dire d'un programme traduisant le code en langage machine.
|
Langage de haut/bas niveau |
Un langage de haut niveau est un langage proche de nous au niveau de sa syntaxe. Par exemple :
Si (nom="Pierre) Alors Ecrire("Bonjour"). Au contraire un langage bas niveau est un langage proche de la machine comme l'assembleur (mov $4, %eax).
|
Langage côté serveur / client |
Il s'agit ici de distinguer le lieu d'exécution d'un programme. Un langage côté serveur (php, asp...) voit ses programmes s'exécuter sur une machine distante. Par exemple, le php est interprété par un serveur et renvoie du code html à l'utilisateur. Un langage client (javascript) est interprété directement sur le poste de l'utilisateur.
|
Langage sensible à la casse |
Un langage sensible à la casse est un langage qui fait la distinction entre les caractères en majuscules et ceux en minuscules. Ainsi, un langage sensible à la casse considérera les noms suivants comme différents : "var, Var, VAR" alors qu'un langage non sensible à la casse ne fera aucune distinction. En programmant, il faut donc s'assurer de respecter des règles d'écriture pour le nommage des noms de variables, de fonctions, classes...
Pour assurer une certain cohérence d'écriture au sein d'un programme, des règles de nommage ont été mises en place. Ces règles jouent sur la casse du nom pour établir une distinction entre une variable, une classe, une méthode...
- variable : nomVariable
- constante : CONSTANTE
- méthode : nomFonction()
- classe : NomClasse
Une variable est un espace en mémoire dans lequel on stocke des données (un nombre, du texte, un tableau...). Le contenu d'une variable évolue au cours d'un programme ("il varie"). On précise le type de la variable (entier, booléan, chaîne de caractère...) pour savoir indiquer comment doit être interprété les informations disponibles en mémoire. Les variables sont une notion essentielle en programmation.
|
Variable globale et locale |
Il s'agit ici de définir ce qu'on appelle la portée d'une variable. En effet, suivant l'emplacement du code où est déclarée une variable, celle-ci n'est pas accessible de partout.
- Variable globale : elle est accessible en tout point du programme. Elle est généralement définie en tout début de programme pour être disponible à tout point du code. L'utilisation des variables globales est proscrite pour des raisons de lisibilité et de maintenance du code.
- Variable locale : elle possède une portée limitée au bloc englobant sa déclaration. Par exemple, une procédure, une classe, une condition... Lorsque le bloc d'instructions a été exécuté, la variable est libérée (=détruite). La durée de vie d'une variable locale correspond donc exactement à celui de son bloc englobant.
Lorsque l'on transmet des paramètres à une procédure, ces derniers peuvent être transmis par adresse (=référence) ou par valeur. Quelle est la différence ?
- Par valeur : la variable est dupliquée lors qu'elle est transmise à la fonction. Autrement dit, la procédure travaille sur une copie de la variable (=une variable locale pour la procédure). Les modifications ne seront donc pas transmises à la variable initialement passée en paramètre.
- Par adresse : contrairement au passage par valeur, ce n'est pas une copie de la variable qui est transmise mais un pointeur (=par référence) vers cette variable. Ceci signifie que la procédure travaille directement sur la variable. Toute modification de la variable dans la procédure revient donc à modifier la variable initiale.
Les types natifs (entier, réel...) sont généralement passés par valeur car une copie en mémoire est peu gourmande. Les objets (instances de classes) sont en fait des pointeurs. Ils sont donc directement transmis par adresse car une copie (clonage) en mémoire serait trop fastidieuse.
Quand on déclare une variable, celle-ci est stockée dans la mémoire vive de l'ordinateur à un certain emplacement identifié par une adresse. Un pointeur contient une adresse mémoire, autrement dit "il pointe" vers des données en mémoire. Travailler avec les pointeurs revient donc à travailler directement sur les variables en mémoire. On utilise généralement les pointeurs quand on transmet des variables à des procédures pour réaliser un passage par adresse (=par référence).
Un transtypage est la conversion d'une variable d'un type vers un autre. Par exemple, convertir une chaine de caractères en nombre pour effectuer un calcul. Programmer en transtypant systématiquement les variables est un gage de sécurité pour s'assurer qu'on travaille bien sur le type de données voulu.
|
Méthode / Procédure / Fonction |
Une procédure est un ensemble d'instructions auquel on peut fournir des paramètres. Une fonction est une procédure qui renvoie une valeur. Par exemple, une procédure pourrait lancer l'impression d'un document alors qu'une fonction pourrait retourner le résultat d'une opération mathématique.
Une méthode désigne aussi bien une procédure qu'une fonction mais ce terme est généralement utilisé dans un contexte de programmation objet.
|
Programmation orientée objet |
La programmation objet est une méthodologie structurée pour programmer. Plutôt que de s'orienter vers le codage des fonctionnalités (qui évoluent rapidement), la programmation orientée objet s'appuie sur les types de données (généralement fixes). Elle prône la définition de structures composés d'attributs (données) et de méthodes (fonctionnalités) : les classes. Des objets seront des réalisations concrètes de ces classes que l'on manipulera. De nombreuses notions régissement la programmation orientée objet : encapsulation, héritage, polymorphisme.
Les attributs d'une classe ne doivent être accessibles que par l'intermédiaire de méthodes (généralement les accesseurs get/set). Les données sont ainsi masquées pour l'utilisateur, elles sont privées en terme objet. Ceci permet de faire évoluer une classe en ajoutant des données sans que l'utilisateur n'ait pas à modifier son code puisqu'il accède indirectement aux attributs via des accesseurs.
Une classe peut héritée d'une autre classe. Dans ce cas, la classe fille (qui hérite) possède les mêmes méthodes et attributs que la classe mère. Ceci permet de mettre en oeuvre différents niveaux de spécialisation en ajoutant uniquement des fonctionnalités et des données plus spécifiques dans les classes filles.
Il s'agit de la possibilité de faire hériter une classe de plusieurs classes différentes. L'héritage multiple est à utiliser avec précaution (C++) puisqu'il pose des problèmes de conflits entre des noms de méthodes et de variables identiques dans différentes classes. La notion d'interface est une alternative propre pour réaliser un héritage plus complexe.
Il s'agit de la possibilité de définir des méthodes de même nom mais dont le nombre d'arguments ou le type est différent. Il est ainsi possible de définir différentes variantes d'une même méthode. C'est le compilateur qui a la charge de déterminer la méthode à utiliser en comparant le nombre d'arguments, les types et l'ordre des paramètres. Le polymorphisme est très souvent utilisé pour la définition des constructeurs de classe.
L'implémentation consiste à écrire le code d'une méthode vide.
Rédéfinir une méthode consiste à implémenter une méthode de même nom dans une classe fille alors qu'elle existe déjà dans la classe mère. Ceci permet de créer des méthodes plus spécifiques dans une classe pour affiner une fonctionnalité. Par exemple, si la classe mère "Ecran" contient la méthode "afficherImage()", la classe fille "EcranCouleur" qui hérite de "Ecran" peut rédéfinir la méthode "afficherImage()" car elle possède des fonctionnalités supplémentaires.
La surcharge consiste à implémenter une méthode déjà existante mais avec un nombre ou types d'arguments différents. On peut ainsi créer différentes variantes d'une même méthode. Le compilateur aura la charge de déterminer automatiquement la méthode à utiliser (suivant les critères du nombre de paramètres, des types, de l'ordre des arguments...). Par exemple, dans la classe "LecteurDVD", on peut définir différentes versions de la méthode "lancerFilm()" : lancerFilm(titreDuFilm), lancerFilm(realisateurFilm, anneeFilm), lancerFilm(typeFilm, anneeFilm, acteursFilm).
Une classe peut être assimilée à une structure composée de données (attributs) et de fonctionnalités (méthodes). Une classe est une représentation abstraite d'une notion. Un objet en sera la représentation concrète grâce au mécanisme d'instanciation. Par exemple, la classe "Personne" possède des attributs (nom, prénom, âge...) et des fonctionnalités (contacter, voirNom...). L'objet "Pierre" sera un exemple concret, instance de la classe "Personne".
Un objet est la réprésentation concrète d'un classe. On dit qu'un objet est une instance de classe puisqu'il en est une des réalisations possibles. Par exemple, l'objet "Ferrari" serait une instance de la classe "Voiture".
Une classe abstraite est une classe comportant au moins une méthode abstraite, c'est-à-dire une méthode sans code (seulement sa définition). Il est impossible d'instancier une classe abstraite tout comme définir des attributs (autres que statiques) dans cette classe. Les classes filles qui héritent d'une classe abstraite doivent absolument implémenter les méthodes abstraites ou se déclarer elle-même comme abstraite. Les méthodes abstraites permettent de s'assurer que les classes filles posséderont un ensemble de fonctionnalités (=méthodes abstraites).
Une interface est une classe ne comportant que des méthodes abstraites. Autrement dit, il s'agit d'une classe sans attributs (autres que statiques) et composés uniquement de méthodes sans code (seulement la définition). Une interface peut hériter d'une autre interface. Chaque classe implémentant cette interface doit implémenter chacune des méthodes. Les interfaces permettent de fournir des fonctionnalités communes à différentes classes. Ces classes sont ainsi réunies sous un même type.
|
Méthode / Variable statique |
Un élément est statique lorsqu'il peut être utilisé sans passer par une instance de classe (=objet). Autrement dit, on accède à une méthode ou une variable en utilisant directement le nom de classe. Un élément statique ne dépend pas d'un objet, il est seulement lié à la classe. On peut utiliser une variable statique pour comptabiliser le nombre d'objets instanciés, fournir des constantes de classe...
|
Droits d'accès / Visibilité |
Les droits d'accès permettent de définir la portée d'une variable, d'une méthode, d'une classe. On considère généralement 4 marqueurs :
- Publique : l'élément est accessible directement en n'importe quel point du code.
- Privé : la classe est accessible dans son package, la variable/méthode disponible uniquement dans la classe où elle définit.
- Protegé : la variable/méthode est accessible dans son package et les classes dérivées.
- Package : la variable/méthode est disponible dans les classes dérivées.
Prenons l'exemple d'une classe mère M et d'une classe fille F qui hérite de M.
- Upcasting : soit o, un objet de type M instance de F. A l'écriture du code, o est considéré de type M. Il ne possède donc que les fonctionnalités de la classe mère. C'est à l'exécution que o sera considéré de type F (=liaison dynamique en java). On gère ainsi globalement les objets en les considérant du type de la classe mère à l'écriture du code.
- Downcasting : à partir de l'exemple ci-dessus, si on veut utiliser les fonctionnalités de la classe fille, il faut faire un cast sur o dans le type F.
Une exception est un événement déclenché par le programme lorsqu'il rencontre une erreur d'exécution connue (division par zéro, index hors du tableau...). On peut traiter cet événement pour le corriger ou bien le laisser se propager entre les méthodes (pour différer son traitement). Si l'exception atteint la méthode principale du programme ("main") sans être traitée, c'est le plantage !
Un accesseur est une méthode qui sert traditionnellement à "accéder" aux données privées d'une classe selon le principe de l'encapsulation. On nomme généralement
getAttribut la méthode servant à retourner la valeur d'un champ et
setAttribut celle affectant une valeur. L'utilisateur accède ainsi aux données via les accesseurs ce qui permet de faire évoluer son code sans modifier la manière d'accéder aux données.
Un constructeur est un méthode particulière qui sert à créer un objet instance d'une classe. Il s'agit du processus par lequel on génère un objet concret à partir d'une structure abstraite. Un constructeur est généralement appelé
new dans les langages.
Contrairement au constructeur qui crée un objet instance de classe, le destructeur est une méthode libérant l'objet de la mémoire.
