从另一个组件更新组件的状态

Question

I have a class

class TableComponent {
    tableBody
    tableHeader
    tableFooter
}

TableHeader has a button that should be enabled or disabled depending on the state of tableBody

class TableHeader {
    button

    void enableButton(false|true)
}

To handle this I pass instance of TableHeader to TableBody like this

new TableBody(tableHeader);

and inside the tableBody I do some actions and invoke tableHeader.enableButton()

But is there a way not to pass the reference of tableHeader into the body? Would use for example of EventBus better? Or for join all table classes into a single class?

Answer 1

You're very close to the Observer Pattern already. The missing piece is just to create the Pub/Sub interfaces, so that when you pass the header into the body, you have a layer of abstraction in place that prevents concrete table components from coupling to each other directly.

public class MainJava {
    interface Publisher { void subscribe(Subscriber s); }
    interface Subscriber { void update(); }

    public static void main(String... args) {
        TableComponent component = new TableComponent(new TableBody(), new TableHeader(), new TableFooter());
        component.setBodyText("Hello World");
    }

    static class TableComponent {
        final TableBody body;
        final TableHeader header;
        final TableFooter footer;

        public TableComponent(TableBody body, TableHeader header, TableFooter footer) {
            this.body = body;
            this.header = header;
            this.footer = footer;
            body.subscribe(header);
        }
        public void setBodyText(String newBody) {
            body.edit(newBody);
        }
    }

    static class TableBody implements Publisher {
        final Set<Subscriber> subscribers = ConcurrentHashMap.newKeySet();
        @Override
        public void subscribe(Subscriber s) {
            subscribers.add(s);
        }
        void edit(String newBody) {
            System.out.println(newBody);
            subscribers.forEach(Subscriber::update);
        }
    }
    static class TableHeader implements Subscriber {
        @Override
        public void update() {
            System.out.println("Toggle Button");
        }
    }
    static class TableFooter {}
}

Although the line body.subscribe(header); may appear no different from new TableBody(tableHeader); it's critical in the former that body sees header only as a Subscriber whereas in the latter body is aware that header is a TableHeader . That layer of abstraction is the difference between tight coupling and loose coupling.