Does this "call-inversion" pattern have a name?

Question

I just answered another question (Select method based on field in class), and I was wondering if the pattern had a name.

Call action.applyX(a), where X depends on some property of a (e.g. type in the example), so you instead call a.apply(action) and let a (or Type) call the appropriate applyX.

Is there a name for that?

public enum Type {
    INTEGER {
        @Override
        public void apply(Action action, A a) {
            action.applyInteger(a);
        }
    },
    STRING {
        @Override
        public void apply(Action action, A a) {
            action.applyString(a);
        }
    };
    public abstract void apply(Action action, A a);
}

public interface Action {
    public void applyInteger(A a);
    public void applyString(A a);
}

public class A {
    private Type type;
    ...
    public void apply(Action action) {
        this.type.apply(action, this);
    }
}

Update

The above is just an example, and using type as the selector is not the important part.

The selection criteria for deciding which X method to call can be anything. In a dice game, X could be 'Odd' or 'Even' and class A could be 'Dice' with a 1-6 int value.

The example is using abstract enum methods as a way to avoid a switch statement (less error prone). The abstract method implementations are a kind of switching technology, in this case the way to choose the appropriate X.

Update 2

This question is about the pattern used to avoid switch statements for doing "action" logic outside of the class (A), not about changing the behavior of A (strategy/policy), where the "switch choices" are well defined, e.g. as a type enum (example above), or by well-known subclasses of A.

As an example, A could define a table column. The class should not be tightly coupled to implementation code, but there will be many different implementation methods ("Actions") that must process column types differently.

Actions might be a call to the appropriate getXxx method on ResultSet, call the appropriate setXxx method on PreparedStatement, format the value for display, render it the XML or Json, parse the value, ...

All these methods would either need a switch statement, or they could implement an interface with the "typed" methods, and ask the class "please call the right one for me".

This question is becoming pretty long. Sorry if I'm not stating the pattern clearly.

Answer 1

This resembles the Visitor pattern, because you are basically adding new operations to A without changing it (you are externalizing its operations to a separate class).

this.type.apply(action, this);

plays the role of:

visitor.visit(this);

If a new action is added (say applyBoolean), you would need to change the code for A if you used switch statement. However, in your implementation you would just use the new visitor subclass (a new Type enum constant) which implements the code that would otherwise be placed in A.

Answer 2

This is the beginnings of a Strategy Pattern

It's a Behavorial Pattern, as opposed to the more common Structural Patterns.

In your example you're not taking full advantage of the pattern. Since you use a single interface for all your strategies

In computer programming, the strategy pattern (also known as the policy pattern) is a software design pattern that enables an algorithm's behavior to be selected at runtime.

Answer 3

I think the name for this is just the name of the language feature used, polymorphism.

Answer 4

Looks like the type decomposition you would find in functional languages

Answer 5

I would say this is an example of using the strategy pattern. The example in the Wikipedia article (written in C#) also uses an enum.