Lors qu'une classe hérite d'une autre, tout l'interêt est bien évidemment de ne pas réimplémenter les methodes de la classe mère. En effet, en l'absence d'une méthode portant le nom demandé, la méthode de la classe mère est appelée, transmettant ainsi tous les arguments. Eh bien ce qui est dommage, c'est que ce n'est pas le cas du constructeur... :\

En effet, si une classe mère prend un argument en paramètre, et qu'une classe fille hérite de cette dernière sans implémenter de constructeur, les paramètres passés au constructeur de la classe fille ne seront pas transmis.

La preuve par l'exemple: j'utilise actuellement un ensemble de managers gérant chacun des objets (Contacts, Articles, etc...) dont les classes implémentent toutes la même interface. Le but est donc de créer un manager "de base" (non instanciable) qui factorise les comportements communs... Chaque manager est lié à un contexte dans l'application, qui est passé en paramètre au constructeur du manager:
/* == Classes utilisées
interface Item
class Contact implements Item
class Context
*/
// Classe mère
class BaseManager {
   private var _context:Context;
   private var _selectedItem:Item;
   // Le constructeur prend un paramètre
   private function BaseManager(ctx : Context) {
      _context = ctx;
   }
   public function getContext() : Context {
      return _context;
   }
   public function getSelectedItem() : Item {
      return _selectedItem;
   }
   private /*protected*/ function setSelectedItem(i : Item) {
      if (i != _selectedItem) {
         _selectedItem = i;
         dispatchEvent({type:"selectionChanged", selected:_selectedItem});
      }
   }
}
class ContactManager
   extends BaseManager {
   // Force le typage à 'Contact'
   private function setSelectedItem(c : Contact) {
      super.setSelectedItem(c);
   }
   public function getSelectedContact() : Contact {
      return Contact(getSelectedItem());
   }
}
// Création du contexte
var ctx:Context = new Context("mainApp");
// Création du ContactManager
var contactManager:ContactManager = new ContactManager(ctx);
// Affichage du contexte
trace(contactManager.getContext()); // undefined Ceci est trés certainement du à la conversion en AS1. En effet, en AS1, déclarer une classe revient à déclarer son constructeur, et donc a relayer "manuellement" les paramètres du constructeur si besoin. Le "compilo" AS2 du coup crée automatiquement un constructeur dont le code est:function ContactManager() {
   super();
} alors que dans mon cas, il faut que je crée le constructeur moi-même:function ContactManager(c : Context) {
   super(c);
}
C'est peut-être déjà connu de beaucoup, mais moi j'ai cherché un p'tit moment quand-même... Bref, cela revient encore et toujours au problème d'appeler le constructeur d'une classe mère avec un nombre indéfini d'arguments (l'idéal étant avec apply)... :\