Métaclasse
Un article de Wikipédia, l'encyclopédie libre.
Une métaclasse est une classe dont les instances sont des classes. Autrement dit, une métaclasse est la classe d'une classe.
Sommaire |
[modifier] Généralités
En programmation orientée objet, une classe est une sorte de moule 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.
[modifier] Les métaclasses dans les langages
Les langages suivants permettent de définir des métaclasses :
La classe java.lang.Class est une métaclasse dans le langage Java.
[modifier] Exemple simple
# 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'acces à des attributs etc
class MyMetaClasse(type):
"""une Metaclasse avec intercepteur : des qu'on fait Maclasse.UnAttribut,
name = UnAttribut, on renvoie une valeur par defaut
"""
def __getattr__(laClasse, name):
return 128
#Declarer 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
[modifier] Autre exemple
Sous Python, la métaclasse de base est nommée type. Quelque 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
(call __new__)
>>> a = A()
(call __init__)
>>> a.get()
(call get)
1
Voici un exemple en Delphi.
// Voici comment est définit le type TComponentClass dans la VCL de delphi : type TComponentClass=class of TComponent;
