如何在实现接口的所有类中设计公共静态方法

Question

I have an interface called Relation , implemented by a class BasicRelation , and extended by subclasses (eg ParentChild , Sibling , Spouse ). While developing my code, I realized that I often need a method which takes a String representation of a relation to create it. For example:

public class ParentChild implements Relation extends BasicRelation {

  // e.g. "Jack is Emily's father. Jill is her mother." will return the list
  // <ParentChild(Jack, Emily), ParentChild(Jill, Emily)>
  static List<ParentChild> fromSentence(String s) {
    ...
  }
}

Now, since I find myself needing this method ( fromSentence(String) ) in every class, except perhaps in BasicRelation , I would like to move it up the hierarchy. The problem is that the internal details of the method is subclass-dependent, so I can't have it as a static method in the interface Relation or the superclass BasicRelation .

Unfortunately, in Java, it is also not possible to have a static abstract method.

Is there any way to ensure that every subclass of BasicRelation (or every class implementing Relation ) implements fromSentence(String) ? If no, should I be designing this in a completely different way? I guess this last question is more of a request for design-advice than a question.

Answer 1

Why does the static method need to be in the interface? What's stopping you from having a 'Utility' class and having the method in there?

public class RelationUtility {
    public static BasicRelation relationFactory(String asString) {
        ....
    }
}

As a static method, there is no reason other than access to private members, which can also be accomplished by by 'default' permissions on those members....

Answer 2

You can try making the BasicRelation class an abstract class and use an abstract fromSentence(..) method. This would require the ParentChild class to override and implement the fromSentence method because you can't create an object for ParentChild without implementing fromSentence()

public abstract class BasicRelation extends Relation(){

   public abstract List<..> fromSentence(String s);
}

public class ParentChild implements Relation extends BasicRelation {

 fromSentence(){
 //parentChild class's implementation
}

}

Answer 3

If I understood right... you can try an approach like this

public class BasicRelation {

    public abstract List<ParentChild> fromSentenceInSubclass(s);

    public List<ParentChild> fromSentence(String s){
        fromSentenceInSubclass(s);
    }
}

And then you could have:

public class SubclassRelation extends BasicRelation {

    public List<ParentChild> fromSentenceInSubclass(s){
        // do subclass relation stuff
    }

}

You will probably need to change the code a bit and add some Generics around to make it happen the way you want. Sotirios Delimanolis Factory suggestion might also be an option.

Answer 4

You can have the abstract class BasicRelation include the static method which throws an Exception. That way you will be forced to override (shadow) the static method in the subclasses when you use it.

Something like:

public abstract class BasicRelation {
    public static List<..> fromSentence(String s) {
        throw new RuntimeException();
    }
}