Un livre de Wikibooks.

Sections 1 Tutorial : Lisaac pour le programmeur objet standard (Java/C++ par exemple) 1.1 Introduction 1.2 Chapitre 1 : Les notions basiques 1.3 Chapitre 2 : Utilisation avancée 1.4 Chapitre 3 : Les design-patterns classiques

[modifier] Tutorial : Lisaac pour le programmeur objet standard (Java/C++ par exemple)

[modifier] Introduction

Ce document a pour but de faire découvrir la programmation par prototype en Lisaac à quelqu'un ayant l'habitude des langages à classes. Ce n'est pas un document de référence mais un tutorial didactique. Ce n'est pas non plus un document expliquant les principes fondamentaux et les caractéristiques de la programmation orientée prototype.

Le plan est divisé en deux chapitres, le premier présente les notions les plus standards de la programmation objet, le deuxième présente des techniques moins connues voir novatrices. Après cela dépend évidement de l'expérience de chacun des lecteurs en la matière.

Le style narratif du document sera sous forme de question/réponse comme pour une FAQ (Foire aux questions). Mais contrairement aux FAQ vous devez lire toutes les parties dans l'ordre. Notez aussi que le plan utilise le vocable de la programmation objet à classe et le contenu introduit celui de la programmation objet à prototype utilisé dans Lisaac.

Si jamais quelque chose ne vous parait pas clair, ou si jamais vous avez une interrogation sur le pourquoi ou les avantages de Lisaac par rapport à ce que vous êtes habitués n'hesitez pas à modifier directement le document et à rajouter votre question à l'endroit le plus approprié. Néanmoins le document ne doit pas devenir un forum de discussion, vous pouvez utiliser la page dédiée pour cela.

Attention : Ce document utilise la syntaxe 0.2 du langage, et le compilateur de cette version n'a pas encore été distribué. Il y a donc quelques différences avec le compilateur que vous pouvez actuelement télécharger. Vous en serez à chaque fois prévenu.

[modifier] Chapitre 1 : Les notions basiques

• Déclarer une classe
• Hériter d'une autre classe
• Déclarer des attributs ou des méthodes
• Faire un main "hello world"
• Instancier des objets
• Déclarer des variables locales
• Le traitement des types de base
• Les conditionnelles et les boucles
• Lisaac/Block
• Lisaac/Keyword slot
• Les expression boolléennes
• Les templates
• Les conteneurs Tableau et Liste
• La gestion des erreurs
• Retour sur les points difficiles
• Lisaac/Référence rapide

AFAIRE : rajouter kkpart qu'il faut dire (-2) pour les int négatif

[modifier] Chapitre 2 : Utilisation avancée

• Transformer une méthode en attribut (ou l'inverse)
• Définir des mots clés dans la liste de paramètre
• Paramètres et valeurs de retour composés
• Utiliser la programmation par contrat
• Déclaration fine des droits d'un prototype
• Créer ses propres structures de contrôle
• Héritage dynamique

[modifier] Chapitre 3 : Les design-patterns classiques

A FAIRE : coder et enlever ceux qui ne sont pas réutilisable directement par du code. De plus certain sont triviaux comme Singleton et Prototype, d'autre sont d'un intéret limité par les mécanismes comme l'héritage partagé pour le Poids-mouche.

• Fabrique Abstraite (Abstract Factory)
• Monteur (Builder)
• Fabrication (Factory Method)
• Prototype (Prototype)
• Singleton (Singleton)
• Adaptateur (Adapter)
• Pont (Bridge)
• Objet composite (Composite)
• Décorateur (Decorator)
• Façade (Facade)
• Poids-mouche ou poids-plume (Flyweight)
• Proxy (Proxy)
• Chaîne de responsabilité (Chain of responsability)
• Commande (Command)
• Interpréteur (Interpreter)
• Itérateur (Iterator)
• Médiateur (Mediator)
• Memento (Memento)
• Observateur (Observer)
• État (State)
• Stratégie (Strategy)
• Patron de méthode (Template Method)
• Visiteur (Visitor)