Задача с наследованием, прошу помощи

List<Branch> mixBrnches = new  ArrayList<>();
 mixBrnches.add(new Branch("Робот троль, услышь людей!"));

package mylist;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 *
 * @author vvm
 */
public class TestAny {
    public static void main(String[] args) {
        List<Shape> mixBrnches = new  ArrayList<>();
        mixBrnches.add(new Circle());
        System.out.println("mixBrnches.size(); = "+ mixBrnches.size());
        mixBrnches.get(0).draw();
         
 
    }
}

/**
 * реализация двусвязанного списка
 * пришлось маленько его допилить чтобы на его базе селать стек и очередь
 * добавлены методы удаление из начала списка и удаление из конца списка также
 * добавлены методы добавление в нчало и добавление в конец
 */
 
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
 
public class SimpleLinkedList<E> implements SimpleContainer<E> {
    private int size = 0;
    private int modCount = 0;
    private Node<E> first;
    private Node<E> last;
 
 
//    public int hashCode(Node<E> e) {
//        return e.date.hashCode();
//    }
 
    /**
     * данный метод добавляет элемент именно в конец списка
     * основан на методе addLs
     *
     * @param e
     * @return
     */
    @Override
    public boolean add(E e) {
        addLast(e);
        return true;
    }
 
    /**
     * добавление элемента в начало
     *
     * @param e
     */
    public void addFirst(E e) {
        Node<E> newLink = new Node<E>(e);
        if (first == null) {
            refPrime(newLink);
        } else {
            newLink.next = first;
            newLink.previos = first;
            first = newLink;
        }
        this.size++;
        modCount++;
    }
 
    /**
     * добавление элемента в конец
     *
     * @param e
     */
    public void addLast(E e) {
        Node<E> newLink = new Node<E>(e);
        if (first == null) {
            refPrime(newLink);
        } else {
            last.next = newLink;
            newLink.previos = last;
            this.last = newLink;
        }
        this.size++;
        modCount++;
    }
 
    /**
     * рефакторинг добавления самог первого элемента происходит везде одинаково
     * добавляется он в конец или в начало
     *
     * @param newLink
     */
    private void refPrime(Node<E> newLink) {
        newLink.previos = first;
        first = newLink;
        newLink.next = this.last;
        this.last = newLink;
    }
 
    /**
     * метод не просто возвращает элемент,
     * а проверяет с какой стороны быстрее добраться до элемента контейнера
     *
     * @param index
     * @return E e
     */
    @Override
    public E get(int index) {
        whenIndexofBound(index);
        Node<E> result = null;
        if (isCheck(index)) {
            result = first;
            for (int i = 0; i < index; i++) {
                result = result.next;
            }
        } else {
            result = last;
            for (int i = getSize() - 1; i > index; i--) {
                result = last.previos;
            }
        }
        return result.date;
    }
 
 
    /**
     * узнать размер нашего двусвязанного списка
     *
     * @return int
     */
    public int getSize() {
        return size;
    }
 
    /**
     * данный метод проверяет существует ли данный индекс
     * и сотри с какой стороны быстрее искать искомый индекс
     *
     * @param index
     * @return
     */
    private boolean isCheck(int index) {
        whenIndexofBound(index);
        return index + 1 <= getSize() / 2;
    }
 
    private static class Node<E> extends SimpleLinkedList {
        E date;
        Node<E> next;
        Node<E> previos;
 
        Node(E date) {
            this.date = date;
        }
 
        @Override
        public int hashCode() {
            return date.hashCode();
        }
    }
 
    /**
     * удаление первого элемента
     *
     * @return
     */
    public E deleteFirst() {
        isCheckelement();
        Node<E> temp = first;
        if (this.size == 1) {
            this.first = temp.next;
        } else {
            this.first = temp.next;
            first.previos = temp.previos;
        }
        modCount++;
        size--;
        return temp.date;
    }
 
    /**
     * удаление последнего элемента
     *
     * @return
     */
    public E deleteLast() {
        isCheckelement();
        Node<E> temp = last;
        if (this.size == 1) {
            this.last = temp.previos;
        } else {
            this.last = last.previos;
            last.next = temp.next;
        }
        modCount++;
        size--;
        return temp.date;
    }
 
    /**
     * вернуть последний элемент
     *
     * @return
     */
    public Node<E> getLast() {
        return last;
    }
 
    /**
     * вернуть первый элемент
     *
     * @return
     */
    public Node<E> getFirst() {
        return first;
    }
 
    public int getModCount() {
        return modCount;
    }
 
    /**
     * проверка есть ли в контейнере элементы
     */
    private void isCheckelement() {
        if (!(size > 0)) {
            throw new NoSuchElementException("в контейнере отсутствуют элементы");
        }
    }
 
    /**
     * проверяет выходим ли мы за рамки существующих элементов
     * и проверяет эсть ли хотябы один элемент
     *
     * @param index
     */
    private void whenIndexofBound(int index) {
        if (size - 1 < index || size == 0) {
            throw new IndexOutOfBoundsException("данного индекса не существует или вы вывалились за пределы массива");
        }
    }
    /**
     * вернёт тру если элемент есть в листе
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        return !(indexOf(e) == -1);
    }
 
    /**
     * возвращает индекс элемента ,
     * если элемент отсутствует то возвращает -1
     *
     * @param e
     * @return
     */
    public int indexOf(E e) {
        int res = -1;
        Node temp = first;
        for (int i = 0; i < size; i++) {
            if (temp.date == e) {
                res = i;
                break;
            }
            temp = temp.next;
        }
        return res;
    }
 
    @Override
    public Iterator<E> iterator() {
        return new Itr<>();
    }
 
    private class Itr<E> implements Iterator<E> {
        private Node iter = first;
        private int check = getModCount();
 
 
        @Override
        public boolean hasNext() {
            testCheck();
            return !(iter == null);
        }
 
        @Override
        public E next() {
            testCheck();
            E element = null;
            if (!hasNext()) {
                throw new NoSuchElementException("элементы закончились");
            } else {
                element = (E) iter.date;
                iter = iter.next;
            }
            return element;
        }
 
        private void testCheck() {
            if (!(check == getModCount())) {
                throw new ConcurrentModificationException("массив был изменён интерация остановлена");
            }
        }
    }
}

import java.util.Iterator;
 
/**
 * интерфейс коллекшен))
 * @param <E>
 */
 
public interface SimpleContainer<E> extends Iterable<E> {
    boolean add(E e);
    E get(int index);
 
    @Override
    Iterator<E> iterator();
}

hashCode()

getSize() / 2;

package simpleLinkedList;
 
import java.util.*;
 
public class StackL {
    private LinkedList list = new LinkedList();
    public void push(Object v){
    list.addFirst(v);
    }
    public Object top(){return list.getFirst();}
    public Object pop(){
    return list.removeFirst();}
    public static void main(String[] args) {
        StackL stack = new StackL();
       /* for(int i = 0; i<10; i++)
            stack.push(Collection2.any.next()); - тут он заполняет контейнер любого типа объектом -"генератором" */ 
System.out.ptintln(stack.top());
System.out.ptintln(stack.pop());
    }
            
}

@Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Node<?> other = (Node<?>) obj;
            if (!Objects.equals(this.date, other.date)) {
                return false;
            }
            if (!Objects.equals(this.next, other.next)) {
                return false;
            }
            if (!Objects.equals(this.previos, other.previos)) {
                return false;
            }
            return true;
        }
    }

 
 /*
 
 */
package simpleLinkedList;
 
/**
 *
 * @author vvm
 */
public class TestSimpleLinkedList {
    public static void main(String[] args) {
        SimpleLinkedList<Shape>  sl= new SimpleLinkedList();
        Circle circle = new Circle();
        sl.add(circle);
        System.out.println("размер = "+sl.getSize());
        System.out.println("Класс = "+ sl.get(0).getClass()); 
        sl.get(0).draw();
        
    }
}
 
/*
run:
размер = 1
Класс = class simpleLinkedList.Circle
метод draw переопределенный в Circle
BUILD SUCCESSFUL (total time: 2 seconds)
*/

/*
  
 */
package mylist;
 
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
 
/**
 *
 * @author vvm
 */
public class TestTree {
 
    public static void main(String[] args) {
        Map treeMap = new TreeMap<>();
        Shape shCircle = new Circle();
        Shape shRect = new Rectangle();
 
        Map<String, Shape> map = new HashMap<>();
        map.put("a", shCircle);
        map.put("b", shRect);
 
        map.entrySet().stream().forEach((pair) -> {
            System.out.println("Ключ = " + pair.getKey()+"  Класс = " + pair.getValue().getClass());
             pair.getValue().draw();
        });
    }
}
 
/*
run:
Ключ = a  Класс = class mylist.Circle
метод draw переопределенный в Circle
Ключ = b  Класс = class mylist.Rectangle
метод draw переопределенный в Rectangle
BUILD SUCCESSFUL (total time: 13 seconds)
*/

 Map<String,Shape> map = new TreeMap<>(); // - красно-черное дерево.
        map.put("a", shCircle);
        map.put("b", shRect);
 
        map.entrySet().stream().forEach((pair) -> {
            System.out.println("Ключ = " + pair.getKey()+"  Класс = " + pair.getValue().getClass());
             pair.getValue().draw();
        });