Разветвленные деревья

import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
 
public class Tree implements TreeModel{
    private Node root;
    public Tree(Node root) {
        super();
        this.root = root;
    }
    public void add(Node parent, Node son) throws Exception {
        parent.add(son);
    }   
    public void remove(Node node) {
        if(node == root) root = null;
        node.remove();
    }   
    public Node createNode(Node parent, Object data) {
        return parent.createNode(data);
    }   
    public void setData(Node node, Object data) {
        node.setData(data);
    }
    @Override
    public Object getChild(Object object, int index) {
        return ((Node)object).getChild(index);
    }
    @Override
    public int getChildCount(Object object) {
        return ((Node)object).getChildCount();
    }
    @Override
    public int getIndexOfChild(Object parent, Object child) {
        Node p = (Node) parent, ch = (Node) child;
        return p.getIndexOfChild(ch);
    }
    @Override
    public Object getRoot() {
        return root;
    }
    @Override
    public boolean isLeaf(Object object) {
        return ((Node)object).isLeaf();
    }
}

import java.util.Iterator;
public abstract class Node implements Iterable<Node>, Comparable<Node>{
    private Object data;
    private Node parent;
    public abstract Iterator<Node> iterator();
    public void add(Node son) throws Exception {
        for (Node node : this) {
            if (node.getData().equals(son.getData())) {
                throw new Exception(son.toString() + " already exist!");
            }
        } basicAdd(son);
    }
    protected abstract void basicAdd(Node son);
    public void remove() {
        if(parent == null) return;
        for(Iterator<Node> iter = parent.iterator();iter.hasNext();){
            Node node = iter.next();
            if(node == this) iter.remove();
        }
    }
    public abstract Node createNode(Object data);
    protected void setData(Object data) {
        this.data = data;
    }
    protected Node getParent() {
        return parent;
    }
    protected void setParent(Node parent) {
        this.parent = parent;
    }
    protected Object getData() {
        return data;
    }
    @Override
    public String toString() {
        return data.toString();
    }
    public Object getChild(int index) {
        int i = 0;
        for (Node node : this) {
            if (i == index) {
                return node;
            } i++;
        } return null;
    }
    public int getChildCount() {
        int i = 0;
        try {
            for (@SuppressWarnings("unused") Node node : this) i++;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return i;
    }
    public int getIndexOfChild(Node ch) {
        int i = 0;
        for (Node node : this) {
            if (node == ch) {
                return i;
            } i++;
        } return -1;
    }
    public boolean isLeaf() {
        return getChildCount() == 0;
    }
    public int compareTo(Node node) {
        return data.toString().compareTo(node.data.toString());
    }
}

import java.util.Iterator;
public abstract class ArrayNode extends Node {
    protected int currentIndex = 0;
        protected int countElem = 0;
    private int startSize = 2;
    private int prevSize = 1;
    protected int fibo(){
        int fibo = prevSize + startSize;
        prevSize = startSize; startSize = fibo;
        return fibo;
    }
    protected ArrayNode[] arraySon = new ArrayNode[fibo()];
    private class ArrayNodeIterator implements Iterator<Node>{
        int index = 0;
        @Override
        public boolean hasNext() {
            return index < arraySon.length;//false;
        }
        @Override
        public Node next() {
            ++index;
            return arraySon[index];//null;
        }
    }
    public ArrayNodeIterator iterator(){
        return null;
    }
}
public class ArrayNodeLast extends ArrayNode {
    public ArrayNodeLast(Object data) {
        setData(data);
        setParent(this);
    }
    @Override
    protected void basicAdd(Node son) {
        ArrayNodeLast newSon = (ArrayNodeLast) son;
        if(arraySon[0] == null){
            arraySon[0] = newSon;
            return;
        }
        arraySon[currentIndex] = newSon;
        currentIndex++; ++countElem;
    }
    @Override
    public Node createNode(Object data) {
        return new ArrayNodeLast(data);
    }
}

public class Node {
 
  Node[] children;
 
  /*
    Не обязательно делать внутренним классом, но иначе придётся самому передавать ссылку на массив в конструкторе.
  */ 
  class MyIter implements Iterator<Node> {
 
    private int index = 0;
 
     public boolean hasNext() {
       return (index < children.length);
     }
 
     public Node next() {
       return children[index++];
     }     
  }
 
  public Iterator iterator() {
    return new MyIter();
  }
 
}

import java.util.Iterator;
 
public abstract class ArrayNode extends Node {
 
    protected ArrayNode[] arraySon;
 
    private class ArrayNodeIterator implements Iterator<Node>{
 
        private int index = 0;
 
        public boolean hasNext() {
            return (index < arraySon.length);
        }
 
        public Node next() {
            return arraySon[index++];
        }  
 
    }
 
    public ArrayNodeIterator iterator(){
        return new ArrayNodeIterator();
    }
}

import java.util.Arrays;
 
public class ArrayNodeFirst extends ArrayNode {
    
    public ArrayNodeFirst(Object data) {
        setData(data);
        setParent(this);
    }
 
    @Override
    protected void basicAdd(Node son) {
        int newSize = arraySon.length + 1;
        ArrayNodeFirst[] arr = new ArrayNodeFirst[newSize];
        arr = (ArrayNodeFirst[]) Arrays.copyOf(arraySon, newSize);
        arr[newSize - 1] = (ArrayNodeFirst) son;
        arraySon = arr;
    }
 
    @Override
    public Node createNode(Object data) {
        return new ArrayNodeFirst(data);
    }
 
}

public boolean hasNext() {
            if(arraySon[index] != null)
                return (index < arraySon.length);
            else return false;
        }