Как реализовать метод с неизвестным количеством аргументов?

вы можете достигнуть чего вы хотите, с некоторыми изменениями и некоторой помощью функционального программирования...

TL; DR

основная идея заключается в том, что transform метод не принимает никаких аргументов. Вместо этого он вернет экземпляр некоторого функционального интерфейса.

реализация данного функционального интерфейса будет состоять из кода, который был бы выполнен transform метод, если он был аргументы.

для представления аргументов разных типов и / или разного количества аргументов для каждого подкласса A интерфейс, мы будем использовать ковариацию в возвращаемом типе метода transform.

это означает, что функциональный интерфейс будет общим (так что тип аргументов может быть разным для каждого подкласса A), и что будут подинтерфейсы, которые расширят этот функциональный интерфейс, каждый из которых принимает другой количество аргументов в одном абстрактном методе. Это позволит transform() возвращаемое значение метода должно иметь либо 1, 2, 3,... аргументы etc.

для выполнения кода, возвращаемого transform() метод, мы будем делать:

instanceOfB.transform().execute("hello");
instanceOfC.transform().execute(1, 'a');
instanceOfD.transform().execute(1, "hello");

наконец, чтобы иметь возможность выполнять код в общем виде, базовый функциональный интерфейс определяет метод varargs executeVariadic(Object... args), который будет реализован как метод по умолчанию каждым дочерним функциональным интерфейсом, делегируя его execute метод и приведение аргументов по мере необходимости.

теперь длинная версия...

давайте начнем с переименования вашего A интерфейс к чему-то более описательному. Как он определяет метод под названием transform, назовем его Transformer.

тогда, давайте создадим функциональный интерфейс, который будет представлять transform метод Transformer интерфейс. Вот оно есть:

@FunctionalInterface
public interface Transformation {

    void executeVariadic(Object... args);
}

этот интерфейс просто определяет один абстрактный метод (SAM), который получает Object... аргумент с varargs. Он существует, чтобы подинтерфейсы могли его переопределить.

теперь, давайте создадим Transformation1 функциональный интерфейс, который расширяет Transformation интерфейс:

@FunctionalInterface
public interface Transformation1<A> extends Transformation {

    void execute(A a);

    @Override
    @SuppressWarnings("unchecked")
    default void executeVariadic(Object... args) {
        this.execute((A) args[0]);
    }
}

этой Transformation1<A> функциональный интерфейс является общим и определяет один абстрактный метод execute, который принимает один аргумент типа A. The executeVariadic метод переопределено как метод по умолчанию, который делегирует его выполнение execute метод, бросая первый аргумент соответственно. Этот бросок генерирует предупреждение, но о, хорошо... нам лучше научиться жить с этим.

Теперь создадим аналогичный интерфейс с двумя параметрами универсального типа и execute метод, который получает два аргумента, типы которых соответствуют параметрам универсального типа:

@FunctionalInterface
public interface Transformation2<A, B> extends Transformation {

    void execute(A a, B b);

    @Override
    @SuppressWarnings("unchecked")
    default void executeVariadic(Object... args) {
        this.execute((A) args[0], (B) args[1]);
    }
}

идея та же:Transformation2 интерфейс расширяет Transformation интерфейс и мы переопределяем executeVariadic метод, чтобы он был делегирован execute метод, бросая аргументы соответственно (и подавляя раздражающее предупреждение).

для полноты картины введем Transformation3 интерфейс, который аналогичен предыдущему TransformationX ones:

@FunctionalInterface
public interface Transformation3<A, B, C> extends Transformation {

    void execute(A a, B b, C c);

    @Override
    @SuppressWarnings("unchecked")
    default void executeVariadic(Object... args) {
        this.execute((A) args[0], (B) args[1], (C) args[2]);
    }
}

надеюсь, что картина уже ясна. Вы должны создать столько TransformationX интерфейсы в качестве аргументов, которые вы хотите поддерживать для transform метод Transformer интерфейс (A интерфейс в вашем вопросе, помните, что я переименовал его).

пока все хорошо, я знаю, что этот ответ длинный,но мне нужно было определить интерфейсы выше, чтобы теперь их можно было использовать для объединения всех частей.

так A интерфейс? Давайте не только изменим его название на Transformer, но и подпись его transform способ:

@FunctionalInterface
public interface Transformer {

    Transformation transform();
}

теперь это ваш базовый интерфейс. The transform метод не имеет аргументов, но возвращает Transformation вместо.

давайте посмотрим, как реализовать свой B, C и D теперь классы. Но сначала, позвольте мне переименовать их в TransformerB, TransformerC и TransformerD, соответственно.

здесь TransformerB:

public class TransformerB implements Transformer {

    @Override
    public Transformation1<String> transform() {
        return a -> System.out.println(a); // or System.out::println
    }
}

важная вещь здесь-использование ковариации в возвращаемом типе transform метод. И я использую Transformation1<String> type, который является подтипом Transformation и указывает, что на TransformerB класс, transform метод возвращает преобразование, которое принимает один аргумент типа String. Как Transformation1 интерфейс-это тип SAM, я использую лямбда-выражение для его реализации.

вот как вызвать код внутри TransformerB.transform способ:

TransformerB b = new TransformerB();
b.transform().execute("hello");

b.transform() возвращает экземпляр Transformation1, которого execute метод немедленно вызывается с помощью его ожидает.

теперь давайте посмотрим на реализацию TransformerC:

public class TransformerC implements Transformer {

    @Override
    public Transformation2<Integer, Character> transform() {
        return (a, b) -> System.out.println(a + b);
    }
}

опять же, ковариация в возвращаемом типе transform метод позволяет нам вернуть конкретный Transformation в этом случае Transformation2<Integer, Character>.

использование:

TransformerC c = new TransformerC();
c.transform().execute(1, 'A');

на TransformerD пример, я использовал преобразование из трех аргументов:

public class TransformerD implements Transformer {

    public Transformation3<Integer, Double, String> transform() {
        return (a, b, c) -> System.out.println(a + b + c);
    }
}

использование:

TransformerD d = new TransformerD();
d.transform().execute(12, 2.22, "goodbye");

это все типобезопасно, потому что общие типы могут быть указаны в TransformationX тип возврата каждого бетона transform способ реализация. Однако использовать примитивные типы невозможно, поскольку примитивные типы нельзя использовать в качестве параметров универсального типа.

относительно того, как назвать transform метод в общем виде, это просто:

void callTransf(Transformer a, Object... args) {
    a.transform().executeVariadic(args);
}

вот почему метод. И это переопределено в каждом TransformationX интерфейс, так что его можно использовать полиморфно, как в коде выше.

вызов callTransf метод простой тоже:

callTransf(b, "hello");
callTransf(c, 1, 'A');
callTransf(d, 12, 2.22, "goodbye");