Instruction. Définition d'un paramètre de type de données.
Type NomDuType ParametrageDuType HeritageType Fin Type
Type NomDuType Recursif ;
Type NomDuType = TypeElementaire ContrainteType ;
Type permet de construire un nouveau type de données à partir des types de données déjà existants.
Il s'agit soit de :
Il est possible de rendre le contenu d'un objet du type variable en créant une définition polymorphe du type au moyen de l'instruction Selon : en fonction de la valeur d'une propriété d'un type, certaines caractéristiques sont disponibles, d'autres sont indisponibles. Par défaut, toutes les caractéristiques sont simultanément disponibles.
Un type peut posséder des opérateurs implicites. Cela s'effectue au moyen de l'attribut Defaut. Ainsi, le type possède automatiquement les opérateurs =, == et !=.
Un type peut hériter des propriétés et des méthodes d'un autre type. Cela s'effectue au moyen de l'instruction-attribut HeriteDe. Ainsi, si le type A hérite du type B, tout objet de type A possède les mêmes caractéristiques que tout objet de type B et les méthodes de B peuvent être surchargées par des méthodes de A.
Un type peut implémenter des interfaces définies par l'instruction Interface. Cela s'effectue au moyen de l'instruction-attribut Implemente. Ainsi, si le type A implémente l'interface B, tout objet de type A possède les mêmes caractéristiques que tout objet de type B et chaque méthode de B sont implémentées par une méthode de A.
Par défaut, un autre type pourra hériter du type en cours de définition. Il est néanmoins possible d'interdire l'héritage de ce type au moyen du mot-clé Final.
L'accès aux propriétés et aux méthodes peut être restreint de la sorte qu'il est par exemple interdit d'utiliser une propriété ou une méthode en dehors des méthodes du type ou en dehors du type héritant. Cela s'effectue respectivement au moyen des instructions Prive et Protege. Par défaut, l'accès aux propriétés et aux méthodes du type est Public, ce qui signifie qu'ils sont utilisables dans les méthodes du type, dans un type héritant ou en dehors du type.
L'héritage d'un type peut être également contrôlé à l'aide de ces même instructions.
Un type peut être paramétré afin de le rendre générique. Les types de paramètres admissibles sont Constante, Enumere et Type. Un type paramétré peut servir à définir des objets génériques s'il n'y a pas de paramètre de déclarés ou spécifiques s'il y a des paramètres de déclarés. En ce cas, lors de la déclaration d'un objet d'un type paramétré, il est nécessaire d'instancier les paramètres en respectant leur nombre et leur sémantique.
Il est possible de définir les opérateurs standards pour un type. Ainsi, un type appelé Complexe permettra l'addition, la soustraction, la comparaison, l'affectation, etc.
Il est possible de définir des constructeurs du type au moyen de l'instruction Constructeur. Un constructeur est une méthode spéciale permettant de construire un objet du type. Si le type comporte un constructeur implicite, c'est-à-dire un constructeur sans paramètre, alors il sera possible de déclarer des objets de ce type qui seront automatiquement initialisés par la valeur renvoyée par ce constructeur. Si le type ne comporte pas de constructeur implicite, les objets de ce type ne peuvent être automatiquement initialisés et en ce cas leur déclaration doit comporter Nul Ou.
Il est possible de définir comment les objets du type doivent être gérés en mémoire. L'allocation et la libération des objets est réalisée par Up ! Compiler statiquement ou dynamiquement selon le contexte. L'allocation dynamique est gérée par défaut par le ramasse miettes du noyau d'exécution. Il est néanmoins possible de se définir un propre système d'allocation au moyen des méthodes spéciales Allouer et Liberer.
Lorsque les types du modèles de données s'utilisent les uns les autres, il est nécessaire de définir certain type comme étant récursifs. Pour plus de précisions, veuillez vous référer à Recursif.
L'instruction Type permet de dénommer un type élémentaire. Ce nouveau type est plus qu'un synonyme qui améliore la lisibilité du programme : il permet d'être certain que toutes les déclarations qui doivent être homogènes sont bien du même type.
L'instruction Type permet de restreindre les types de base Caractere, Entier et Reel en posant une contrainte. Par exemple, il est possible de définir les entiers naturels à partir de Entier.
L'instruction Type permet également de déclarer un paramètre à un type de type de données. Ce paramètre peut être employé pour déclarer une propriété du type ou un paramètre d'une méthode. Le type passé en paramètre est supposé ne pas avoir de constructeur implicite, donc les propriétés ou les paramètres des méthodes de type ce paramètre doivent être déclaré avec les instructions Nul Ou.
Tous les constructeurs d'un type possédant des paramètres ont comme premiers paramètres implicites les paramètres du type. De fait, un type paramétré ne peut avoir de constructeur implicite.
Il est possible de définir l'entrepôt dans lequel seront rangés par défaut les objets de ce type ainsi que les propriétés des objets de ce type. Cela s'effectue au moyen de l'instruction Entrepot. Si aucun entrepôt n'est précisée, alors les objets sont rangés dans le premièr entrepôt utilisateur.
Il est possible de définir le nombre maximal d'objets à allouer simultanément lorsque Up ! Object Management System doit allouer un objet de ce type et qu'il n'y a plus d'objet en réserve. Cela s'effectue au moyen de l'instruction TailleSegmentMax. Si aucune limite n'est précisée, alors le type ne dispose pas de son propre espace d'allocation.
Il est possible de spécifier que les objets du type pourront avoir des propriétés dynamiques en plus des propriétés statiques provenant de la définition du type. Cela s'effectue au moyen de l'instruction ProprietesDynamiques.
Il est possible de spécifier que les modifications des objets du type seront gérées en transaction. Cela s'effectue au moyen de l'instruction Transactionnel.
Type A
/****/
/* Définition du type A. */
C1 : Entier;
/* Définition de la propriété C1 de type entier. Il est public. */
C2 : Tableau[10] De Booleen;
/* Definition de la propriété C2 de type tableau de 10 booléens. Il est public. */
Procedure M1();
/* Définition de la méthode M1. Elle est publique. */
Fonction F1(P1 : Entier) Retourner Caractere;
/* Définition de la méthode F1. Elle est publique. */
Operateur +(P1 : Entier);
/* Définition de l'addition. Elle est publique. */
Constructeur A(P1 : Entier);
/* Définition d'un constructeur. Il est publique. */
Protege :
C3 : Entier;
/* Définition de la propriété C4 de type entier. Il est public. */
C4 : Tableau[10] De Booleen;
/* Définition de la propriété C4 de type tableau de 10 booléens. Il est public. */
Procedure M2();
/* Définition de la méthode M2. Elle est protégée. */
Fonction F2(P1 : Entier) Retourner Caractere;
/* Définition de la méthode F2. Elle est protégée. */
Operateur -(P1 : Entier);
/* Définition de la soustraction. Elle est protégée. */
Constructeur A(P1 : Reel);
/* Définition d'un constructeur. Il est protégé. */
Prive :
C5 : Entier;
/* Définition de la propriété C5 de type entier. Il est prive. */
C6 : Tableau[10] De Booleen;
/* Définition de la propriété C6 de type tableau de 10 booléens. Il est prive. */
Procedure M3();
/* Définition de la méthode M2. Elle est privée. */
Fonction F3(P1 : Entier) Retourner Caractere;
/* Définition de la méthode F2. Elle est privée. */
Operateur *(P1 : Entier);
/* Définition de la multiplication. Elle est privée. */
Constructeur A(P1 : Date);
/* Définition d'un constructeur. Il est privé. */
Fin Type
Type B
/****/
C1 : Entier;
/* Définition de la propriété C1 de type entier. Il est public. */
C2 : Tableau[10] De Booleen;
/* Définition de la propriété C2 de type tableau de 10 booléens. */
Allouer() Retourner B;
/* Définition de l'allocation d'un objet de type B. */
Liberer();
/* Définition de la désallocation d'un objet de type B. */
Fin Type
Interface C
/*********/
Protege :
Procedure M1 (P1 : Caractere, P2 : Date);
Fonction F1 (P1 : ListeDe A) Retourner Nul Ou Booleen;
Fin Interface
Type D Implemente C
/*****************/
/* Le type 'D' implemente l'interface 'C'. */
Protege :
Procedure M1 (P1 : Caractere, P2 : Date);
Fonction F1 (P1 : ListeDe A) Retourner Nul Ou Booleen;
...
Fin Type
Type E Implemente C
/*****************/
/* Le type 'E' implemente l'interface 'C'. */
Protege :
Procedure M1 (P1 : Caractere, P2 : Date);
Fonction F1 (P1 : ListeDe A) Retourner Nul Ou Booleen;
...
Fin Type
Type P(P1 : Constante, P2 : Enumere, P3 : Type)
/*********************************************/
/* Le type P est paramétré par une constante entière, un énuméré et un type qui ne peut être nul. */
...
Fin Type
Type ListeDeA = ListeDe A;
/************************/
/* Définition d'un type correspondant à une liste de A. */
Type EntierNaturel = Entier Contrainte Objet >= 0;
/************************************************/
/* Définition d'un type correspondant aux entiers naturels. */
Variable
/******/
V1 : Nul Ou P(10, Booleen, Entier);
/* Déclaration d'une variable du type P qui est paramétré. */
V2 : P;
/* Déclaration d'une variable du type P qui est conserve sont aspect générique. */
Principal
/*******/
V1=P(10,Booleen,Entier);
/* Création d'un objet de P. */
Fin Principal
ListeDe pour définir une liste. ReferenceDe pour définir une référence. Selon pour définir une partie polymorphique d'un type. Contrainte pour poser une contrainte sur un type de base.
Interface pour définir une interface.
Metier pour définir un type métier.
| - | - | - | - | - | - | - | - | - |