Вызов main() из вложенного класса

package linkedlist;
 
public class LinkedList {
 
    public interface Linkable {
 
        public Linkable getNext();//возвращает слейдущий элемент списка
 
        public void setNext(Linkable node);//устанавливает сдедующий эемент списка
    }
 
    public LinkedList() {
    }
    Linkable head;
 
    public synchronized Linkable getHead() {
        return head;
    }
 
    public synchronized void insertAtHead(Linkable node) {
        node.setNext(head);
        /**
         * Вставляет узел в начало списка *
         */
        head = node;
    }
 
    /**
     * Вставляет узел в конец списка
     *
     * @param node
     */
    public synchronized void insertAtTail(Linkable node) {
        if (head == null) {
            head = node;
        } else {
            Linkable p, q;
            for (p = head; (q = p.getNext()) != null; p = q) /* пустой цикл */;
            p.setNext(node);
        }
    }
 
    /**
     * Удаляет и возвращает в качестве значения узел, находящийся в начале
     * списка
     */
    public synchronized Linkable removeFromHead() {
        Linkable node = head;
        if (node != null) {
            head = node.getNext();
            node.setNext(null);
        }
        return node;
    }
 
    public synchronized Linkable removeFromTail() {
        if (head == null) {
            return null;
        }
        Linkable p = head, q = null, next = head.getNext();
        if (next == null) {
            head = null;
            return p;
        }
        while ((next = p.getNext()) != null) {
            q = p;
            p = next;
        }
        q.setNext(null);
        return p;
    }
 
    /**
     * Удаляет из списка узел, совпадающий с заданным. Для проверки на
     * совпадение вместо оператора — применяется метод equals().
     */
    public synchronized void remove(Linkable node) {
        if (head == null) {
            return;
        }
        if (node.equals(head)) {
            head = head.getNext();
            return;
        }
        Linkable p = head, q = null;
        while ((q = p.getNext()) != null) {
            if (node.equals(q)) {
                p.setNext(q.getNext());
                return;
            }
            p = q;
        }
    }
 
    /**
     * Этот вложенный класс определяет метод main(), тестирующий LinkedList
     */
    public static class Test {
 
        /**
         * Это тестовый класс, реализующий интерфейс Linkable *
         *
         */
        static class LinkableInteger implements Linkable {
 
            int i; // Данные, содержащиеся в узле 
            Linkable next; // Ссылка на следующий узел в списке 
            public LinkableInteger(int i) {this.i = i;}
            @Override
            public Linkable getNext() {return next;}
            @Override
            public void setNext(Linkable node) {next = node;}
            @Override
            public String toString(){return i + "";}
            public boolean equals(Object o) {
            if (this == o)return true;
            if (!(o instanceof LinkableInteger))return false;
            if (((LinkableInteger) o).i == this.i)return true;
            return false;
            }
        }
        /**
         * Тестовая программа. Вставляет несколько узлов, удаляет несколько
         * узлов, затем печатает все элементы списка. Она должна напечатать
         * числа 4, 6. 3. 1 и 5
         *
         * @param args
         */
        public static void main(String[] args) {
            LinkedList ll = new LinkedList(); // Созданле слиска 
            ll.insertAtHead(new LinkableInteger(1)); // Что-то вставляется 
            ll.insertAtHead(new LinkableInteger(2));
            ll.insertAtHead(new LinkableInteger(3));
            ll.insertAtHead(new LinkableInteger(4));
            ll.insertAtTail(new LinkableInteger(5));
            ll.insertAtTail(new LinkableInteger(6));
            System.out.println(ll.removeFromHead()); // Удаляем и печатаем узел 
            System.out.println(ll.removeFromTail()); // Снова удаляем и печатаем 
            ll.remove(new LinkableInteger(2)); // Удаляем еще один узел
// Теперь печатаем содержимое списка 
            for (Linkable l = ll.getHead(); l != null; l = l.getNext())
                System.out.println(l);
            
        }
    }
}

public class Start {
    static int ctr = 1;
    
    public static void main(String[] args) {
        System.out.println("in Main" + ctr); 
            
        Vlozhennyi.callMain();       
    }
    
    static class Vlozhennyi {
        public static void callMain(){
            String str[] = null;
            
            System.out.println("Vlozhennyi " + ctr);
            
            if (ctr++ < 3) {
                Start.main(str);
            }           
        }
    }
}