如何确保接口实现扩展特定类？

Question

I have two types of editors. One is a subclass of JTextArea and one is a subclass of JTable ( JTextArea and JTable are both subclasses of JComponent ). I want my two classes, TextAreaEditor and TableEditor to implement the interface Editor , which just has the method public String getText() .

I want the client code to simply use the Editor interface. The issue is, all of my Editor s use methods of JComponent , like setEnabled(bool) . Since my editor is an interface and I can't make it extend JComponent, I have to use the implementations instead of the interface when calling these methods. So I thought that instead of using an interface, I can simply make Editor a subclass of JComponent and make my classes extend that. The issue is classes like TextAreaEditor already extend some class like JTextArea , so I can't make them extend another class.

Is there any way to make sure that my Editor class is a JComponent, and that my concrete editor classes are Editor s and subclasses of JComponent ?

Answer 1

If you expose the JComponent methods you care about in a subclass of your editor interface, they would be 'retroactively' implemented by your class.

Here is some code to demonstrate the idea:

interface Editor { 
  String getText(); 
}

interface SwingEditor extends Editor { 
  void setEnabled(bool); // has to match *exactly* the signature from JComponent
}

class TableEditor extends JTable implements SwingEditor {
   // implement your getText(), and anything else you need 
   // no need to implement setEnabled, as it is provided by JTable
}

SwingEditor te = new TableEditor();
te.setEnabled(true); // will call JComponent's method

I assume you really need inheritance here, in general often composition is a better option for Swing UI code.

Answer 2

Use composition over inheritacne . Most of the time inheritance is really not the right solution, and in your case, it'll save you from writing quite a bit of code.

Have your TextAreaEditor and TableEditor both have an instance of the JComponent they need. Add all the methods you need to your interface, and then delegate those calls to the JComponet .

For example:

public class TextAreaEditor implements Editor {
     private final JTextArea textArea = new JTextArea();

     public void setEnabled(bool isEnabled) {
          return textArea.setEnabled(isEnabled);
     }

     //... your own methods plus other methods from JComponent
}

You might want to get a bit more fancy and use some sort of dependency injection to instantiate the JComponent , but that's not really necessary. It could, however, solve the problem of having to have to classes if all the changes is which particular JComponent you need to inject.

Let me know if you need more clarificaiton.

Answer 3

If you really need your Editor class to be a JComponent as well you can opt to simply document this and perform a cast in your code. Not the most neat solution, but by far the easiest.

Another approach would be to add an extra method to the Editor interface:

public JComponent getComponent();

where your Editor instances could implement this method by simply returning this .

The benefit of the latter approach is that you can use all JComponent methods, and do not have to duplicate them in your interface, and come to the conclusion in 2 months that you forgot to add one of the JComponent methods to your interface

Answer 4

The following design takes care of it:

public class TextAreaEditor extends JTextArea implements Editor {
//provide your implementation of getText()
//setEnabled(bool) doesn't have be implemented as JComponent will provide
}

TextAreaEditor te = new TextAreaEditor();
te.setEnabled(true); // will call JComponent's impl

as per the above code your own concrete implementations of Editor (TextAreaEditor) is an Editor and subclass of JComponent.

Answer 5

I would probably create a new table and textarea class extending their respective super class, and implementing an editor interface like so

public class JTextAreaEditor extends JTextArea implements Editor {
...
}

Then use composition to expose the methods of the Editor interface

    public class JTextAreaEditor extends JTextArea implements Editor {
       private Editor editor;

       public String getValue() {
          return editor.getValue();
       }
       ...
    }

Answer 6

I think your argument is simply incorrect: For an interface (Editor), you shouldn't concern on how the implementations are implemented. You said all your Editor implementation needs to be JComponent. That's just what happens now but it is never need to be a "requirement" for being an "Editor". The design of Editor have no reason to impose on that, as long as the implementation conforms to what Editor asks for (getText() ).

What you are talking on is mostly a default base class for "normal" Editor implementations. Once again, note that whether the implementation choose to use this base class is their choice, as long as they conform to your Editor interface.

public interface Editor {
    String getText();
}

public abstract class JComponentEditor extends JComponent 
        implements Editor {
    //.....
}

public TextAreaEditor extends JComponentEditor {
    public String getText() {
        // implements TextAreaEditor's version of getText
    }
}

---

EDIT: I think I bit misunderstood a bit on the question of OP. Anyway, the main argument in my answer still holds: It do not make sense to enforce "...that my Editor class is a JComponent, and that my concrete editor classes are Editors and subclasses of JComponent". It is just the implementation detail of Editor