Modelo para arvore

/** 
     * Com esse método, o Java quem é o objeto que está num determinado índice 
     * do pai. Cada nó de uma árvore pode ser encarado como uma lista. Sendo o 
     * pai a lista e o índice um dos filhos. 
     *  
     * @param parent 
     *            É o pai, que tem os filhos. 
     *            Índice do filho. 
     */  
    public Object getChild(Object parent, int index) {  
        if (parent == raiz) // É o nó principal?  
            return diretorios.get(index);
  
        if (parent instanceof Diretorio)
            return ((Diretorio) parent).getFilhos().get(index);  

        if (parent instanceof DiretorioFilho)
            return ((DiretorioFilho) parent).getNetos().get(index);  

        if (parent instanceof DiretorioNeto)
            return ((DiretorioNeto) parent).getFilhosNetos().get(index);  

        if (parent instanceof DiretorioFilhoNeto)
            return ((DiretorioFilhoNeto) parent).getFixos().get(index);  
  
        // Se o pai não é nenhum desses. Melhor dar erro.  
        throw new IllegalArgumentException("Invalid parent class"  
                + parent.getClass().getSimpleName());  
    }  
  
    /** 
     * Retornamos quantos filhos um pai tem. No caso de um livro, é a contagem 
     * de autores. No caso da lista de livros, é a quantidade de livros. 
     */  
    public int getChildCount(Object parent) {  
        if (parent == raiz) // É o nó principal?  
            return diretorios.size();
  
        if (parent instanceof Diretorio)
            return ((Diretorio) parent).getFilhos().size();

        if (parent instanceof DiretorioFilho)
            return ((DiretorioFilho) parent).getNetos().size();

        if (parent instanceof DiretorioNeto)
            return ((DiretorioNeto) parent).getFilhosNetos().size();

        if (parent instanceof DiretorioFilhoNeto)
            return ((DiretorioFilhoNeto) parent).getFixos().size();
  
        // Se o pai não é nenhum desses. Melhor dar erro.  
        throw new IllegalArgumentException("Invalid parent class"  
                + parent.getClass().getSimpleName());  
    }

- biblioteca1
       -Estante11
             -Prateleira111
                   *Livro1
                    *Livro2
              -Prateleira112
                    *Livro3
        -Estante12
                +Prateleira121
                +Prateleira122

   +biblioteca2
   +biblioteca3

private String raiz = "Biblioteca";

  //supondo que são tres tipos de objetos finais que o modelo irá exibir: são eles
  private List<Livro> livros;  
  private List<Caderno> cadernos;   
  private List<Agenda> agendas;  

 //agora o miolo aqui não sei, mas de acordo com o trecho de código que vc me mostrou ficaria algo do tipo assim:
  
public Object getChild(Object parent, int index) {  
        if (parent == raiz) // É o nó principal?  
            return diretorios.get(index);
  
        if (parent instanceof Estante)
            return ((Estante) parent).getFilhos().get(index);  

        if (parent instanceof Prateleira)
            return ((Prateleira) parent).getNetos().get(index);  

       /* Este resto não precisa neste exemplo 
        if (parent instanceof DiretorioNeto)
            return ((DiretorioNeto) parent).getFilhosNetos().get(index);  

        if (parent instanceof DiretorioFilhoNeto)
            return ((DiretorioFilhoNeto) parent).getFixos().get(index);  
  
        */

        // Se o pai não é nenhum desses. Melhor dar erro.  
        throw new IllegalArgumentException("Invalid parent class"  
                + parent.getClass().getSimpleName());  
    }  
  
 
/* E esses métodos? getFilhos ? getNetos ? getFilhosNetos? De onde surgiram? Da minha própria classe?
  Se for então o correto deveria ser:
     ((Estante) parente).getPrateleiras()
     
*/

    public int getChildCount(Object parent) {  
        if (parent == raiz) // É o nó principal?  
            return diretorios.size();
  
        if (parent instanceof Estante)
            return ((Estante) parent).getFilhos().size();

        if (parent instanceof Prateleira)
            return ((Prateleira) parent).getNetos().size();


       /* Nao precisa [...]
        if (parent instanceof DiretorioNeto)
            return ((DiretorioNeto) parent).getFilhosNetos().size();

        if (parent instanceof DiretorioFilhoNeto)
            return ((DiretorioFilhoNeto) parent).getFixos().size();
       */

        throw new IllegalArgumentException("Invalid parent class"  
                + parent.getClass().getSimpleName());  
    }  

    public int getIndexOfChild(Object parent, Object child) {
		if (parent == raiz)
			return livros.indexOf(child);
		if (parent instanceof Estante)
			return ((Estante) parent).getPrateleiras().indexOf(child);
		if (parent instanceof Prateleira)
                        //isto não faz sentida caso possa ter livros, agendas e cadernos...
                        //então estou pensando que cada tipo de "filho" deve estar em um diretório que identifca seu tipo?
                        //exemplo: todos os livros ficam dentro de outro dir "Livros" e o mesmo para "Cadernos" e "Agendas" ?
			return ((Prateleira) parent).getLivros().indexOf(child);
		return 0;
	}


	public Object getRoot() {
		return raiz;
	}


	public boolean isLeaf(Object node) {
		return node instanceof Autor;
                //quem que ficaria aqui? livro caderno ou agenda?
	}

	public void valueForPathChanged(TreePath path, Object newValue) {
		// Com esse método, a tree avisa que um objeto mudou.
		// Editem se quiserem que um nó seja editável
	}

	// Esses dois métodos abaixo poderiam ir para classe abstrata
	public void removeTreeModelListener(TreeModelListener l) {
		listeners.remove(l);
	}

	public void addTreeModelListener(TreeModelListener l) {
		listeners.add(l);
	}

       /*aqui nao deveria ter métodos do tipo:
           addBiblioteca(String nome){}
           addEstante(String nome,Biblioteca tal){}
           addPrateleira(String nome,Estante tal){}
           addLivro(Livro l);
           addCaderno(Caderno n);
           addAgenda(Agenda l);
       */