Métaclasse
Pour les articles homonymes, voir métaclasse (homonymie).
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.
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 défaut
# peut servir pour faire des bouchons par exemple ou restreindre la création
# ou l'accès à des attributs…
class MyMetaClasse(type):
"""une Metaclasse avec intercepteur : dès qu'on fait Maclasse.UnAttribut,
name = UnAttribut, on renvoie une valeur par défaut
"""
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 définition 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. 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;
En JavaScript, il suffit de retourner une classe depuis le constructeur.
class ModelClass {
constructor(name) {
return class ModelInstance {
constructor() {
this.name = name;
}
};
}
}
const MyModel = new ModelClass('myModel')
const instance = new MyModel(); // instance.name === 'myModel'
