Java - 在处理继承和接口时调用Swing中的方法

Question

My problem is quite hard to word but here is the basic outline:

I have an interface:

public interface TheInterface {
    /**
     * 
     * Returns a string
     */

    public String getStuff(); 



}

I have an abstract class that implements this interface:

public abstract class GenericClass implements TheInterface {

    public GenericClass() {
        // TODO Auto-generated constructor stub
    }



    @Override
    public String getStuff() {
        return "Random string";
    }


}

I then have a class that extends GenericClass

public class GUIClass extends GenericClass {
    private myFrame  myNewFrame;
    public GUIClass() {
        super();
        myNewFrame = new myFrame();

    }

}

As you can see, the GenericClass has a frame:

import javax.swing.JFrame;


public class myFrame extends JFrame {

    private myPanel topPanel;

    public myFrame() {

        topPanel= new myPanel(); 
        add(topPanel); 

         setSize(400,200); 
         //setLocation(200,200); 
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
         setTitle("Test Program"); 
         setVisible(true); 
    }

}

And inside that frame is a panel which contains a label:

import java.awt.GridLayout; import java.awt.Label;

import javax.swing.JLabel; import javax.swing.JPanel;

public class myPanel extends JPanel {

    private JLabel myLabel;

    public myPanel() {
        setLayout(new GridLayout(0,2));
        add (new Label("This label should contain the content of getStuff(): "));
        myLabel=new JLabel();
        add (myLabel);
    }

}

And what I want to do here is to call getStuff() from the GenericClass and have it displayed inside that label. However at the moment I have no access to it and it seems that my design is flawed. I would appreciate it if anyone could help to rearrange or change this so that it would be possible to call that method in the label in the most efficient way without multiple cases of the same code.

Thanks.

Answer 1

You could use the Observer pattern:

public interface StuffObserver {
/**
 * 
 * Pass whatever you want, perhaps getStuff(),
 * but that method might be removed by the time we're done here
 * (depends on what else might need to query/track it without,
 *  an observer)
 */
private void onStuffChanged(String newStuff); 

}

Your Panel class is now

public class myPanel extends JPanel implements StuffObserver

which contains

private void onStuffChanged(String newStuff)
{
   Runnable changeText = new Runnable() {
       public void run() {
           myLabel.setText(newStuff);
       }
   };
   SwingUtilities.invokeLater(changeText);
}

make sure you have myLabel referencing the actual label you added to panel (your current code around that might not be what you want?)

From here, have perhaps GenericClass or it's subclass GUIClass can have a List of StuffObservers (with methods to add or delete from)

private List<StuffObservers> stuffObservers = new ArrayList<>();
public void addStuffObserver(StuffObserver ob)...
// looks familar? Same way Swing has addActionListener() on some components
public void deleteStuffObserver(StuffObserver ob)... 

GUIClass can simply call something like:

myNewFrame = new myFrame();
addStuffObserver(myNewFrame.getPanel());

Your GenericClass or GUIClass can also do the following whenever it changes what the outcome of getStuff() can be:

for (StuffObserver ob : stuffObservers)
{
    ob.onStuffChanged(someStringRepresentingWhatYouWouldChangeGetStuffTo);
}

And get rid of getStuff() now. Anytime you change the state that getStuff() would have returned, your JLabel will now auto update to display that data.

Answer 2

I would suggest you construct and manage your GUI components directly in GUIClass instead of auto-managing them in custom subclasses.

public class GUIClass extends GenericClass {
    private JFrame frame;
    private JPanel panel;
    private JLabel label;

    public GUIClass() {
        super();
        initialisation();
        setLabelText(getStuff());
    }

    private void initialisation() {
        // Label
        this.label = new JLabel();
        this.label.setText(getStuff());

        // Panel
        this.panel = new JPanel();
        this.panel.setLayout(new GridLayout(0, 2));
        this.panel.add(this.label);

        // Frame
        this.frame = new JFrame();
        this.frame.add(this.panel);
        this.frame.setSize(400, 200);
        this.frame.setLocation(200, 200);
        this.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.frame.setTitle("Test Program");
        this.frame.setVisible(true);
    }

    private void setLabelText(String text) {
        this.label.setText(text);
    }
}

This is a design suggestion, so I might have forgotten some elements from your original code, but I think you can get the idea!