Kann der Parameter einer Java-Funktion optionale Schnittstellen erfordern?

Ich habe zwei Schnittstellen in Java (Version 8), die sehr ähnlich sind. Ich kann die Schnittstellen nicht ändern und kann die Klassen, die sie implementieren, nicht ändern.

public interface A {
    int get();
}

public interface B {
    int get();
    int somethingelse();
}

Jetzt habe ich eine Funktion, deren Implementierung (fast) auf beide Schnittstellen passt. Ich möchte, dass es so etwas macht:

public int foo((A | B) p) {
    int ret = 0;
    if (p instanceof B) {
        ret = p.somthingelse();
    }
    return ret + p.get();
}

Ich möchte keine Inspektion verwenden, da sich diese Funktion in der Hauptpipeline meines Programms befindet. Ich möchte, dass es eine gute Leistung hat. Ist das in Java möglich?

Bearbeiten:

Eine einfache Lösung besteht darin, foo()sie für jede Schnittstelle anders zu kopieren / einzufügen und zu implementieren. Aber in Wirklichkeit sind foo()die Schnittstellen viel länger und ich versuche, Codeduplikationen zu vermeiden.

Es gibt leider keine Möglichkeit, eine solche rückwirkende Beziehung zwischen zwei nicht verwandten Typen herzustellen.

Wenn Sie Änderungen foo()und deren Aufrufe vornehmen können, können Sie möglicherweise funktionale Schnittstellen verwenden, die mit den Signaturen übereinstimmen, die Sie im Inneren aufrufen foo. Ich verwende IntSupplierhier mit entsprechenden Lambda-Ausdrücken konkrete Implementierungen von AundB .

Angenommen, Sie haben diese Implementierungen:

class AImpl implements A {
     //implementation
}
class BImpl implements B {
     //implementation
}

Sie können foozu etwas wechseln wie:

public int foo(IntSupplier get, IntSupplier somethingElse) {
    int ret = 0;
    if (somethingElse != null) {
        ret = somethingElse.getAsInt();
    }
    return ret + get.getAsInt();
}

Und nenne es so:

A a = new AImpl();
B b = new BImpl();

int result = this.foo(a::get, b::somethingelse);

Ich kann mir nur Folgendes vorstellen:

public int foo(A p) {
    return internal_foo(p);
}

public int foo(B p) {
    return internal_foo(p);
}

private int internal_foo(Object p) {
    if (p instanceof A) {
        return ((A)p).get();
    }
    if (p instanceof B) {
        B b = (B)p;
        ret = b.somthingelse();
        return ret + b.get();
    }
    throw new ClassCastException("Wrong type");
}

Afaik, Java unterstützt dies nicht direkt, aber Sie können manuell einen "Type-Union-Wrapper" erstellen. Etwas wie das:

abstract class AorB {
    public static AorB wrap(A a) {
        return new AWrapper(a);
    }

    public static AorB wrap(B b) {
        return new BWrapper(b);
    }

    abstract int get();
    abstract int somethingElse();
}

class AWrapper extends AorB {
    private final A a;

    AWrapper(A a) {
        this.a = a;
    }

    @Override
    int get() {
        return a.get();
    }

    @Override
    int somethingElse() {
        return 0;
    }
}

class BWrapper extends AorB {
    private final B b;

    BWrapper(B b) {
        this.b = b;
    }

    @Override
    int get() {
        return b.get();
    }

    @Override
    int somethingElse() {
        return b.somethingElse();
    }
}

// and then

public int foo(A a) {
    return fooImpl(AorB.wrap(a));
}

public int foo(B b) {
    return fooImpl(AorB.wrap(b));
}

int fooImpl(AorB p) {
    return p.get() + p.somethingElse();
}

Sie können auch einige Inspektionsfunktionen hinzufügen hasSomethingElse(), z. B. wenn kein geeigneter Standardwert zurückgegeben werden soll, wie 0oben.