Can I check if a void method returned?

Question

I just want to ask, if it is possible to check if a void method "cancelled" itself by calling return;?

For example in my main I call calculate(myArray);, which is defined as follows:

public static void calculate(Object[] array) {
    if (array == null)
        return;
    // do stuff
}

Is their a way to know, if it returned or not? My thoughts were making a "global" boolean which is changed to true right before we return and then check its value in main or just change the return type to something like int and when it returned at the beginning we use return -1; and at the end of the method return 0;

Both is possible but I think neither of them is very good style. Is there an alternative?

Answer 1

You are right that the practices you described are considered bad in Java (and other modern languages).

The most common acceptable practices for your scenario are:

• Make the method throw an exception. Do this if the "failing" code path shouldn't happen under normal circumstances.
• Make the method's return type bool to indicate success or failure. Do this if the "failing" code path can happen under normal circumstances as well.

Answer 2

No, you cannot. From The Oracle Java tutorials - Returning a Value from a Method:

Any method declared void doesn't return a value. It does not need to contain a return statement, but it may do so. In such a case, a return statement can be used to branch out of a control flow block and exit the method and is simply used like this:

return;

There is no way from method invocation to determine if the void method was completed by a fall-through block or a return; statement.

Most other methods includes a return type of boolean and returns false when something went wrong, or simply throws an IllegalArgumentException.

Answer 3

You can utilize publisher - listener pattern :)

import java.awt.event.ActionListener;
import java.util.LinkedList;
import java.util.List;

public class Sample {

    private interface Event {

    }

    private static class ExitEvent implements Event {

    }

    private static class SucceedEvent implements Event {

    }

    private interface EventListener {
        void eventPerformed(Event e);
    }

    private static List<EventListener> listeners = new LinkedList<EventListener>();

    private static void addActionListener(EventListener l) {
        listeners.add(l);
    }

    private static void fireEvent(Event event) {
        for (EventListener l : listeners) {
            l.eventPerformed(event);
        }
    }

    public static void calculate(Object[] array) {
        if (array == null) {
            fireEvent(new ExitEvent());
            return;
        }

        fireEvent(new SucceedEvent());
    }

    public static void main(String[] args) {

        addActionListener(new EventListener() {

            public void eventPerformed(Event e) {

                if (e instanceof ExitEvent) {
                    System.out.println("Exit");
                } else if (e instanceof SucceedEvent) {
                    System.out.println("Success");
                }

            }

        });

        calculate(null);
        calculate(new Object[] {});

    }

}

Output:

Exit
Success

You can go much farther and remove those ugly ifs, by utilizing visitor pattern

import java.util.LinkedList;
import java.util.List;

public class Sample {

    private interface EventVisitor {
        void visit(ExitEvent event);

        void visit(SucceedEvent event);
    }

    private interface Event {
        void accept(EventVisitor visitor);
    }

    private static class ExitEvent implements Event {

        public void accept(EventVisitor visitor) {
            visitor.visit(this);
        }

    }

    private static class SucceedEvent implements Event {

        public void accept(EventVisitor visitor) {
            visitor.visit(this);
        }

    }

    private interface EventListener {
        void eventPerformed(Event e);
    }

    private static List<EventListener> listeners = new LinkedList<EventListener>();

    private static void addActionListener(EventListener l) {
        listeners.add(l);
    }

    private static void fireEvent(Event event) {
        for (EventListener l : listeners) {
            l.eventPerformed(event);
        }
    }

    public static void calculate(Object[] array) {
        if (array == null) {
            fireEvent(new ExitEvent());
            return;
        }

        fireEvent(new SucceedEvent());
    }

    public static void main(String[] args) {

        addActionListener(new EventListener() {

            public void eventPerformed(Event e) {

                e.accept(new EventVisitor() {

                    public void visit(SucceedEvent event) {
                        System.out.println("Success");

                    }

                    public void visit(ExitEvent event) {
                        System.out.println("Exit");

                    }
                });

            }

        });

        calculate(null);
        calculate(new Object[] {});

    }

}

Output:

Exit
Success