Каков наилучший способ работы со многими интерфейсами?

Ответ 1

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

IA ia = x.lookupCapability(IA.class);
if (ia != null) {
    ia.a();
}

Он подходит здесь, как и для многих интерфейсов, желание разделить уровни, и вы можете более легко комбинировать случаи взаимозависимых интерфейсов (if (ia != null && ib != null) ...).

Ответ 2

Если у вас есть метод (полукод)

void doSomething(IA & ID & IE thing);

тогда моя главная проблема: не может ли doSomething быть лучше адаптирован? Может быть, лучше разделить функциональность? Или сами интерфейсы плохо адаптированы?

Я несколько раз сталкивался с подобными вещами, и каждый раз было лучше сделать большой шаг назад и переосмыслить полное разбиение логики - не только из-за того, что вы упомянули, но и из-за других проблем.

Поскольку вы сформулировали свой вопрос очень абстрактно (т.е. без разумного примера), я не могу сказать, насколько это целесообразно и в вашем случае.

Ответ 3

Я бы избегал всех "искусственных" интерфейсов/типов, которые пытаются представить комбинации. Это просто плохой дизайн... что произойдет, если вы добавите еще 5 интерфейсов? Число комбинаций взрывается.

Кажется, вы хотите знать, реализует ли какой-либо экземпляр какой-либо интерфейс (-ы). Возможные варианты:

• use instanceof - нет стыда
• использовать отражение, чтобы обнаружить интерфейсы через object.getClass().getInterfaces() - вы можете написать некоторый общий код для обработки файлов
• используйте отражение, чтобы обнаружить методы с помощью object.getClass().getMethods() и просто вызовите те, которые соответствуют известному списку методов ваших интерфейсов (этот подход означает, что вам не нужно заботиться о том, что он реализует), звучит просто и, следовательно, звучит как хороший идея)

Вы не указали нам, почему именно вы хотите знать, поэтому трудно сказать, что такое "лучший" подход.

Edited

OK. Поскольку добавлена ​​дополнительная информация, это начинает иметь смысл. Лучшим подходом здесь является использование обратного вызова: вместо передачи в родительском объекте передайте интерфейс, который принимает "дочерний".

Это упрощенная версия шаблона посетителя. Ваш код вызова знает, с чем он звонит, и как он может обрабатывать ребенка, но код, который перемещается и/или решает добавить ребенка, не имеет контекста вызывающего.

Ваш код будет выглядеть примерно так (caveat: May не компилируется, я просто набрал его):

public interface Parent<T> {
    void accept(T child);
}

// Central code - I assume the parent is passed in somewhere earlier
public void process(Parent<T> parent) {
    // some logic that decides to add a child
    addChild(parent, child);
}

public void addChild(Parent<T> parent, T child ) {
    parent.accept(child);
}

// Calling code
final IRevisionable revisionable = ...;
someServer.process(new Parent<T> {
    void accept(T child) {
        T newRev = revisionable.createNewRevision();
        newRev.addChild(child);
    }
}

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

Ответ 4

На самом деле решение 1 является хорошим решением, но вы должны найти лучшее именование.

На самом деле вы бы назвали класс, реализующий интерфейс IPersistable_MasterSlaveCapable_XmlIdentifierProvider? Если вы придерживаетесь хорошего соглашения об именах, оно должно иметь значимое имя, исходящее из модельного объекта. Вы можете дать интерфейсу одно имя с префиксом I.

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

Ответ 5

Моя ситуация противоположная: я знаю, что в определенный момент кода, foo должен реализовать IA, ID и IE (в противном случае он не смог бы получить это далеко). Теперь мне нужно вызвать методы во всех трех интерфейсах. Какой тип должен ли foo получить?

Можете ли вы полностью обойти проблему, передав (например) три объекта? Поэтому вместо:

doSomethingWithFoo(WhatGoesHere foo);

:

doSomethingWithFoo(IA foo, ID foo, IE foo);

Или вы можете создать прокси-сервер, который реализует все интерфейсы, но позволяет отключать определенные интерфейсы (т.е. вызов "неправильного" интерфейса вызывает UnsupportedOperationException).

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