Declaring interface method to allow only implemented class

Question

I have interface Syncable:

public interface Syncable{
    public void sync(Syncable other);
}

And two implemented classes:

public class TstA implements Syncable{
    @Override
    public void sync(Syncable other) {
        // TODO Auto-generated method stub      
    }
}

public class TstB implements Syncable{
    @Override
    public void sync(Syncable other) {
        // TODO Auto-generated method stub      
    }
}

So this code is legal:

TstA a = new TstA();
TstB b = new TstB();
a.sync(b);

This is not what I want. I want to allow a.sync receive instances of TstA, and b.sync receive instances of TstB.

Probably I have to use generics, but how?

possible duplicate of [declare paramter subtype in Java interface, use subtypes in Java implementing methods](http://stackoverflow.com/questions/4820159/declare-paramter-subtype-in-java-interface-use-subtypes-in-java-implementing-me) — Sotirios Delimanolis, Mar 29 '14 at 19:54

score 2 · Accepted Answer · answered Mar 29 '14 at 19:55

2

Make your interface generic:

public interface Syncable<T extends Syncable<T>> {
    public void sync(T other);
}

And implement a parameterized instance of that interface:

public class TstA implements Syncable<TstA> {
    @Override
    public void sync(TstA other) {
        // TODO Auto-generated method stub      
    }
}

answered Mar 29 '14 at 19:55

Rohit Jain

209,639
45
409
525

This is strict enough for me, but not an end solution, as defining signature: interface Syncable> doesn't infer that it will be used properly, and may be used like this: class TstA implements Syncable – Andrey Mar 29 '14 at 20:06
@AndreyP That is possible. But I guess you can't get around with that. :( – Rohit Jain Mar 29 '14 at 20:09
Is it possible to add restriction that: class T1 implements Syncable so that T1=T2 ? – Andrey Mar 29 '14 at 20:10
@AndreyP No you can't do that. That kind of restriction is not possible. – Rohit Jain Mar 29 '14 at 20:12
@AndreyP: If the above way works for you, `interface Syncable` would also work. – newacct Apr 02 '14 at 09:37
@newacct And that would allow the instantiation like this - `Syncable – Rohit Jain Apr 02 '14 at 09:46
@RohitJain: Where does it say that `Syncable – newacct Apr 02 '14 at 09:50

score 0 · Answer 2 · answered Apr 02 '14 at 09:36

Analogous to Comparable, this is how you would do it:

public interface Syncable<T> {
    public void sync(T other);
}

public class TstA implements Syncable<TstA> {
    @Override
    public void sync(TstA other) {
        // TODO Auto-generated method stub      
    }
}

public class TstB implements Syncable<TstB> {
    @Override
    public void sync(TstB other) {
        // TODO Auto-generated method stub      
    }
}

If there were a generic class or method that required a type parameter T to be syncable to itself, then that class or method would declare the bound T extends Syncable<? super T>.

Declaring interface method to allow only implemented class

2 Answers2