Ereditarietà runtime
L'ereditarietà del runtime è, come dici tu, la costruzione dell'albero gerarchico genitore / figlio in fase di runtime. Tuttavia, sembri insicuro su cosa possa significare o sembrare. In linguaggi come Java, devi fondamentalmente definire la gerarchia delle classi al momento della compilazione. Ciò significa che il tuo codice deve avere questa struttura generale.
class NewClass {
//Some methods and stuff
}
class ChildClass extends NewClass {
//Some methods and stuff
}
Non è realmente possibile (leggi: conveniente), al di fuori di trucchi molto arcani come modificare codice byte al volo, per definire una nuova classe. A differenza di Python, dove codice simile può essere fatto in questo modo:
class NewClass():
pass
class ChildClass(NewClass):
pass
O nell'interprete al volo:
>>> NewClass()
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
NewClass()
NameError: name 'NewClass' is not defined
>>> class NewClass():
pass
>>> NewClass()
<__main__.NewClass object at 0x02AC6970>
>>> ChildClass()
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
ChildClass()
NameError: name 'ChildClass' is not defined
>>> class ChildClass(NewClass):
pass
>>> nc = NewClass()
>>> cc = ChildClass()
>>> nc
<__main__.NewClass object at 0x02E9B190>
>>> cc
<__main__.ChildClass object at 0x02E9B150>
Qui ho creato classi con lo stesso nome di Java, ma l'ho fatto al volo in un interprete. Nessun limite di tempo compilato. Ma aspetta, c'è di più! Puoi creare una nuova classe, al volo, con solo tre cose: un nome, una tupla dell'ordine di ereditarietà e un dizionario dello spazio dei nomi (o un oggetto simile al dizionario).
>>> NewClass
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
NewClass
NameError: name 'NewClass' is not defined
>>> NewClass = type("NewClass", (), {})
>>> NewClass()
<__main__.NewClass object at 0x02AA6970>
>>> ChildClass
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
ChildClass
NameError: name 'ChildClass' is not defined
>>> ChildClass = type("ChildClass", (NewClass,), {})
>>> ChildClass()
<__main__.ChildClass object at 0x02EBB190>
>>>
Si noti come in questa lingua è possibile creare una nuova classe, eventualmente utilizzando variabili per il nome, l'ordine di ereditarietà e lo spazio dei nomi. Senza nemmeno usare la parola chiave della classe . Che è l'eredità di runtime.
Come nota conclusiva per questa sezione, non voglio dare l'impressione che questo sia in qualche modo l'unico modo per farlo. L'ereditarietà basata sul prototipo come implementata in JavaScript è un approccio abbastanza diverso da questo, e supporta cose affascinanti e utili (ma anche molto pericolose) come riassegnare la classe genitore su un oggetto esistente.
Che tipo di lingue lo supportano
Non penso che ci sia davvero un buon modo per classificarlo senza essere circolari e dicendo "Runtime Inheritance è supportato nelle lingue Inheritable di runtime". A seconda di chi parli, sono sicuro che puoi trovare questo tipo di funzionalità in qualsiasi paradigma (funzionale, procedurale, orientato agli oggetti, ecc.). In realtà è solo un'altra caratteristica linguistica, anche se potente.
Qualche situazione in cui potrebbe rivelarsi utile?
Assolutamente . Le opzioni includono, ma non sono limitate a queste:
- Implementazione di un interprete in cui il programmatore può definire i tipi
- Creazione di tipi di dati appropriati durante la lettura di dati, ad esempio una chiamata di procedura remota di rete o la creazione di tipi di nodo DOM basati su uno schema XML
- Qualsiasi tipo di software di simulazione in cui l'utente può creare la propria categoria di oggetti e quindi crearne alcuni.
- Creazione di una nuova classe per rappresentare i typeclass in un parser di espressioni regolari