Sort Linkedlist with Comparator and Generics java

Question

I'm trying to sort a linkedlist with generics but I'm having trouble with some casting issues. The code is throwing Bus can't be cast to Node. I know the problem is in the comparator (where I casted to Bus) but otherwise I don't know how could I call to the methods defined in Bus (irrelevant whether is Bus or another Object, just testing with a random one) . I've been researching the internet but couldn't find a solution. Here is the code:

/**
 * Swaps the current node's element with the previous one
 */
public void swap(){
    Object previous = getCurrent().getElement();
    Object current = next().getElement();
    getCurrent().setElement(previous);
    previous().setElement(current);
}

public AbstractList<T> orderBy(Comparator<Node<T>> comparator){
    setCurrent(getFirst());
    Node<T> aux;
    Node<T> current;
    boolean check = true;
    while (check){
        check = false;
        aux = getFirst();
        current = getFirst().getNext();
        while(hasNext()) {
            if (comparator.compare(aux, current) > 0) {
                check = true;
                swap();
            }
            aux = current;
            current = current.getNext();
        }
    }
    return this;
}

The comparator:

import java.util.Comparator;
public class InternComparator implements Comparator<Node<Bus>>{

@Override
public int compare(Node<Bus> o1, Node<Bus> o2) {
return ((Bus)o1.getElement()).getIntern() - ((Bus)o2.getElement()).getIntern();
        } //getIntern() returns an Integer

AbstractList (given by the professor):

    import java.util.NoSuchElementException;
public class AbstractList<T> {
    private Node<T> first;
    private Node<T> current;
    private Node<T> last;
    private int size = 0;


    public boolean hasNext(){
        return current != last;
    }

    public boolean hasPrevious(){
        return current != first;
    }

    public Node getCurrent(){
        return current;
    }

    public void setCurrent(Node<T> current) {
        this.current = current;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return first == last || first == null;
    }

    public void add(T t){
        Node<T> a = new Node<T>(t);
        if(first == null){
            first = a;
        }
        if(last == null && first != null){
            last = a;
            last.setPrevious(first);
            first.setNext(last);
        }

        Node<T> aux = last;
        last.setNext(a);
        last = a;
        last.setPrevious(aux);
        current = last;
        size++;
    }

    public Node next(){
        if(!hasNext()){
            throw new RuntimeException("No elements available next.");
        }
        current = current.getNext();
        return current;
    }

    public Node previous(){
        if(!hasPrevious()){
            throw new RuntimeException("No elements available previous.");
        }
        current = current.getPrevious();
        return current;
    }

    public Node getFirst(){
        return first;
    }

    public Node getLast(){
        return last;
    }

    public void setFirst(Node<T> first){
        this.first = first;
    }

    public void setLast(Node<T> last) {
        this.last = last;
    }

    public void remove(T t){
        current = first;
        boolean removed = false;
        while (hasNext()) {

            if (current.getElement() == t || current.getElement().equals(t)) {
                if(current != last && current != first) {
                    current.getNext().setPrevious(current.getPrevious());
                    current.getPrevious().setNext(current.getNext());
                } else if(current == first){
                    current.getNext().setPrevious(null);
                } else if(current == last){
                    current.getPrevious().setNext(null);
                }
                removed = true;
                return;
            }

            current = next();
        }

        if(removed){
            size--;
        } else {
            throw new NoSuchElementException("No such element on the list.");
        }
    }

    public Node goTo(int pos){
        if(pos > size){
            throw new ArrayIndexOutOfBoundsException("Inexistent Position");
        }
        current = first;
        for(int i = 0; i < pos; i++){
            current = next();
        }
        return current;
    }

    public void insertAfter(T t){
        Node<T> aux = new Node<>(t);
        if(current != last) {
            Node<T> next = current.getNext();
            Node<T> previous = current;
            current.getNext().setPrevious(aux);
            current.setNext(aux);
            aux.setNext(next);
            aux.setPrevious(previous);
        } else {
            current.setNext(aux);
            aux.setPrevious(current);
            last = aux;
        }
        size++;
    }

    public void insertPrevious(T t){
        Node<T> aux = new Node<>(t);
        if(current != first) {
            Node<T> previous = current.getPrevious();
            Node<T> next = current;
            current.getPrevious().setNext(aux);
            current.setPrevious(aux);
            aux.setNext(next);
            aux.setPrevious(previous);
        } else {
            Node<T> aux1 = current;
            current.setPrevious(aux);
            first = aux;
            first.setNext(aux1);
        }
        size++;
    }

    @Override
    public String toString() {
        String result = "";
        current = first;
        while(hasNext()) {
            result += current.getElement() + "";
            next();
        }
        return result;
    }
}

class Node<T> {
    private Object element;
    private Node<T> prev;
    private Node<T> next;

    public Node(T element){
        this.element = element;
    }

    public Node(T element, Node next){
        this.element = element;
        this.next = next;
    }

    public Node<T> getNext() {
        return next;
    }

    public Node<T> getPrevious() {
        return prev;
    }

    public Object getElement() {
        return element;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }

    public void setPrevious(Node<T> prev) {
        this.prev = prev;
    }

    public void setElement(Object element) {
        this.element = element;
    }
}

Answer 1

Think again: your object is of type Node<Bus>; and you are wondering why the cast to Bus fails?

Or lets rephrase: do you assume that a Bus<People> represents a human being?

If you have a container, then you have to retrieve the contained value; and that can't be achieved by casting the container!

Or, to keep using strange pictures: you don't get an egg out of the box by declaring the box to be an egg. You open the box, and fetch the egg.