Metaclasă

În programarea orientată obiect , o metaclasă este o clasă ale cărei instanțe sunt în sine clase. Acest concept este strâns legat de conceptul de reflecție (reflecție), care se aplică acelor instrumente conceptuale care vă permit să reprezentați, în cadrul unui program, informații despre părțile constitutive ale programului (de obicei clase și obiecte).

Conceptul de metaclasă este utilizat în principal la nivel teoretic (apare, de exemplu, în definiția formală a semanticii limbajului de modelare unificat ), dar găsește și aplicații directe în diferite limbaje de programare . În Java , de exemplu, toate clasele sunt considerate conceptual instanțe ale unei singure Class metaclasă, în type Python este o metaclasă.

Piton

În Python, o metaclasă este definită în cea mai mare parte ca o subclasă de tip.

 clasa AttributeInitType ( tip ):
     def __call__ ( self , * args , ** kwargs ):
         "" "Creați o nouă instanță." ""
 
         # Mai întâi, creați obiectul în modul implicit normal.
         obj = tip . __suna__ ( auto , * argumente )
 
         # În plus, setați atribute pentru noul obiect.
         pentru nume , valoare în kwargs . articole ():
             setattr ( obj , nume , valoare )
 
         # Returnează noul obiect.
         întoarce obiect

Această metaclasă suprascrie doar crearea obiectului. Toate celelalte aspecte ale clasei și comportamentului obiectului sunt încă tratate în funcție de tip. Acum, clasa Mașină poate fi rescrisă pentru a utiliza această metaclasă. În Python 2 acest lucru se realizează prin atribuirea __metaclass__ în definiția clasei în timp ce în Python 3 dând argumentul clasei metaclasă = M )

 clasa Mașină ( obiect ):
     __metaclass__ = AttributeInitType
     __slots__ = [ 'make' , 'model' , 'year' , 'color' ]
 
     @proprietate
     descriere def ( auto ):
         "" "Returnează o descriere a acestei mașini." ""
         returnează „ % s % s % s % s " % ( auto . culoare , auto . an , auto . marca , auto . model )

Obiectele Car pot fi instanțiate astfel:

 masini = [
     Mașină ( marca = 'Toyota' , model = 'Prius' , an = 2005 , culoare = 'verde' ),
     Mașină ( marca = 'Ford' , model = 'Prefect' , an = 1979 , culoare = 'albastru' )]

Un alt exemplu de Metaclasă în Python:

 clasa Vrajă ( tip ):
    def __new__ ( cls , classname , super , classdict ):
        def pph ( ore ): return lambda self : self . pay_per_hour * ore

        classdict [ 'pay_per_hour' ] = 12
        classdict [ 'day_salary' ] = pph ( 8 )
        classdict [ 'week_salary' ] = pph ( 8 * 5 )
        classdict [ 'year_salary' ] = pph ( 8 * 5 * 4 * 12 )
        classdict [ 'month_salary' ] = pph ( 8 * 5 * 4 )
        tip retur . __new__ ( cls , classname , super , classdict )

Person (metaclass = ortografică):
    def __init__ (auto, nume, prenume, bday):
        sinele . nume = nume
        sinele . prenume = prenume
        sinele . bday = bday

    def get_name ( auto ):
        a reveni auto. _Nume
    def get_lastname ( self ):
        a reveni auto. _nume
    def get_bday ( self ):
        a reveni auto. _ziua
    def __repr__ ( auto ):
        returnează „nume: {0} , prenume: {1} , bday: {2} ” . format ( self . nume , self . prenume , self . bday )
      
dacă __name__ == "__main__" :
    persona = Person ( "Mario" , "Rossi" , "23 noiembrie 65" )

Limbi care acceptă metaclasele

Lisp comun , prin CLOS
Delphi și alte versiuni ale Object Pascal afectate de acesta
Macabru
Obiectiv-C
Piton
Perl , prin metaclasa pragmatică, precum și folosind Moose
Rubin
Convorbire scurtă

Elemente conexe