public abstract class CollectionCondition extends AbstractCondition<List<WebElement>> {

    // если здесь не имплементировать, просится во вме кондишены сразу)))
    @Override
    public String identity() {
 ...

/*
    )))
    отлично написано
*/

public abstract class AbstractCondition<V> implements Condition<V> {

...
    public abstract String identity();
/*
    вот тут - убираем метод
*/
 public String toString() {
        return this.getClass().getSimpleName() + " for " + entity.identity() + " found by: " + entity + "\n expected: " + expected() + "\n actual: " + actual();
 }
 /*
    вот тут - уже ок - ты вызываешь entity.identity()
 */

public interface LazyEntity <T> {

    public T getWrappedEntity();

    public String identity();
}
/*
    это ок
*/
public abstract class AbstractLazyElement implements LazyElement {
...
    public String identity() {
        return "element";
    }
    /*
        это ок)
    */
public abstract class AbstractLazyCollection implements LazyCollection {
...
    public String identity() {
        return "collection";
    }
    /*
        это ок
    */
/*
    то есть все, что мешало - это объявленный абстрактный метод в AbstractCondition
    в AbstractCondition уберешь - и в потомках AbstractCondition сможешь убрать)
*/
*********************************************************************************************************
public abstract class AbstractLazyElement implements LazyElement {

...
    public LazyElement click() {
        waitFor(this).until(visible());
        actions().click(getWrappedEntity()).perform();
        return this;
    }
/*
    у вебэлемента есть метод click
    вместо actions().click(getWrappedEntity()).perform();
    вызывай getWrappedEntity().click()

    doubleClick() & hover() - да, надо реализовывать через actions()
    тут - можно проще
*/
**************************************
    public LazyElement pressEnter() {
        waitFor(this).until(visible());
        getWrappedEntity().sendKeys(Keys.ENTER);
        return this;
    }
/*
    можно переиспользовать LazyElement sendKeys(CharSequence... text)
*/
************************************************
/*

    следующий наворот )


    WebElement - это тоже интерфейс

    Если мы отнаследуем наш интерфейс LazyElement от WebElement
    Это то же самое что и заявить - "наш LazyElement - полная замена WebElement - и везде где вы его использовали
    вы теперь можете использовать наш лейзи враппер
    который помимо всех фич вебэлемента еще и будет ждать себя..."

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

    но тогда, при использовании переменной типа LazyElement - мы не получим функциональности WebElement

    потому тут правильнее именно отнаследовать LazyElement от WebElement

    Это в java-ООП мире достаточно прикольная практика -
    всегда, когда ты хочешь сделать какие-то штуки внутри объекта публичными -
    выносить их сначала в отдельный интерфейс - и потом его имплементировать

    потому что просто сделать какие-то штуки публичными - это недостаточно "строго"

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

    тут надо внимательно к вопросу подойти)

    в рамках LazyElement - не реализовывай методов, одноименных с методами WebElement
    просмотри в WebElement - какие методы объявлены
    и одноименных в LazyElement - не добавляй

    да, мы для некоторых методов потерям chainable возможности - изменится возвращаемый тип

    но зато не будет двусмысленностей

    в абстрактном классе AbstractLazyElement - реализуй все вебэлементовские методы
    думаю, проблем с этим не будет
    примеры уже есть

    думай - в каких методах и чего надо ждать - ничего не ждать / ждать видимости / ждать наличия в DOM

*/
*******************************************
/*
    следующий наворот )

    наворачиваем Collection )

        наследуем этот интерфейс и от Iterable<LazyElement>

        цель - уметь писать такой код

        elements = $$(...);
        for(LazyElement element:elements) {
            ...
        }

        т е уметь обходить нашу коллекцию элементов в таком варианте цикла

        чистая теория
        http://tutorials.jenkov.com/java-generics/implementing-iterable.html

        нам она практически не пригодится )
        просто для понимания - разумно ознакомиться

        достаточно понять, что
        при имплементировании интерфейса Iterable<...>
        надо будет реализовать метод
         public Iterator<ProxyElement> iterator()

        Дальше мы схитрим)

        List<...> тоже наследник Iterable<...>

        если мы внутри метода iterator()
            создадим и заполним список list типа List<LazyElement> элементами из коллекции

            то тогда можно вернуть в качестве результата метода iterator() - list.iterator();

        загвоздка в том, что в коллекции  getWrappedEntity()  возвращает значение типа List<WebElement>
        а мы хотим получить List<LazyElement>

        Вот и пришло время создать еще одного потомка для AbstractLazyElement
          назовем его LazyWrappedWebElement (обернутый веб элемент)
          будем передавать ему в конструктор вебЭлемент
          как ты понимаешь, его реазизация getWrappedEntity() - будет возвращать тот же веб элемент

        И теперь опять возвращаемся к методу iterator()
        Если в новый список List<LazyElement>
        Ты будешь складывать новосозданные объекты типа LazyWrappedWebElement
        То это будет ОК (т к LazyWrappedWebElement - потомок абстрактного класса который имплементирует интерфейс LazyElement)

        Проверяем новую функциональность на коде типа

            for (LazyElement element:tasks) {
                System.out.println(element.getText());
                element.shouldHave(text("а"));
            }

*/