Sort Superclass list of objects that are Subclasses of the Superclass

Question

Suppose I have an abstract Superclass named that is defined like this:

public abstract class Member implements Comparable<Member>

And then I have two Subclasses of Member, defined like this:

public class Coach extends Member

public class Player extends Member

Then, I have a list of Member, which means it contains both Coach and Player.

I need to sort this list, in which a coach always comes first and then come the players sorted by an identification number.

I need to implement the compareTo method to do this. But how do I proceed, knowing that I can't implement the method in the superclass Member, since the identification number is a property of Player and Coach doesn't have it?

I hope I've been clear on the problem.

As you said, writing the `compareTo()` method on `Member` to sort *child classes* is not possible. You are trying to write a wrong design. In order to compare them, you need to do it processing a common field(s). — Lucio, Jun 15 '14 at 19:59

Norbert Radyk · Accepted Answer · 2014-06-15T20:15:12.137

You've got a couple of options here:

Write a compareTo method on Member and write a compator which will check whether member object is the instance of Coach (then it will be always before other Member object).

In this solution, however you assume however that base class will know about it's implementors which might be considered a bad design, as once you start introducing more implementing classes (i.e. Referee, Technical Assistant etc.) you'll need to change the method every time, and might end up with something really complicated.

On the other hand though you've got the full ordering control in one place, which is easier to test and reason about than...

Alternatively extend member with getOrderingIndicator() abtract method which you'll implement in both Player (assign identification number) and Coach (assign 0 or some other value lower than allowed player identification number) and use this abstract method in the compareTo method in Member class.

In this solution you'll guarantee that whatever implementations of Member base class there are in the future, they will be correctly ordered.

All in all though, I'd strongly suggest implementing the compareTo on the member level, since it's the Member objects you're comparing.

score 2 · Answer 2 · answered Jun 15 '14 at 20:04

2

You need to implement Comparator and check object's class and take decision

abstract class Member implements Comparator<Base>{
    @Override
    public int compare(Base o1, Base o2) {
        if(o1.getClass() == Couch.class && o2.getClass() == Player.class){
            return Integer.MAX_VALUE;
        }

        if(o1.getClass() == Player && o2.getClass() == Coach.class){
            return Integer.MIN_VALUE;
        }

        if(o1.getClass()==o2.getClass() && o1.getClass() == Coach.class){
            return 0;
        }

        if(o1.getClass() == o2.getClass() && o2.getClass() == Player.class){
            //cast to player and compare them
        }

    }
}

answered Jun 15 '14 at 20:04

jmj

237,923
42
401
438

2

why not "instanceof" instead of getClass()? – EpicPandaForce Jun 15 '14 at 20:15
1

to be strict about that class only – jmj Jun 15 '14 at 20:24
I see. Fair enough. :D – EpicPandaForce Jun 15 '14 at 20:40

Avneet Singh · Answer 3 · 2022-05-03T05:24:12.163

import java.util.*;

abstract class VIP implements Comparable<Member>{
 abstract  int getOrderIndex();
 abstract String getName();
}


class Member extends VIP {
    String name;
    int index;
    public Member(String s,int i){
    this.name=s;this.index=i;
    }
    
    public  int compareTo(Member m){
       return this.getOrderIndex()-m.getOrderIndex();
     }
    
    public String getName(){
    return name;
    }
    public int getOrderIndex(){
    return index;
    }
}

class Player extends Member {
      public Player(String s,int i){
      super(s,i);
      } 
}
class Coach extends Member{
    public Coach(String s,int i){
      super(s,i);
    }
}
class Refree extends Member{
    public Refree(String s,int i){
      super(s,i);
    }
}

class Main{
  public static void main(String[] args) {
        
        List<Member> l=new ArrayList<Member>();
        
         l.add(new Refree("refree",2));
         l.add(new Player("player2",1));
         l.add(new Player("player1",1));
         l.add(new Coach("coach2",0));       
         l.add(new Coach("coach1",0));      
       
        l.sort((m1,m2)-> m1.compareTo(m2));
       
        l.forEach(o-> System.out.println(o.getName()));
       
       
  }
}

Sort Superclass list of objects that are Subclasses of the Superclass

3 Answers3