Tham số của hàm Java có thể yêu cầu giao diện tùy chọn không?

Tôi có hai giao diện trong Java (phiên bản 8) rất giống nhau. Tôi không thể thay đổi giao diện và không thể thay đổi các lớp thực hiện chúng.

public interface A {
    int get();
}

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

Bây giờ tôi có một chức năng mà việc thực hiện của nó phù hợp với cả hai giao diện (gần như). Tôi muốn nó làm một cái gì đó như thế:

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

Tôi không muốn sử dụng kiểm tra vì chức năng này nằm trong hệ thống chính của chương trình của tôi. Tôi muốn nó có hiệu suất tốt. Có thể làm điều này trong Java?

Biên tập:

Một giải pháp đơn giản sẽ là sao chép / dán foo()và thực hiện nó khác nhau cho mỗi giao diện. Nhưng trong thực tế foo()và các giao diện dài hơn thế và tôi đang cố gắng tránh sao chép mã.

Thật không may, không có cách nào để tạo ra mối quan hệ hồi tố giữa hai loại không liên quan.

Nếu bạn có thể thay đổi foo()và các yêu cầu của nó, bạn có thể sử dụng các giao diện chức năng khớp với các chữ ký mà bạn gọi bên trong foo. Tôi đang sử dụng IntSupplierở đây, với các biểu thức lambda tương ứng bằng cách sử dụng các triển khai cụ thể của Avà B.

Nói rằng bạn có những triển khai này:

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

Bạn có thể thay đổi foothành một cái gì đó như:

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

Và gọi nó theo cách này:

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

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

Cách duy nhất tôi có thể tưởng tượng là thế này:

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 không hỗ trợ điều này trực tiếp, nhưng bạn có thể tự tạo một "trình bao bọc kiểu liên kết". Một cái gì đó như thế này:

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();
}

Bạn cũng có thể thêm một số chức năng kiểm tra như hasSomethingElse(), nếu không có giá trị mặc định phù hợp để trả về, như 0ở trên ..