Thanks to Guy Tremblay.
Signed-off-by: Alexandre Terrasa <alexandre@moz-concept.com>
Signed-off-by: Jean Privat <jean@pryen.org>
\part{Modules de la bibliothèque standard Nit}
\chapter{Kernel}
-Le module |kernel| est à la base de toute la hiérarchie objet de Nit, c'est donc un module de base. Par exemple, il contient les classes fondamentales tel que |Bool|, |Char|, |Float|, |Int|, |Object|...
+Le module |kernel| est à la base de toute la hiérarchie objet de Nit, c'est donc un module de base. Par exemple, il contient les classes fondamentales telles que |Bool|, |Char|, |Float|, |Int|, |Object|...
Faisons un tour rapide des classes principales du module |kernel| :
\begin{description}
\item[Object]C'est la super classe implicite de toutes les classes en Nit : toutes ces méthodes sont donc héritées par toutes les classes.
\item[Bool]Représente les booléens. Les seules instances possibles de cette classe sont |true| et |false|. Les booléens sont souvent utilisés dans les branchements conditionnels et les boucles.
\item[Char]Représente les caractères.
- \item[Comparable]C'est l'ancêtre de toutes les classes qui peuvent être comparés selon un ordre total.
+ \item[Comparable]C'est l'ancêtre de toutes les classes dont les instances peuvent être comparées selon un ordre total.
\item[Discrete]L'ancêtre de toutes les classes représentant des ensembles dénombrables comme les entiers ou l'alphabet.
\item[Float]Représente les nombres à virgule flottante.
\item[Int]Représente les nombres entiers.
\end{description}
-Les classes du module |kernel| sont fréquemment raffinées dans les autres modules de la librairie standard.
+Les classes du module |kernel| sont fréquemment raffinées dans les autres modules de la bibliothèque standard.
\chapter{String}
Ce module introduit les classes permettant de manipuler les chaînes de caractères.
Le module string raffine les classes |Array|, |Collection|, |Float|, |Int|, |Map| et |Object| pour y rajouter la méthode |to_s|.
\chapter{Maths}
-Le module math raffine les classes Object, Int et Float pour y rajouter une série de méthodes en rapport avec les mathématiques. Elle est automatiquement importée avec la libraire standard.
+Le module math raffine les classes Object, Int et Float pour y rajouter une série de méthodes en rapport avec les mathématiques. Elle est automatiquement importée avec la bibliothèque standard.
\section{Variables mathématiques}
Le module math raffine la classes Object pour lui rajouter la méthode |pi| (3.141592) :
\lstinputlisting[language=Nit]{./modules/listings/pi1_c.nit}
\section{Fonctions trigonométriques}
-Les méthodes sin(), cos(), tan(), asin(), acos(), atan() permettent d'effectuer les opérations trigonométriques.Les angles doivent être exprimés en radians. Pour convertir des degrés en radian, il suffit de les multiplier par pi/180.
+Les méthodes sin(), cos(), tan(), asin(), acos(), atan() permettent d'effectuer les opérations trigonométriques. Les angles doivent être exprimés en radians. Pour convertir des degrés en radian, il suffit de les multiplier par pi/180.
Exemple :
\lstinputlisting[language=Nit]{./modules/listings/cos1_c.nit}
\section{Interfaces des collections}
\subsection{Interface Collection}
-Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon assez générale. Elle est la super interface de plusieurs interfaces de la libraire standard. Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de l'interface Collection.
+Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon assez générale. Elle est la super interface de plusieurs interfaces de la bibliothèque standard. Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de l'interface Collection.
Cette interface définit plusieurs méthodes :
\end{tabularx}
\section{Séquences}
-Les séquences sont des collections indexées et ordonnées. La notion d'index est importante, elle précise que chaque valeur est associé à une sorte d'étiquette numérique permettant de la retrouver. L'ordre de la séquence est donc induit par l'ordre des étiquettes.
+Les séquences sont des collections indexées et ordonnées. La notion d'index est importante, elle précise que chaque valeur est associée à une sorte d'étiquette numérique permettant de la retrouver. L'ordre de la séquence est donc induit par l'ordre des étiquettes.
L'interface Sequence introduit les méthodes suivantes :
\hline
first:E & Retourne le premier élément de la séquence. \\
\hline
- first=(E) & Définie le premier élément de la séquence. \\
+ first=(E) & Définit le premier élément de la séquence. \\
\hline
last:E & Retourne le dernier élément de la séquence. \\
\hline
- last=(E) & Définie le dernier élément de la séquence. \\
+ last=(E) & Définit le dernier élément de la séquence. \\
\hline
pop:E & Retourne et retire le dernier élément de la séquence. \\
\hline
\lstinputlisting[language=Nit]{./modules/listings/list1_c.nit}
\subsection{Tableaux}
-Les tableaux représentent des collections d'objets dont la taille est dynamique. Les tableaux sont gérées grâce à la classe Array.
+Les tableaux représentent des collections d'objets dont la taille est dynamique. Les tableaux sont gérés grâce à la classe Array.
-Chaque objet de type Array gère une capacité qui est le nombre total d'élément qu'il est possible d'insérer avant d'agrandir le tableau. Cette capacité a donc une relation avec le nombre d'éléments contenus dans la collection. Lors d'un ajout dans la collection, cette capacité et le nombre d'éléments de la collection déterminent si le tableau doit être agrandi. Si un nombre important d'élément doit être ajouté, il est possible de forcer l'agrandissement de cette capacité avec la méthode |enlarge|. Son usage évite une perte de temps liée au recalcul de la taille de la collection.
+Chaque objet de type Array gère une capacité qui est le nombre total d'éléments qu'il est possible d'insérer avant d'agrandir le tableau. Cette capacité a donc une relation avec le nombre d'éléments contenus dans la collection. Lors d'un ajout dans la collection, cette capacité et le nombre d'éléments de la collection déterminent si le tableau doit être agrandi. Si un nombre important d'éléments doit être ajouté, il est possible de forcer l'agrandissement de cette capacité avec la méthode |enlarge|. Son usage évite une perte de temps liée au recalcul de la taille de la collection.
Exemple :
\lstinputlisting[language=Nit]{./modules/listings/array1_c.nit}
\lstinputlisting[language=Nit]{./modules/listings/array2_c.nit}
\section{Ensembles}
-Un ensemble (Set) est une collection qui n'autorise pas l'insertion de doublons.
+Un ensemble (Set) est une collection qui n'autorise pas la présence de doublons.
-L'interface Set définit les méthodes d'une collection qui n'accepte pas de doublons dans ces éléments. Elle hérite de l'interface Collection mais elle ne définie pas de nouvelle méthode. Pour déterminer si un élément est déjà inséré dans la collection, la comparaison est basée sur les valeurs des éléments.
+L'interface Set définit les méthodes d'une collection qui n'accepte pas de doublons dans ces éléments. Elle hérite de l'interface Collection mais elle ne définit pas de nouvelle méthode. Pour déterminer si un élément est déjà présent dans la collection, la comparaison est basée sur les valeurs des éléments.
L'interface Set possède deux implémentations concrètes :
\documentclass[letterpaper,11pt]{doc_nit}
-\usepackage{../nit_version}
% Titre du document et auteur
\title{Développez en Nit}
\author{Université du Québec à Montréal}
-\date{\today\\\nitversion}
+\date{v0.5}
% Début du document
\begin{document}
\input{./licence.tex}
% Fin du document
-\end{document}
+\end{document}
\ No newline at end of file
end
class ClasseComplete
-special ClasseAbstraite
+ super ClasseAbstraite
end
var o = new ClasseComplete
end
class MonAutreClasse
-special MaClasse
+ super MaClasse
redef fun methode(i: Int): Int
do
return i
rayon = r
end
- redef fun aire: Float
+ redef fun aire: Float
do
return pi * rayon * rayon
end
end
+
+var forme: Forme
+
+forme = new Carre(10.0)
+print forme.aire # Affiche "100"
+
+forme = new Cercle(10.0)
+print forme.aire # Affiche "314.15"
\chapter{Concept de classe}\r
L'idée de base de la programmation orientée objet est de rassembler dans une même entité les données et les traitements qui s'y appliquent. Dans cette partie, nous allons voir comment Nit permet de développer en objet.\r
\r
-Une classe est le support de l'encapsulation : c'est un ensemble de données et de fonction regroupées dans une même entité. Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les données sont appelées des méthodes. Les données en elles-mêmes sont appelées des attributs. Les attributs et les méthodes représentent les propriétés de la classe. Instancier une classe consiste à créer un objet sur son modèle.\r
+Une classe est le support de l'encapsulation : c'est un ensemble de données et de fonction regroupées dans une même entité. Une classe est une description abstraite d'un ensemble d'objet ayant des propriétés communes. Les fonctions qui opèrent sur les données sont appelées des méthodes. Les données en elles-mêmes sont appelées des attributs. Les attributs et les méthodes représentent les propriétés de la classe.\r
\r
Rappelons qu'en Nit absolument TOUT est objet.\r
\r
Pour accéder à une classe il faut en déclarer une instance ou objet.\r
\r
-Une classe se compose en deux parties : un en-tête et un corps. Le corps peut être divisé en deux sections : la déclaration de ses propriétés (attributs et la définition des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui gère leur accessibilité par les composants hors de la classe.\r
+Une classe se compose de deux parties : un en-tête et un corps. Le corps peut être divisé en deux sections : la déclaration de ses propriétés (attributs) et la définition des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui gèrent leur accessibilité par les composants hors de la classe.\r
\r
Une classe comporte donc sa déclaration, des attributs et la définition de ses méthodes.\r
\r
-En Nit, toutes les classes héritent forcément de la classe |Object|. Cette relation d'héritage est implicite, c'est à dire qu'il n'y a pas besoin de la déclarer.\r
+En Nit, toutes les classes héritent forcément de la classe |Object|. Cette relation d'héritage est implicite, c'est à dire qu'il n'est pas nécessaire de la déclarer.\r
\r
\section{Syntaxe et déclaration d'une classe}\r
La syntaxe de déclaration d'un classe est la suivante :\r
L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre d'abord la méthode A puis la méthode B, B peut être appelée sans problème dans A.\r
\r
\chapter{Objets}\r
-La classe est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même, seules les données (valeurs des attributs) sont différentes à chaque objet.\r
+La classe est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même, seules les données (valeurs des attributs) sont différentes pour chaque objet.\r
\r
\section{Instancier une classe : créer un objet}\r
L'opérateur |new| se charge de créer une nouvelle instance d'une classe et de l'associer à une variable.\r
Cela n'est pas obligatoire grâce au typage adaptatif (voir chapitre~\ref{typage-adaptatif} \nameref{typage-adaptatif}) mais on peut aussi préciser le type sur la variable qui va recevoir l'instance :\r
\lstinputlisting[language=Nit]{./poo/listings/new2_s.nit}\r
\r
-En Nit, toutes les classes sont instanciées par allocation dynamique à part les types universels (voir chapitre~\ref{universal} \nameref{universal}). Dans l'exemple précédent, la variable |instance| contient une référence sur la classe instanciée (contient l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur cette adresse comme en C).\r
+En Nit, toutes les classes sont instanciées par allocation dynamique à part les types universels (voir chapitre~\ref{universal} \nameref{universal}). Dans l'exemple précédent, la variable |instance| contient une référence sur un objet de la classe instanciée (contient l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur cette adresse comme en C).\r
\r
\lstinputlisting[language=Nit]{./poo/listings/new3_s.nit}\r
\r
\end{description}\r
\r
\section{Références et comparaison d'objets}\r
-Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet. Lorsque l'on écrit |instance1 = instance2|, on copie la référence |instance1| dans |instance2| : |instance1| et |instance2| pointent sur le même objet. Par défaut, l'opérateur |==| permet de comparer ces références. Deux objets avec des propriétés identiques sont deux objets distincts.\r
+Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet. Lorsque l'on écrit |instance1 = instance2|, on copie la référence |instance1| dans |instance2| : |instance1| et |instance2| pointent sur le même objet. Par défaut, l'opérateur |==| est celui de la classe |Object| et permet de comparer ces références. Deux objets avec des propriétés identiques sont deux objets distincts.\r
\r
\lstinputlisting[language=Nit]{./poo/listings/comparaison1_s.nit}\r
Si on souhaite comparer deux objets en se basant sur la valeur de leurs attributs, il est possible de redéfinir l'opérateur |==| dans leur classe (voir section~\ref{redef-operateur} \nameref{redef-operateur}).\r
\r
-Par exemple, l'opérateur |==| a été redéfinit pour la classe String il est donc possible de comparer deux String en se basant sur leurs valeurs :\r
+Par exemple, l'opérateur |==| a été redéfini pour la classe String il est donc possible de comparer deux String en se basant sur leurs valeurs :\r
\lstinputlisting[language=Nit, linerange=1-5]{./poo/listings/comparaison2_c.nit}\r
\r
-Il est possible de comparer le type de deux objets, c'est à dire de vérifier si deux objets sont de la même classe ou non. Pour cela nous allons utiliser la méthode |is_same_type(o:Object)|. Cette méthode est introduite dans la classe |Object|, comme toutes les classes en héritent implicitement, elle est disponible dans toutes les classes.\r
+Il est possible de comparer le type de deux objets, c'est à dire de vérifier si deux objets sont de la même classe ou non. Pour cela il faut utiliser la méthode |is_same_type(o:Object)|. Cette méthode est introduite dans la classe |Object|, comme toutes les classes en héritent implicitement, elle est disponible dans toutes les classes.\r
\r
\lstinputlisting[language=Nit, linerange=8-9, firstnumber=last]{./poo/listings/comparaison2_c.nit}\r
\r
Pour vérifier que deux variables sont en fait des références vers le même objet, il est possible d'utiliser le mot-clé |is| :\r
-\lstinputlisting[language=Nit, linerange=6, firstnumber=last]{./poo/listings/comparaison2_c.nit}\r
+\lstinputlisting[language=Nit, linerange=6-6, firstnumber=last]{./poo/listings/comparaison2_c.nit}\r
\r
-\section{Objet null}\r
-En Nit, il existe une particularité pour l'objet |null|. Contrairement à Java il ne peut pas être utilisé à la place de n'importe où. En effet, Nit propose un mécanisme permettant de limiter statiquement les erreurs fréquentes de type |nullPointerException|.\r
+\section{Types nullable}\r
+En Nit, il existe une particularité pour la valeur |null|. Contrairement à Java il ne peut pas être utilisé n'importe où. En effet, Nit propose un mécanisme permettant de limiter statiquement les erreurs fréquentes de type |nullPointerException|.\r
\r
Pour qu'une variable puisse prendre la valeur |null|, elle doit avoir été déclarée explicitement avec le type |nullable| :\r
\lstinputlisting[language=Nit]{./poo/listings/nullable1_c.nit}\r
Dans l'exemple précédent, si on omet de préciser le type comme |nullable|, le compilateur Nit lèvera une erreur au moment de la compilation.\r
\r
+La valeur |null| peut donc être utilisée avec n'importe quel type \textit{nullable} mais aucun message ne peut être envoyé à |null|.\r
+\r
\chapter{Modificateurs d'accès}\r
-Les modificateurs d'accès assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de données par les autres classes. Ils s'appliquent aussi bien aux classes, qu'aux méthodes et attributs.\r
+Les modificateurs d'accès assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de données par les autres classes. Ils s'appliquent aussi bien aux classes qu'aux méthodes et attributs.\r
\r
\section{Visibilité des entités}\r
De nombreux langages orientés objet introduisent des attributs de visibilité pour réglementer l'accès aux classes et aux objets, aux méthodes et aux données.\r
\r
%TODO reformuler\r
\begin{description}\r
- \item[Par défaut : public] Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut lorsqu'aucun modificateur n'est précisé. Un attribut ou une méthode déclaré public est visible par tous les autres objets. Dans la philosophie orientée objet aucun attribut ne devrait être déclaré public : il est préférable d'écrire des méthodes pour le consulter et le modifier.\r
- \item[protected] Si un attribut ou une méthode est déclarée |protected|, seules les méthodes de ses sous classes pourront y accéder.\r
+ \item[Par défaut : public] Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut lorsqu'aucun modificateur n'est précisé. Un attribut ou une méthode public est visible par tous les autres objets. Dans la philosophie orientée objet, aucun attribut ne devrait être déclaré public : il est préférable d'écrire des méthodes pour le consulter et le modifier.\r
+ \item[protected] Si un attribut ou une méthode est déclaré |protected|, seules les méthodes des sous classes pourront y accéder.\r
\item[private] C'est le niveau de protection le plus fort. Les composants ne sont visibles qu'à l'intérieur du fichier où est définie la classe.\r
\end{description}\r
\r
\section{Types retournés}\r
Le type retourné correspond au type de l'objet qui est renvoyé par la méthode. Si la méthode ne retourne rien, alors on ne précise pas le type retourné.\r
\r
-La valeur de retour de la méthode doit être transmise par l'instruction |return|. Elle indique la valeur que prend la méthode et termine celle ci : toutes les instructions qui suivent |return| ne seront pas exécutées. Si des instructions sont placées après le mot clé |return|, une erreur |unreachable statement| sera levée lors de la compilation.\r
+La valeur de retour de la méthode doit être transmise par l'instruction |return|. Elle indique la valeur que prend la méthode et termine celle ci : les instructions qui suivent |return| à l'intérieur du même bloc ne seront pas exécutées. Si des instructions sont placées après le mot clé |return|, une erreur |unreachable statement| sera levée lors de la compilation.\r
\r
\lstinputlisting[language=Nit]{./poo/listings/methode1_c.nit}\r
\r
Il est possible d'inclure une instruction |return| dans une méthode sensée ne rien retourner : cela permet de quitter la méthode.\r
\r
\section{Passage de paramètres}\r
-Les paramètres des méthodes sont déclarés entre parenthèses et séparés par des virgules. Le type et le nombre de paramètres déclarés doivent correspondre au type et au nombre de paramètres transmis. Si un méthode n'accepte pas de paramètres, il suffit de ne pas indiquer de parenthèses :\r
+Les paramètres des méthodes sont déclarés entre parenthèses et séparés par des virgules. Le type et le nombre de paramètres déclarés doivent correspondre au type et au nombre de paramètres transmis. Si une méthode n'accepte pas de paramètres, il suffit de ne pas indiquer de parenthèses :\r
\lstinputlisting[language=Nit]{./poo/listings/methode2_c.nit}\r
\r
Si plusieurs paramètres ont le même type, il est possible de le factoriser :\r
\r
Il n'est pas possible d'indiquer des valeurs par défaut dans les paramètres. \r
\r
-Lorsqu'un objet est passé comme paramètre à une méthode, cette dernière reçoit une référence qui désigne son emplacement mémoire d'origine et qui est une copie de la variable. Il est possible de modifier l'objet grâce à ces méthodes mais il n'est pas possible de remplacer la référence contenue dans la variable passée en paramètre : ce changement n'aura lieu que localement à la méthode.\r
+Lorsqu'un objet est passé comme paramètre à une méthode, cette dernière reçoit une référence qui désigne son emplacement mémoire d'origine. Il est possible de modifier l'objet grâce à ces méthodes mais il n'est pas possible de remplacer la référence contenue dans la variable passée en paramètre : ce changement n'aura lieu que localement à la méthode.\r
\r
\section{Envoi de message}\r
Un message est émis lorsqu'on demande à un objet d'exécuter l'une de ses méthodes.\r
\lstinputlisting[language=Nit]{./poo/listings/methode8_c.nit}\r
\r
\section{Nombre variable de paramètres}\r
-Il est possible d'indiquer qu'une méthode peut recevoir un nombre variable de paramètre grâce à l'opérateur |...|. Le paramètre sera alors considéré comme un tableau du type spécifié. L'envoi de message pourra alors contenir aucun, un ou plusieurs arguments pour le paramètre ainsi déclaré.\r
+Il est possible d'indiquer qu'une méthode peut recevoir un nombre variable de paramètre grâce à l'opérateur |...|. Le paramètre sera alors considéré comme un tableau du type spécifié. L'envoi de message pourra alors contenir zéro, un ou plusieurs arguments pour le paramètre ainsi déclaré.\r
\r
\lstinputlisting[language=Nit]{./poo/listings/methode9_c.nit}\r
\r
-Seulement un seul paramètre variable est autorisé dans une signature.\r
+Un seul paramètre variable est autorisé dans une signature.\r
\r
\section{Enchaînement de références}\r
Il est possible d'enchaîner les envois de messages aux retours des méthodes :\r
\lstinputlisting[language=Nit]{./poo/listings/methode5_c.nit}\r
\r
-Ici on appelle la méthode to\_upper de l'objet retourné par la méthode substring de l'objet "abcd".\r
+Ici on appelle la méthode \textit{to\_upper} de l'objet retourné par la méthode \textit{substring} de l'objet \textit{"abcd"}.\r
\r
\section{Mot-clé self}\r
\r
Voici un exemple d'utilisation des getters automatiques :\r
\lstinputlisting[language=Nit]{./poo/listings/accesseurs2_c.nit}\r
\r
-Pour les setters, ils sont toujours générés comme étant |private|. Pour changer cette visibilité, il est nécessaire de préciser l'attribut comme |writable| en lui rajoutant la visibilité souhaitée :\r
+Pour les setters, ils sont toujours générer comme étant |private|. Pour changer cette visibilité, il est nécessaire de préciser l'attribut comme |writable| en lui rajoutant la visibilité souhaitée :\r
\begin{description}\r
\item[writable] Le setter automatique sera généré avec la visibilité public.\r
\item[protected writable] Le setter automatique sera généré avec la visibilité |protected|.\r
\lstinputlisting[language=Nit]{./poo/listings/accesseurs3_c.nit}\r
\r
\section{Redéfinition d'attributs}\r
-Les accesseurs automatiques sont des considérés comme des méthodes normales, ils peuvent donc être hérités et redéfinis. De plus les accesseurs automatiques peuvent être utilisés pour redéfinir des accesseurs manuels. |redef var| permet de préciser une redéfinition du getter alors que |redef writable| permet de redéfinir le setter :\r
+Les accesseurs automatiques sont considérés comme des méthodes normales, ils peuvent donc être hérités et redéfinis. De plus les accesseurs automatiques peuvent être utilisés pour redéfinir des accesseurs manuels. |redef var| permet de préciser une redéfinition du getter alors que |redef writable| permet de redéfinir le setter :\r
\lstinputlisting[language=Nit]{./poo/listings/accesseurs4_c.nit}\r
\r
\section{Opérateur isset}\r
\r
-Pour vérifier si un opérateur a été initialisée, on peut utiliser l'opérateur |isset| :\r
+Pour vérifier si un attribut a été initialisé, on peut utiliser l'opérateur |isset| :\r
\lstinputlisting[language=Nit,]{./poo/listings/isset_c.nit}\r
\r
\chapter{Constructeurs}\r
\r
\section{Redéfinition de méthodes}\r
\label{redef}\r
-La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent (type et nombre de paramètres et la valeur de retour doivent être identiques). Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge (et rappelez-vous : ce n'est pas autorisé en Nit !).\r
+La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent (type et nombre de paramètres et la valeur de retour doivent être identiques). Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge... et rappelez-vous : ce n'est pas autorisé en Nit.\r
\r
Pour redéfinir une méthode, il suffit d'utiliser le mot-clé |redef| :\r
\lstinputlisting[language=Nit]{./poo/listings/redef1_c.nit}\r
%\lstinputlisting[language=Nit]{./poo/listings/redef5_c.nit}\r
\r
\section{Polymorphisme}\r
-Le polymorphisme est la capacité, pour un même message de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée dynamiquement à l'exécution.\r
+Le polymorphisme est la capacité, pour un même message, de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée dynamiquement à l'exécution.\r
\r
L'idée est de partir d'un type et de le modifier. Par exemple, on peut créer une classe de base, puis faire des classes dérivées :\r
-\lstinputlisting[language=Nit]{./poo/listings/polymorphisme_c.nit}\r
+\lstinputlisting[language=Nit, linerange=1-35]{./poo/listings/polymorphisme_c.nit}\r
\r
On peut ensuite traiter les objets de la même manière quelques soit leur type dynamique :\r
-\lstinputlisting[language=Nit, linerange=39-43, firstnumber=last]{./poo/listings/polymorphisme_c.nit}\r
+\lstinputlisting[language=Nit, linerange=37-43, firstnumber=last]{./poo/listings/polymorphisme_c.nit}\r
\r
L'héritage définit un sous-typage implicite de la classe fille vers la classe mère : on peut affecter à une référence d'une classe n'importe quel objet d'une de ses sous classes.\r
\r
\section{Coercition}\r
-La coercition (conversion de type) peut être utilisé dans le cadre d'un cast standard grâce au mot-clé |as| :\r
+La coercition (conversion de type) peut être utilisée dans le cadre d'un cast standard grâce au mot-clé |as| :\r
\lstinputlisting[language=Nit]{./poo/listings/coercition1_c.nit}\r
\r
L'inconvénient de cette méthode est que si l'objet n'avait pas été dynamiquement typé en tant que Vache, une erreur d'exécution serait survenue lors du cast puisque celui-ci aurait échoué.\r
\chapter{Généricité et types virtuels}\r
\r
\section{Généricité}\r
-Le principe de la généricité est de factoriser les méthodes pouvant s'appliquer à n'importe quelle variable quelque soit sont type en évitant les problèmes de coercition.\r
+Le principe de la généricité est de factoriser les méthodes pouvant s'appliquer à n'importe quelle variable quel que soit son type en évitant les problèmes de coercition.\r
\r
\subsection{Généricité simple}\r
Prenons un exemple de classe non générique :\r
Si nous souhaitons pouvoir utiliser cette classe avec d'autres objets que des |String|, il serait possible de se baser sur le type le plus haut dans la hiérarchie Nit, c'est à dire |Object| :\r
\lstinputlisting[language=Nit, linerange=1-3]{./poo/listings/gen2_c.nit}\r
\r
-Voyons maintenant ce qu'il se passe quand nous utilisons cette classe avec des |Int| :\r
+Voyons maintenant ce qui se passe quand nous utilisons cette classe avec des |Int| :\r
\lstinputlisting[language=Nit, linerange=5-7, firstnumber=last]{./poo/listings/gen2_c.nit}\r
\r
Vous remarquerez qu'il est nécessaire d'utiliser un cast pour utiliser le retour du |getter| de l'attribut |valeur| puisque celui-ci est de type |Object|. Ce n'est pas pratique et potentiellement dangereux pour la stabilité du programme puisque le risque d'erreur d'exécution sur un cast qui a échoué augmente.\r
\r
Dans cette classe, le T n'est pas encore défini, cela se fera à l'instanciation. Par contre, une fois instancié avec un type, l'objet ne pourra travailler qu'avec le type de données spécifié à l'instanciation.\r
\r
-La déclaration d'une classe générique se fait en utilisant précisant le type joker (représenté par n'importe quel mot) entre crochet |[T]|. Il suffit ensuite d'implémenter les méthodes comme nous le ferions habituellement mais en remplaçant les types par le joker que nous avons défini dans la déclaration de la classe.\r
+La déclaration d'une classe générique se fait en précisant le type joker (représenté par n'importe quel mot) entre crochet |[T]|. Il suffit ensuite d'implémenter les méthodes comme nous le ferions habituellement mais en remplaçant les types par le joker que nous avons défini dans la déclaration de la classe.\r
\r
Voyons comment utiliser notre classe générique avec des entiers :\r
\lstinputlisting[language=Nit, linerange=5-6, firstnumber=last]{./poo/listings/gen3_c.nit}\r
\lstinputlisting[language=Nit]{./poo/listings/gen5_c.nit}\r
\r
\section{Types virtuels}\r
-Les types virtuels permettent définir au sein d'une classe un champ qui va contenir un type plutôt d'un objet. Ce champ peut ensuite être utilisé pour typer les paramètres et les types de retour des méthodes. Sa valeur sera exploitée à la compilation pour définir quel est le type à utiliser.\r
+Les types virtuels permettent définir au sein d'une classe un champ qui va contenir un type plutôt d'un objet. Ce champ peut ensuite être utilisé pour typer les paramètres et les types de retour des méthodes. Sa valeur sera exploitée à la compilation pour définir le type à utiliser.\r
\r
Exemple d'utilisation d'un type virtuel :\r
\lstinputlisting[language=Nit]{./poo/listings/type1_c.nit}\r
Pour l'instant il n'est pas possible d'importer des modules se trouvant dans un autre répertoire que celui où se trouvent les fichiers sources.\r
\r
\subsection{Import privé}\r
-Si on utilise le mot-clé |private| devant le |import|, le module sera importé dans le module courant comme privé. C'est à dire que tous les modules qui importeront le module courant ne verrons pas les classes et les propriétés importées.\r
+Si on utilise le mot-clé |private| devant le |import|, le module sera importé dans le module courant comme privé. C'est à dire que les modules qui importeront le module courant ne verrons pas les classes et les propriétés importées.\r
\r
\subsection{Import intrusif}\r
L'utilisation du mot-clé |intrude| avant l'import d'un module permet d'importer le module en mode intrusif, c'est à dire d'ignorer toutes les restrictions liées à la visibilité. Ainsi les méthodes déclarées |private| seront considérées comme publiques.\r
\part{Présentation de Nit}\r
\r
\chapter{Caractéristiques}\r
-Nit est un langage de programmation orienté objet dont la syntaxe est proche de celle des langages de scripts. Le but de Nit est de proposer un langage de programmation robuste typage statique, où la structure n'est pas une torture.\r
+Nit est un langage de programmation orienté objet dont la syntaxe est proche de celle des langages de scripts. Le but de Nit est de proposer un langage de programmation robuste à typage statique, où la structure n'est pas une torture.\r
\begin{description}\r
\item[Nit est compilé]Le code source de Nit est compilé pour être ensuite traduit en C.\r
\item[Nit est orienté objet]Comme la plupart des langages récents, Nit est orienté objet. Chaque fichier source contient la définition d'une ou plusieurs classes qui sont utilisées les unes avec les autres pour former une application. En Nit, TOUT est objet (Et oui même a = 0, c'est de l'objet).\r
\end{quote}\r
\r
\chapter{Historique}\r
-Nit est le descendant direct de PRM développé en 2005 au LIRMM en France. Il s'agit d'un langage jouet servant à expérimenter des traits de langage et des techniques d'implémentation.\r
+Nit est le descendant direct de PRM développé en 2005 au LIRMM en France. Il s'agissait d'un langage jouet servant à expérimenter des traits de langage et des techniques d'implémentation.\r
\r
-En 2008 nait Nit un langage plus généraliste développé conjointement par l'UQAM et le LIRMM. Il étend PRM en y ajoutant utilisabilité et robustesse.\r
+En 2008 nait Nit un langage plus généraliste développé conjointement à l'UQAM et au LIRMM. Il étend PRM en y ajoutant utilisabilité et robustesse.\r
\r
-Aujourd'hui, en 2011, le développement de Nit continu...\r
+Aujourd'hui, en 2011, le développement de Nit continue...\r
\r
\r
\chapter{Installation de Nit}\r
-Le compilateur Nit est librement accessible grâce à Git : \r
+Le compilateur Nit est librement accessible grâce à git : \r
\begin{description}\r
\item[Protocole GIT]\url{git://nitlanguage.org/nit.git}\r
\item[Protocole HTTP]\url{http://nitlanguage.org/nit.git}\r
Ça y est, le compilateur Nit est maintenant installé sur votre ordinateur !\r
\r
\chapter{Compilation et exécution}\r
-Un programme Nit est composé d'un ou plus généralement plusieurs fichiers source. N'importe quel éditeur de texte peut être utilisé pour éditer un fichier Nit.\r
+Un programme Nit est composé d'un ou plus généralement plusieurs fichiers source. N'importe quel éditeur de texte peut être utilisé pour modifier un fichier Nit.\r
\r
Ces fichiers source possèdent l'extension \og .nit \fg. Ils peuvent contenir du code, une ou plusieurs classes et/ou modules.\r
\r
-\part{Syntaxe et éléments de bases de Nit}\r
+\part{Syntaxe et éléments de base de Nit}\r
\r
\chapter{Syntaxe}\r
\r
\r
Attention : Le compilateur lèvera une exception si une variable commence par une majuscule.\r
\r
-Un identificateur ne peut pas appartenir à la liste des mots clés réservé du langage Nit :\r
+Un identificateur ne peut pas appartenir à la liste des mots clés réservés du langage Nit :\r
\begin{multicols}{4}\r
\begin{itemize}\r
\item |abort|\r
\begin{itemize}\r
\item On préfèrera utiliser la notation basée sur le soulignement pour les variables. Par exemple : |ma_variable| ;\r
\item Les types, comme les noms des classes seront écrits en \og CamelCase \fg. Par exemple : |MaClasse| ;\r
- \item L'indentation est faite avec le caractère de tabulation et est afficher comme 8 espaces ;\r
+ \item L'indentation est faite avec le caractère de tabulation et est affichée comme 8 espaces ;\r
\item Les opérateurs sont entourés d'espaces. Par exemple : |4 + 5| ou |x = 5| ;\r
\item Les spécificateurs de type (|:|) et les virgules (|,|) ont un espace après mais pas avant. Par exemple : |var x: X| ou |[1, 2, 3]| ;\r
\item Les parenthèses (|()|) et les crochets (|[]|) ne prennent pas d'espaces ;\r
\r
A l'heure actuelle, Nit ne supporte pas les commentaires multi-lignes.\r
\r
-\chapter{Éléments de bases de Nit}\r
+\chapter{Éléments de base de Nit}\r
\r
\section{Déclaration et utilisation des variables}\r
\r
Vous remarquerez qu'en Nit, il n'est pas nécessaire d'utiliser les parenthèses si le constructeur ne prend pas de paramètres.\r
\r
\section{Type nullable}\r
-Pour éviter les exceptions |nullPointerException| qui peuvent être très fréquentes sur d'autres langages, Nit impose au développeur de préciser si une variable a le droit de prendre la valeur |null|.\r
+Pour éviter les exceptions |nullPointerException| qui peuvent être fréquentes sur d'autres langages, Nit impose au développeur de préciser si une variable a le droit de prendre la valeur |null|.\r
\r
Pour préciser qu'une variable peut prendre la valeur |null|, il faut utiliser le mot clé |nullable|.\r
\r
\r
\section{Structures de contrôles}\r
\r
-Comme les autres langages de développement, Nit propose un ensemble d'instruction qui permettent d'organiser et de structurer les traitements. L'usage de ces instructions est similaire à celui rencontré à leur équivalent dans d'autres langages.\r
+Comme les autres langages de développement, Nit propose un ensemble d'instructions qui permettent d'organiser et de structurer les traitements. L'usage de ces instructions est similaire à celui rencontré à leur équivalent dans d'autres langages.\r
\r
\subsection{Boucles}\r
\subsubsection{While}\r
\lstinputlisting[language=Nit, linerange=18]{./syntaxe/listings/for_c.nit}\r
\r
\subsubsection{Loop}\r
-Les boucles infinies sont souvent utilisés accompagnées de l'instruction |break|. Elles sont utiles pour implémenter les boucles de type \og jusqu'à \fg |untill| ou pour simuler le |exit when| de Ada.\r
+Les boucles infinies sont souvent utilisés accompagnées de l'instruction |break|. Elles sont utiles pour implémenter les boucles de type \og jusqu'à \fg \textit{untill} ou pour simuler le \textit{exit when} de Ada.\r
\r
\lstinputlisting[language=Nit]{./syntaxe/listings/loop_c.nit}\r
\r
On peut aussi utiliser des clauses |else if| pour chaîner plusieurs tests :\r
\lstinputlisting[language=Nit, linerange=9-17]{./syntaxe/listings/if_c.nit}\r
\r
-Attention : Si on utilise un |else| ou un |else if|, l'instruction ne peut pas être écrit \og OnLiner \fg.\r
+Attention : Si on utilise un |else| ou un |else if|, l'instruction ne peut pas être écrit \textit{On Liner}.\r
\r
\subsection{Débranchements}\r
|continue| permet de passer immédiatement à l'itération suivante dans une boucle |for|, |while| ou |loop| :\r
L'instruction |abort| permet d'arrêter le programme en lançant une erreur fatale.\r
\r
\subsection{Assertions}\r
-L'instruction |assert| vérifie si une expression booléenne est vrai, sinon elle arrêtera le programme comme |abort|. Elle peut être combinée à une close |else| pour exécuter du code avant d'arrêter le programme :\r
+L'instruction |assert| vérifie si une expression booléenne est vrai, sinon elle arrêtera le programme comme |abort|. Elle peut être combinée à une clause |else| pour exécuter du code avant d'arrêter le programme :\r
\lstinputlisting[language=Nit]{./syntaxe/listings/assert_c.nit}\r
\r
Comme on peut le voir dans l'exemple précédent, une étiquette peut être précisée pour être affichée dans le message d'erreur.\r
\r
Attention, en Nit, la première case du tableau est la case 0 !\r
\r
+\subsection{Parcours d'un tableau}\r
+On peut parcourir les tableaux grâce à une boucle |for| :\r
+\lstinputlisting[language=Nit, linerange=3-5, firstnumber=last]{./syntaxe/listings/array2_c.nit}\r
+\r
\subsection{Initialisation explicite d'un tableau}\r
Il existe une manière plus rapide de créer les tableaux en initialisant explicitement le tableau avec les valeurs qu'il doit contenir.\r
\r
\lstinputlisting[language=Nit, linerange=1]{./syntaxe/listings/array2_c.nit}\r
\r
-\subsection{Parcours d'un tableau}\r
-On peut parcourir les tableaux grâce à une boucle |for| :\r
-\lstinputlisting[language=Nit, linerange=3-5, firstnumber=last]{./syntaxe/listings/array2_c.nit}\r
-\r
%\section{Intervalles}\r
%TODO vérifier et faire\r
%Il est possible de déclarer des intervalles |Range| basés sur des types discrets (comme |Int| par exemple). Il existe deux types d'intervalles : les intervalles ouverts |[1..5[| qui excluent le dernier élément, et les intervalles fermés |[1..5]| qui incluent le dernier élément.\r
\r
\r
\section{Conversions de types}\r
-En Nit, il n'existe pas de mot clé de transtypage. Les conversions de types se font par des méthodes. La bibliothèque standard fournit une série de classe qui contiennent des méthodes de manipulation et de conversion de types.\r
+En Nit, il n'existe pas de mot clé de transtypage. Les conversions de types se font par des méthodes. La bibliothèque standard fournit une série de classes qui contiennent des méthodes de manipulation et de conversion de types.\r
\r
\begin{tabularx}{\linewidth}{|c|X|}\r
\hline\r
\textbf{Classe} & \textbf{Rôle} \\\r
\hline\r
- Char & pour les caractères \\\r
+ \textit{Char} & pour les caractères \\\r
\hline\r
- String & pour les chaînes de caractères \\\r
+ \textit{String} & pour les chaînes de caractères \\\r
\hline\r
- Int & pour les entiers \\\r
+ \textit{Int} & pour les entiers \\\r
\hline\r
- Float & pour les nombres à virgule flottante \\\r
+ \textit{Float} & pour les nombres à virgule flottante \\\r
\hline\r
\end{tabularx}\r
\r
-Par exemple la classe Int propose les méthodes suivantes :\r
+Par exemple la classe \textit{Int} propose les méthodes suivantes :\r
\begin{description}\r
- \item[Int.to\_c:Char] Retourne le caractère correspondant.\r
- \item[Int.to\_f:Float] Retourne l'entier sous forme de |Float|.\r
- \item[Int.to\_s:String] Retourne l'entier sous forme de |String|.\r
+ \item[Int.to\_c: Char] Retourne le caractère correspondant.\r
+ \item[Int.to\_f: Float] Retourne l'entier sous forme de |Float|.\r
+ \item[Int.to\_s: String] Retourne l'entier sous forme de |String|.\r
\end{description}\r
\r
\section{Manipulation de chaînes de caractères}\r
\r
\subsection{Caractères spéciaux}\r
\r
-Dans un chaîne de caractères, plusieurs caractères particuliers doivent être échappés grâce au caractère |\| pour être utilisés. \r
+Dans une chaîne de caractères, plusieurs caractères particuliers doivent être échappés grâce au caractère |\| pour être utilisés. \r
\r
Le tableau ci-dessous recense les principaux caractères à échapper :\r
\r
Par exemple avec un Int :\r
\lstinputlisting[language=Nit, linerange=7-7]{./syntaxe/listings/string_c.nit}\r
\r
-Une notation allégée permet de concaténer une variable ou une expression avec une chaine de caractère :\r
+Une notation particulière permet d'inclure une variable ou une expression dans une chaine de caractères :\r
\lstinputlisting[language=Nit, linerange=9-10]{./syntaxe/listings/string_c.nit}\r
\r
La notation allégée appelle implicitement la méthode |to_s| sur les types autres que |String| :\r
\r
\subsection{Comparaison de chaînes de caractères}\r
\r
-En Nit il est possible de comparer deux chaînes de caractères directement grâce à l'opérateur |==|. Contrairement à Java par exemple, Nit va comparer la valeur des objets String est non pas les objets en eux-mêmes.\r
+En Nit il est possible de comparer deux chaînes de caractères directement grâce à l'opérateur |==|. Contrairement à Java par exemple, Nit va comparer la valeur des objets String est non pas les références vers les objets.\r
\lstinputlisting[language=Nit]{./syntaxe/listings/string2_c.nit}\r
\r
\subsection{Autres opérations sur les chaînes de caractères}\r
-Les méthodes |to_upper| et |to_lower| permettent respectivement d'obtenir une chaîne tout en majuscule ou tout en minuscule.\r
+Les méthodes |to_upper| et |to_lower| permettent respectivement d'obtenir une chaîne toute en majuscule ou toute en minuscule.\r
\r
La méthodes |length| permet d'obtenir la taille de la chaîne.\r
\r
Par exemple :\r
\lstinputlisting[language=Nit]{./syntaxe/listings/typage_c.nit}\r
\r
-Les instructions de contrôle de flot vont eux aussi agir sur le typage de la variable :\r
+Les instructions de contrôle de flot vont elles aussi agir sur le typage de la variable :\r
\lstinputlisting[language=Nit]{./syntaxe/listings/typage2_c.nit}\r
\r
Le typage adaptatif fonctionne aussi avec les types nullables :\r
nitlanguage / nit.git / commitdiff