Re: Generics/Comparator

From:

"Kaiser S." <sausey@name.invalid>

Newsgroups:

comp.lang.java.programmer

Date:

Wed, 25 Apr 2007 13:02:43 +0200

Message-ID:

<462f3517$0$25949$ba4acef3@news.orange.fr>

There is no problem using generics in comparators, but your design is,
indeed, flawed. First of all, the semantics is unclear: why are
HandlerOfB and HandlerOfC extending HandlerOfA?

Well the snippet is a simplified version of the real source code. The
Handlers have 10/15 methods in common and in a lot of places, i don't
need to know the actual type of handler.

That is also the source of the problem: HandlerOfA defines
getComparator(), which returns a Comparator. Here already you should
get a compiler warning not to use raw types. But in respect to what
comes later, it is difficult to generify this. What type of Comparator
would you return? Comparator<A> won???t work, since then the methods in
HandlerOfB and HandlerOfC won???t override properly. A possibility is to
make the method itself generic:

public abstract <T extends A> Comparator<T> getComparator();

But that would make it more complicated than it???s worth. From the

Yes, it's not possible to generify the method.

snippet you show in the main method, I see no reason why you would need
the handlers inherit from each other. So maybe if you explained what
you really wanted, someone could help you better.

import java.util.Comparator;
import java.util.TreeSet;

public class TestComparator {

    private static abstract class A {
    }

    private static class B extends A {
    }

    private static class C extends A {
    }

    private static abstract class HandlerOfA {
        public abstract Comparator getComparator();
    }

    private static class HandlerOfB extends HandlerOfA {
        public static class ComparatorOfB implements Comparator<B> {
            public int compare(B b1, B b2) {
                return 0;
            }

        }
        public Comparator getComparator() {
            return new ComparatorOfB();
        }
    }

    private static class HandlerOfC extends HandlerOfA {
        public static class ComparatorOfC implements Comparator<C> {
            public int compare(C c1, C c2) {
                return 0;
            }

        }
        public Comparator getComparator() {
            return new ComparatorOfC();
        }
    }

    public static void main(String[] args) {
        HandlerOfA contA = new HandlerOfB();
        HandlerOfB contB = new HandlerOfB();
        HandlerOfC contC = new HandlerOfC();

        TreeSet<A> treesetA = new TreeSet<A>(contA.getComparator());
        treesetA.add(new B());

        TreeSet<B> treesetB = new TreeSet<B>(contB.getComparator());
        treesetB.add(new B());

        TreeSet<C> treesetC = new TreeSet<C>(contC.getComparator());
        treesetC.add(new C());

    }
}