Métaclasse

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

En programmation, une métaclasse est une classe dont les instances sont des classes. Autrement dit, une métaclasse est la classe d'une classe.

Généralités[modifier | modifier le code]

En programmation orientée objet, une classe est une sorte de module qui permet de créer un sous-ensemble d'objets. La classe décrit comment se comportent ses objets, fournit leur interface et compose la structure de leur état. La classe permet de créer de nouveaux objets au moyen d'un mécanisme appelé instanciation. Ce mécanisme peut se décomposer en deux opérations  :

  • allocation d'un espace mémoire pour le nouvel objet (opération alloc()),
  • initialisation du nouvel objet (lancement du constructeur).

Dans des environnements de programmation réflexifs, les classes peuvent être vues comme des objets à part entière créés au moyen du mécanisme d'instanciation (alloc(); init()). Dans ce cas, toutes les classes peuvent être vues comme des instances créées à la base à partir d'une même classe.

Une classe dont les instances sont des classes se nomme métaclasse (notez que la définition est récursive). Puisqu'une métaclasse est une classe, elle définit elle aussi le comportement et la structure de l'état de ses instances. En créant une nouvelle métaclasse, on va donc intervenir sur la manière avec laquelle les classes sont créées et donc intervenir sur une partie du langage lui-même. Grâce à un mécanisme comme celui-ci, le développeur peut ajouter de nouvelles fonctionnalités au langage, comme la possibilité de tracer les appels de méthodes, la possibilité de créer des singletons, la sérialisation d'objets au format XML, etc.

Les métaclasses dans les langages[modifier | modifier le code]

Les langages suivants permettent de définir des métaclasses :

La classe java.lang.Class est une métaclasse dans le langage Java.

Exemple simple[modifier | modifier le code]

# interception de tous les Attributs pour retourner une valeur par defaut
# peut servir pour faire des bouchons par exemple ou restreindre la creation
#ou l'accès à des attributs etc
 
class MyMetaClasse(type):
    """une Metaclasse avec intercepteur : dès qu'on fait Maclasse.UnAttribut,  
     name =  UnAttribut, on renvoie une valeur par defaut
    """
    def __getattr__(MaClasse, name):
        return 128
 
#Déclarer une classe, c'est instancier une métaclasse.
class MaClasse:
    __metaclass__ = MyMetaClasse   #Lien avec la metaclasse
    #Ensuite la definition de la classe continue (....)
 
print MaClasse.x, MaClasse.y
#resultats
128 128

Autre exemple[modifier | modifier le code]

Sous Python, la métaclasse de base est nommée type. Quel que soit l'objet manipulé, l'exécution de monObjet.__class__.__class__ retourne type. La création d'une nouvelle métaclasse se fait en spécialisant type. Les opérations alloc() et init() sont respectivement représentées par les méthodes __new__() et __init__(). __new__() est une méthode de classe qui prend quatre paramètres : la métaclasse elle-même, le nom de la classe instanciée, ses superclasses et un dictionnaire contenant l'ensemble de ses méthodes et attributs. __init__() est une méthode d'instance. Ses paramètres sont les mêmes que ceux de __new__() hormis le premier qui représente la classe instanciée dans le cas de __init__().

L'exemple ci-dessous montre un exemple d'utilisation d'une métaclasse en Python. Il s'agit d'une métaclasse qui permet de tracer l'appel de méthode.

from types import FunctionType
class Tracer(type):
    def __new__(metacls, name, bases, dct):
        # définition d'une fonction wrapper pour les méthodes
        def _wrapper(method):
            # création d'une fonction permettant tracer une méthode
            def _trace(self, *args, **kwargs):
                print "(call %s with *%s **%s)" % (method.__name__, str(args), kwargs)
                return method(self, *args, **kwargs)
            # idiome: faire passer une fonction pour une autre
            _trace.__name__ = method.__name__
            _trace.__doc__  = method.__doc__
            _trace.__dict__.update(method.__dict__)
            return _trace
 
        # remplacement de toutes les méthodes par leur équivalent tracé
        newDct = {}
        for name, slot in dct.iteritems():
            if type(slot) is FunctionType:
                newDct[name] = _wrapper(slot)
            else:
                newDct[name] = slot
        # appel au constructeur de la super classe (type)
        return type.__new__(metacls, name, bases, newDct)

Le principe de la métaclasse Tracer consiste à transformer toutes les méthodes de ses instances, de telle sorte qu'elles affichent un message avant de continuer leur exécution. La fonction _wrapper() qui se trouve dans le constructeur de la métaclasse est un décorateur, c'est-à-dire qu'elle prend en entrée une fonction et renvoie en sortie cette fonction avec un comportement modifié. Il faut savoir que dans le paramètre dct du constructeur, ce qui doit représenter des méthodes est encore à l'état de fonction.

Voici un exemple montrant comment utiliser la métaclasse.

class A(object):
    # création de la liaison entre la classe et la métaclasse
    __metaclass__ = Tracer
 
    def __init__(self):
        self.a = 1
 
    def get(self): return self.a
 
 
>>> a = A()
(call __init__ with *() **{})
>>> a.get()
(call get with *() **{})
1

Voici un exemple en Delphi.

  // Voici comment est défini le type TComponentClass dans la VCL de delphi :
  type
    TComponentClass = class of TComponent;

Voir aussi[modifier | modifier le code]