Bonjour à toutes et à tous,

J'ai écrit une classe ArrayList ( sur le schéma de la classe du même nom en java ) pour diverse utilisation.
J'utilise celle-ci dans une autre de mes classes. Mais à l'éxécution de la seconde, le debuggeur me signal une erreur : Uncaught TypeError: Cannot call method 'add' of undefined

L'erreur est déclaré dans la fonction addSousOnglet de la classe Onglet.

voici le code :

/* ArrayList -> tableau dynamique */
function ArrayList(){
	ArrayList.prototype.add = function(e){ 
		this.array.push(e); 
		return true; 
	}
	ArrayList.prototype.add = function(i,e){ 
		if(!this.isEmpty()){
			if(i!=0){
				var fin1 = i-1;
				var fin2 = this.size()-1;
				var part1 = this.array.slice(0,fin1);
				var part2 = this.array.slice(i,fin2);
				this.clear();
				this.addAll(part1);
				this.add(e);
				this.addAll(part2);
			} else {
				this.add(e);
			}
		}
	}
	ArrayList.prototype.addAll = function(e){
		this.array.push(e);
		return true;
	}
	ArrayList.prototype.addAll = function(i,e){
		this.add(i,e);
		return true;
	}
	ArrayList.prototype.clear = function(){
		this.array = new Array;
	}
	ArrayList.prototype.get = function(i){
		return this.array[i];
	}
	ArrayList.prototype.isEmpty = function(){ 
		if(this.size() == 0){
			return true; 
		}
		return false;
	}
	ArrayList.prototype.remove = function(i){
		if(!this.isEmpty()){
			if(i!=0){
				var fin = this.size()-1;
				var part1 = this.array.slice(0,i);
				part1.pop();i++;
				var tab = part1.concat(this.array.slice(i,fin));
				this.clear();
				this.addAll(tab);
			} else {
				this.array.pop();
			}
		}
	}
	ArrayList.prototype.set = function(i,e){
		this.array[i] = e;
	}
	ArrayList.prototype.size = function(){ 
		return this.array.length; 
	}
	var array = new Array;
}
/* Methodes
openAll() affiche tous les sous-onglets
closeAll() cache tous les sous-onglets
chronoCloseAll() cache tous les sous-onglets après un chrono
addSousOnglet() ajoute un sous-onglet
getOnglet() retourne l'onglet courant format objet
----getName() retourne le nom de l'onglet
----getSousOnglet(i) retourne le sous-onglet i format objet
--------getValue() retourne la valeur du sous-onglet i
--------setValue(e) modifie la valeur du sous-onglet i
*/
function Onglet( name ){
	var arrayList = new ArrayList();
	var name = name;
	Onglet.prototype.openAll = function(){
		for(i=0;i<this.arrayList.size();i++){
			var name = this.arrayList.get(i);
			document.getElementsByName( name )[0].style.display = '';
		}
	}
	Onglet.prototype.closeAll = function(){
		for(i=0;i<this.arrayList.size();i++){
			var name = this.arrayList.get(i);
			var sousOnglet = document.getElementsByName( name )[0];
			if( sousOnglet ){ sousOnglet.style.display = 'none'; }
		}
	}
	Onglet.prototype.chronoCloseAll = function(){
		var o = this;
		setTimeout( function(){ o.closeAll() }, 5000);
	}
	Onglet.prototype.addSousOnglet = function(e){
		this.arrayList.add(e);
	}
	Onglet.prototype.getOnglet = function(){
		Onglet.prototype.getName = function(){
			return this.name;
		}
		Onglet.prototype.getSousOnglet = function(i){
			Onglet.prototype.getValue = function(){
				return this.arrayList.get(i);
			}
			Onglet.prototype.setValue = function(e){
				this.arrayList.set(i,e);
				return true;
			}
			return "undefined";
		}
		return "undefined";
	}
}

Edit :
J'ai trouvé le problème. Je vais vous expliquer si vous avez un jour ce problème.
En JavaScript, il semblerait que la surcharge de fonction dans une même classe serait mal géré.
J'ai donc nommé différemment les fonctions qui aurait du être surchargées, comme ceci :

/* Methodes
add(e) ajout un element
addIn(i,e) ajout un element à l'emplacement désigné //A la place de add(i,e)
addAll(e) ajout d'une collection d'element
addAllIn(i,e) ajout d'une collection d'element à l'emplacement désigné //A la place de addAll(i,e)
clear() réinitialise le contenu 
get(i) retourne l'element désigné
isEmpty() retourne un boolean suivant l'etat du tableau
remove(i) supprime l'element désigné
set(i,e) modifie l'element désigné par l'element en paramètre
size() retourne la taille du tableau
*/

Ce n'est pas tout, il apparaissait claire que j'avais un problème dans ma seconde classe : Onglet.
J'avais oublié de déclarer les variables d'instance avant de les alimenter. Je vais illustré mes dire :

function Onglet( name ){
	/* Déclaration des variables d'instances */
	var arrayList, name;
	Onglet.prototype.openAll = function(){[...]}
	Onglet.prototype.closeAll = function(){[...]}
	Onglet.prototype.chronoCloseAll = function(){[...]}
	Onglet.prototype.addSousOnglet = function(e){[...]}
	Onglet.prototype.getName = function(){[...]}
	Onglet.prototype.getValueSousOnglet = function(i){[...]}
	Onglet.prototype.setValueSousOnglet = function(i,e){[...]}
	Onglet.prototype.getNbrOnglet = function(){[...]}
	/* Initialisation des variables d'instances */
	this.arrayList = new ArrayList();
	this.name = name;
}

Pour finir, toujours dans la classe Onglet, j'avais imbriqué des fonctions mais JavaScript ne comprenait pas la hiérarchie de fonction, exemple avec la première version de la classe Onglet (plus haut) :

Onglet.prototype.getOnglet = function(){
	Onglet.prototype.getName = function(){[...]}
	Onglet.prototype.getSousOnglet = function(i){
		Onglet.prototype.getValue = function(){[...]}
		Onglet.prototype.setValue = function(e){[...]}
		return "undefined";
	}
	return "undefined";
}