Problem z Comparable

Witam!
Moim zadaniem było napisanie własnej kolekcji przechowującej elementy w kolejności rosnącej. Następnie, miałem utworzyć hierarchię klas (np. żołnierze) tak, aby po dodaniu obiektów do kolekcji, uporządkował je rosnąco (według stopni).

 public class Kolekcja <T extends Comparable<T>>
{
    public class Wezel
    {
        T obj;
        Wezel nastepny = null;
    }
    
    Wezel lista = new Wezel();
    public Wezel dodaj(T element)
    {
        lista = dodaj(element, lista);
        return lista;
    }
    
    
    private Wezel dodaj(T element, Wezel wezel)
    {
        Wezel tymczasowy = new Wezel();     
        if(wezel.obj == null || wezel.obj.compareTo(element) >=  0)
        {
            tymczasowy.obj = element;
            tymczasowy.nastepny = wezel;
            wezel = tymczasowy;    
        }
        else
        {
            wezel.nastepny = dodaj(element,wezel.nastepny);
        }
        return wezel; 
    }
     
    public void wypisz()
    {
        Wezel tymczasowy = new Wezel();
        tymczasowy = lista;
        while(tymczasowy.nastepny != null)
        {
            System.out.println(tymczasowy.obj);
            tymczasowy = tymczasowy.nastepny;
        }
    }      
}

A tu klasa abstrakcyjna Żołnierz

public abstract class Zolnierz implements Comparable<Zolnierz>
{
    Integer stopien = 0;
    @Override
    public abstract int compareTo(Zolnierz zol);
}

I przykładowo Kapitan

public class Kapitan extends Zolnierz 
{    
    Integer stopien = 3;

  @Override
    public int compareTo(Zolnierz zol)
    {
        return (stopien.compareTo(zol.stopien));
    }

}

Dodając do mojej kolekcji kapitana, nie jest brany pod uwagę jego stopień (=3), tylko stopień z klasy abstrakcyjnej żołnierz (=0). Bardzo proszę o wskazówki.

Trochę nie czaję bazy, z czym masz problem. Ale w Kapitanie chyba powinno być this.stopien. zresztą nie lepiej w abstrakcji stworzyć sobie getter i setter dla stopien? A następnie sobie go gdzieś indziej ustawiać. Skoro i tak rozszerzeasz abstract i musisz zaimplementować klasę abstrakcyjną, to ona nie musi nadpisywać pola stopien, moze smialo korzystac z this.

public abstract class Zolnierz implements Comparable<Zolnierz> 
{
    Integer stopien = new Integer(0);
    
    @Override
    public int compareTo(Zolnierz z)
    {
        System.out.println(stopien);
        System.out.println(z.stopien);
        
        return stopien.compareTo(z.stopien);
    }
}

W momencie wywołania compareTo stopień i z.stopień mają wartość 0 przez co nie mogę ich porównać w kolekcji.

A może by tak zaimplementować compareTo w klasie Żołnierz?

public int compareTo(Żołnierz trep){
  retuen getStopień().compareTo(trep.getStopień());
}

public abstract int getStopień();

W każdej podklasie będziesz miał odpowiednie implementacje getStopień, a klasy to Szeregowiec{0}, Kapitan{3} itd. Dzięki temu nie musisz też w każdej klasie implementować metody compareTo. Ma to tą zaletę, że wszyscy żołnierze są porównywani w jednolity sposób.

@koziolek, dzięki za pomoc, o to mi właśnie chodziło!