java引用不在范围内的对象

Question

one question that always pops up when my java project gets bigger is if there is an easy way of making references to a specific object thats cannot be referenced by super or getParent(). The following graph should illustrates my current problem:

For every FileListItem I want to instatiate a new FileListItemController which needs methods from ProtocolController. Is there a way of referencing the ProtocolController object instatiated by main in the FileListItems other than passing it on through mainWindow, FileListContentPanel, FileListItems?

---

First thanks to all your answers.

I am using the model, view, control pattern for my project.

The singleton pattern sounds interesting but my feeling is that it does not solve my issue. Here is some code to illustrate my problem:

public class Main {
    public static void main(String [ ] args) {
        ProtocolController pc = new ProtocolController();
        mainWindow mw = new mainWindow();

    }
}
public class ProtocolController {
    File protocol;
    public ProtocolController(File protocol){
        this.protocol = protocol;
    }

    public void writeSomethingToProtocolFile(String something){
        // write something to th protcol file specified by the object
    }
}
public class mainWindow {
    public mainWindow(){
        FileListContentPanel flcp = new FileListContentPanel();
    }
}
public class FileListContentPanel {
    public FileListContentPanel(){
        int numListItems = 10;
        for (int i = 0; i < 10; i++) {
            FileListItem fli = new FileListItem();
            FileListItemController flic = new FileListItemController(fli);
        }
    }
}
public class FileListItemController {

    public FileListItemController(FileListItem fli){

    }
    public void addSomethingToProtocol(String something){
        // at this point I want to use a method from the ProtocolController class instantiated by the main method
    }
}

Answer 1

There are different approaches for this.

For instance, if you only need one ProtocolController instance, you could use the singleton pattern . Each FileListItemController is then able to retrieve the same ProtocolController object.

class ProtocolController {

    private static instance;

    private ProtocolController() { }

    public static ProtocolController getInstance() {
        if (instance == null) {
            instance = new ProtocolController();
        }
        return instance;
    }
}

You can then get ProtocolController.getInstance() from within FileListItemController and then call the desired method.

Answer 2

If you have only one instance of FileListItemController , you can use Singleton pattern with "Lazy instantiation".

And ProtocolController instantiates FileListItemController like this :

FileListItemController fileListItemControllerInstance = FileListItemController.getInstance();

EDIT

If each FileListItem references one FileListItemController , you can use a Factory ( Abstract Factory Pattern )

In this case, your ProtocolController can instiate a FileListItemController factory. You can pass ProtocolController reference to the factory if needed.

Then FileListItem can use this factory to create new FileListItemController instances.

Answer 3

This looks like a use case for Model-View-Controller design pattern.

Your FileListItem objects are model (You'll need a new class to hold them). Both Controller and View ( FileListControlPanel ) get a reference to Model. Controller then uses methods on model to change its contents, and View subscribes to model's events to show the changes.

https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller

Answer 4

Window doesn't need to know about the protocol. In fact, Panel doesn't need to know about the protocol either.

Use dependency injection.

---

Panel

Since Panel creates the controllers, Panel will need a reference to Protocol . So you'll need to inject the protocol into the panel.

class Panel {
    public Panel(Protocol protocol) {
        for(...) {
            Item item = new Item();
            Controller controller = new Controller(item, protocol);
        }
    }
}

I don't recommend populating the list in the constructor like this, but I kept it so the code is familiar.

Window

To prevent Window knowing about Protocol , you should inject the panel.

class Window {
    public Window(Panel panel) {
        // ...
    }
}

Update main

With these new changes, you'd be interfacing with your types as follows:

Protocol protocol = new Protocol();
Panel panel = new Panel(protocol);
Window window = new Window(panel);

Now Window doesn't need to depend on Protocol .

---

Introduce a factory

I mentioned how Panel doesn't need to depend on Protocol either.

It's the Controller that uses the protocol; the panel only references the protocol so it can pass it to newly created controllers. The protocol is needed for the creation of controllers.

You could introduce a factory to handle the creation of controllers. The factory would reference the protocol:

class ControllerFactory {
    private Protocol protocol;

    public ControllerFactory(Protocol protocol) {
        this.protocol = protocol;
    }

    public Controller newController(Item item) {
        return new Controller(item, protocol);
    }
}

Panel would now depend on the factory instead of the protocol:

class Panel {
    public Panel(ControllerFactory factory) {
        factory = factory;

        for(...) {
            Item item = new Item();
            Controller controller = factory.newController(item);
        }
    }
}

Your new usage would be as follows:

Protocol protocol = new Protocol();
ControllerFactory factory = new ControllerFactory(protocol);
Panel panel = new Panel(factory);
Window window = new Window(panel);

Neither Window or Panel know about the protocol.