Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Java > Generics/Comparator

Reply
Thread Tools

Generics/Comparator

 
 
Kaiser S.
Guest
Posts: n/a
 
      04-24-2007
Hello,

here is a short class source with begining of generics. Could you please
tell me how to use generics with the comparators ?

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());

}
}


Thanks for any help
 
Reply With Quote
 
 
 
 
Kaiser S.
Guest
Posts: n/a
 
      04-25-2007
If it's not possible to put generics in comparators, could you tell me
what is wrong in the design of the classes? What should i change in
order to have the same fonctionnalities, but with a different design ?
 
Reply With Quote
 
 
 
 
Hendrik Maryns
Guest
Posts: n/a
 
      04-25-2007
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Kaiser S. schreef:
> If it's not possible to put generics in comparators, could you tell me
> what is wrong in the design of the classes? What should i change in
> order to have the same fonctionnalities, but with a different design ?


Please quote some content if you reply to a message. I now had to look
for you previous message in order to try to help.

I pasted it in below.

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?

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
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.

Read also the last link in my sig, particularly the section ‘describe
the goal, not the step’.

> Hello,
>
> here is a short class source with begining of generics. Could you please tell me how to use generics with the comparators ?
>
> 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());
>
> }
> }


H.

- --
Hendrik Maryns
http://tcl.sfs.uni-tuebingen.de/~hendrik/
==================
http://aouw.org
Ask smart questions, get good answers:
http://www.catb.org/~esr/faqs/smart-questions.html
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iD8DBQFGLyZbe+7xMGD3itQRAgFjAJ0Yf/PednLJg958yJk5oOzN47V1VgCeNAmw
kwtc37ovldqO8484Sp4GWJs=
=o+x9
-----END PGP SIGNATURE-----
 
Reply With Quote
 
Kaiser S.
Guest
Posts: n/a
 
      04-25-2007
> 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());
>>
>> }
>> }

 
Reply With Quote
 
Esmond Pitt
Guest
Posts: n/a
 
      04-26-2007
You need a few adjustments:

private static abstract class HandlerOfA
{
public abstract Comparator<? extends A> 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<B> 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<C> getComparator()
{
return new ComparatorOfC();
}
}

and then in your main:

HandlerOfA contA = new HandlerOfB();

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

This ceases to make sense once the generics are introduced.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off




Advertisments