# Un fichier = un module. Les classes d'un module sont définies dans le fichier.
# Au début des fichiers, les modules à importer doivent être déclarés (via le
# mot clé "import"). Implicitement, tout module importe le module nommé
-# "standard" qui définit les classes usuelles.
+# "core" qui définit les classes usuelles.
# On va étudier une représentation d'un entrepôt de produits variés.
class Entrepot
# Dans un bloc "private", les propriétés déclarées sont seulement accessibles au
# receveur ("self")
-# Les attributs sont déclarés par le mot clé "meth" et commencent par un "@"
- attr _nom_: String # Un entrepôt a un nom (de type chaîne).
- attr _rayons: Array[Rayon] # Il est composé d'un ensemble de rayon.
+# Les attributs sont déclarés par le mot clé "fun" et commencent par un "@"
+ var nom_: String is noinit # Un entrepôt a un nom (de type chaîne).
+ var rayons: Array[Rayon] is noinit # Il est composé d'un ensemble de rayon.
# "Array" est une classe paramétrée, les crochets en sont la marque.
# La classe "Rayon" est définie plus loin
# Les propriétés déclarées dans un bloc "public" sont accessibles à tout le
# monde.
-# Les méthodes (fonctions et procédures) sont déclarées par le mot clé "meth"
+# Les méthodes (fonctions et procédures) sont déclarées par le mot clé "fun"
# nom est une fonction qui retourne une chaîne
- meth nom: String
+ fun nom: String
do
# "return" sort de la fonction
return _nom_
end
# set_nom est une procédure qui prend une chaîne en paramètre
- meth set_nom(n: String)
+ fun set_nom(n: String)
do
_nom_ = n # "=" désigne l'affectation
# Les affectations sont des instructions et ne sont pas
# chaînées
end
- meth add_rayon(r: Rayon)
+ fun add_rayon(r: Rayon)
do
_rayons.add(r) # "add" ajoute un élément
end
# to_s est la méthode implicitement appelée par "print" et "println"
# Il s'agit de la représentation "humaine" d'un objet
- redef meth to_s: String
+ redef fun to_s: String
do
# Les variables sont déclarées par "var", leur portée va de leur
# déclaration jusqu'au "end" correspondant
- var s = new Buffer # Là où on calcule le résultat
+ var s = new FlatBuffer # Là où on calcule le résultat
# Les chaînes littérales sont déclarées avec des guillemets
s.append("*** Entrepôt ") # On initialise "s"
# puis on concatène des chaînes à "s"
class Produit
private
- attr _nom_: String # Désignation du produit
- attr _qte_: Int # Quantité en stock
+ var nom_: String # Désignation du produit
+ var qte_: Int # Quantité en stock
# Comme nous l'avons vu, les accesseurs en lecture sont
# généralement homonymes aux attributs (au @ près).
- meth nom: String
+ fun nom: String
do
return _nom_
end
- meth qte: Int
+ fun qte: Int
do
return _qte_
end
# Toutefois, pour les accesseurs en écriture, il est d'usage en NIT
# d'utiliser un type de méthode particulier appelé "accesseur universel"
# son nom se caractérise par un "=" final
- meth qte=(i: Int)
+ fun qte=(i: Int)
do
_qte_ = i
end
# la quantité d'un produit.
- redef meth to_s: String
+ redef fun to_s: String
do
# On peut aussi utiliser "+" pour concaténer les chaînes
return _nom_ + ":" + _qte_.to_s
class Rayon
private
- attr _stock: Array[Produit] # Des produits en stock
- attr _rubrique: String # La catégorie des produits stockés
+ var stock: Array[Produit] is noinit # Des produits en stock
+ var rubrique: String is noinit # La catégorie des produits stockés
# Cette fonction est utilisé par to_s pour afficher un petit titre
- meth to_s_head: String
+ fun to_s_head: String
do
# Les déclarations de type sont optionnelles dans un bloc "var".
# Si une expression est passée comme valeur initiale d'une
# variable, le type statique de la variable est implicitement
# celui de l'expression.
- var s = new Buffer
+ var s = new FlatBuffer
s.append("* Rayon : ")
# Ici, le type statique de s est implicitement String
return s.to_s
end
- meth cherche_produit(n: String): nullable Produit
+ fun cherche_produit(n: String): nullable Produit
do
var i = _stock.iterator
while i.is_ok do
end
- redef meth to_s: String
+ redef fun to_s: String
do
- var s = new Buffer
+ var s = new FlatBuffer
s.append(to_s_head)
# Les boucles en NIT sont des structures puissantes, toutefois
# la manipulation des itérateurs peut être facilité par la
# Cette fonction permet de retourner la quantité d'un produit donné
# Ce service est très simple à implémenter si on utilise cherche_produit
- meth quantite(n: String): Int
+ fun quantite(n: String): Int
do
var p = cherche_produit(n)
# "==" est l'opérateur d'égalité d'identité
# Le service dual consiste à définir la quantité d'un produit
# En NIT, il est d'usage de définir ce genre de service par un accesseur
# universel :
- meth quantite=(n: String, i: Int)
+ fun quantite=(n: String, i: Int)
do
var p = cherche_produit(n)
if p == null then
# pour obtenir la quantité de clous dans le rayon, et :
# r.quantite("clous") = 15
# pour mettre le nombre de clous à 15
-
- init do end
end
class RayonNormal
-special Rayon
+ super Rayon
init(r: String)
do
class RayonFroid
# Les super-classes sont déclarés avec le mot clé "special".
# Implicitement, c'est "Object", la classe de tous les objets.
-special Rayon
+ super Rayon
# Tant qu'on parle d'implicite, en l'absence de bloc de propriétés,
# celles-ci sont déclarées en tant que "public"
- meth temp_max: Int
+ fun temp_max: Int
do
return _temp_max_ # Attribut défini juste en dessous
end
- attr _temp_max_: Int # Une température maximale
+ var temp_max_: Int # Une température maximale
# Les autres attributs sont bien sûr hérités !
- redef meth to_s_head: String # On redéfinit cette méthode
+ redef fun to_s_head: String # On redéfinit cette méthode
do
# nous avons vu le "append" et le "+" sur les chaînes, mais la
# méthode la plus simple reste la construction "{}" qui
nitlanguage / nit.git / blobdiff