Несколько уровней подклассов и метод построения цепочки

Question

Я работаю по следующей структуре:

• Buffer
• XBuffer расширяет Buffer
• XYBuffer расширяет XBuffer

Все объекты должны быть инстанциируемый, так нет abstract, чтобы поддерживать совместимость вперед.

я придумал следующее, ловушками/вопросов, которые я опишу ниже:

public class Buffer<S extends Buffer<S>> { 
    protected final int bufferType; 
    protected final int bufferDataType; 

    protected int bufferId; 
    protected boolean created; 

    public Buffer(final int bufferType, final int bufferDataType) { 
     this.bufferType = bufferType; 
     this.bufferDataType = bufferDataType; 
    } 

    @SuppressWarnings("unchecked") 
    public S create() { 
     assertNotCreated(); 
     bufferId = GL15.glGenBuffers(); 

     created = true; 
     return (S)this; 
    } 

    @SuppressWarnings("unchecked") 
    public S bind() { 
     assertCreated(); 
     GL15.glBindBuffer(bufferType, bufferId); 

     return (S)this; 
    } 

    @SuppressWarnings("unchecked") 
    public S fillData(final float[] data) { 
     assertCreated(); 

     FloatBuffer dataBuffer = BufferUtils.createFloatBuffer(data.length).put(data); 
     dataBuffer.flip(); 
     GL15.glBufferData(bufferType, dataBuffer, bufferDataType); 

     return (S)this; 
    } 

    public void delete() { 
     assertCreated(); 

     GL15.glDeleteBuffers(bufferId); 
    } 

    public int getBufferId() { 
     return bufferId; 
    } 

    public boolean hasBeenCreated() { 
     return created; 
    } 

    private void assertCreated() { 
     if (!hasBeenCreated()) { 
      throw new RuntimeException("Buffer has not been created."); 
     } 
    } 

    private void assertNotCreated() { 
     if (hasBeenCreated()) { 
      throw new RuntimeException("Buffer has been created already."); 
     } 
    } 

    @Override 
    public String toString() { 
     return "Buffer(" + bufferType + ", " + bufferDataType + ", " + bufferId + ", " + created + ")"; 
    } 
} 

---

public class ArrayBuffer<S extends ArrayBuffer<S>> extends Buffer<S> { 
    public ArrayBuffer(final int bufferDataType) { 
     super(GL15.GL_ARRAY_BUFFER, bufferDataType); 
    } 
} 

---

public class StaticDrawArrayBuffer extends ArrayBuffer<StaticDrawArrayBuffer> { 
    public StaticDrawArrayBuffer() { 
     super(GL15.GL_STATIC_DRAW); 
    } 
} 

Сейчас происходит следующее:

• StaticDrawArrayBuffer работает, как и ожидалось.
• ArrayBuffer не работает должным образом, так как я не могу создать экземпляр без использования дженериков. (Имейте в виду: дженерики, используемые здесь, только там, чтобы помочь мне, а не на самом деле предоставлять общие функции)
• Buffer не работает должным образом с той же проблемой, что и ArrayBuffer.

Что мне нужно?

• Все, что есть сейчас, за исключением того, что я могу создать экземпляр Buffer и ArrayBuffer без использования дженериков.

Как бы это сделать?

Для уточнения Более того, эти заявления должны все компиляции:

• Buffer buffer = new Buffer().create().bind();
• ArrayBuffer arrayBuffer = new ArrayBuffer().create.bind();
• StaticDrawArrayBuffer staticDrawArrayBuffer = new StaticDrawArrayBuffer().create.bind()

Если бы я не использовать какие-либо генерики вообще, то new ArayBuffer().create() будет возвращать Buffer, в результате чего его нельзя назначить ArrayBuffer. Он оставляет цепочку методов Buffer неповрежденными, но, кроме того, она также нарушится, если цепочка будет содержать методы, доступные только для ArrayBuffer.

Если это помогает, у меня есть возможность использовать Java 8, если это почти без ошибок (должно быть, я думаю?), Учитывая, что этот проект долго не будет видеть реальный дневной свет.

Answer 1

Как насчет возвратных типов Covariant вместо дженериков?

public class ArrayBuffer extends Buffer { 
    public ArrayBuffer(final int bufferDataType) { 
     super(GL15.GL_ARRAY_BUFFER, bufferDataType); 
    } 

    public ArrayBuffer create() { 
     super.create(); 
     return this; 
    } 
    public ArrayBuffer bind() { 
     super.bind(); 
     return this; 
    } 
} 

public class StaticDrawArrayBuffer extends ArrayBuffer { 
    public StaticDrawArrayBuffer() { 
     super(GL15.GL_STATIC_DRAW); 
    } 


    public StaticDrawArrayBuffer bind() { 
     super.bind(); 
     return this; 
    } 
} 

AFAIK это должно составить в настоящее время:

Buffer buffer = new Buffer().create().bind(); 
ArrayBuffer arrayBuffer = new ArrayBuffer().create().bind(); 
StaticDrawArrayBuffer staticDrawArrayBuffer = new StaticDrawArrayBuffer().create().bind() 

Answer 2

Одна из возможностей заключается в том, чтобы отделить часть вашего кода, которая не использует дженерики из общего дерева наследования (что, на мой взгляд, является довольно неуклюжим, но это в основном проблема с тем, как была разработана Java и выбор дизайна, сделанный при добавлении дженериков к языку).

Что я имею в виду, что это сделать следующее:

public class Buffer extends BaseBuffer<Buffer> { 
    public Buffer(final int bufferType, final int bufferDataType) { 
     super(bufferType, bufferDataType); 
    }  
} 

public class ArrayBuffer extends BaseArrayBuffer<ArrayBuffer> { 
    public ArrayBuffer(final int bufferDataType) { 
     super(bufferDataType); 
    } 
} 

Где BaseBuffer и BaseArrayBuffer являются классы, которые вы звоните Buffer и ArrayBuffer.

(Хотя это кажется, что вы, возможно, уже делают это, основываясь на одном из ваших комментариев?)

Проблема этого метода состоит в том, что вы не могли пройти StaticDrawArrayBuffer как ArrayBuffer или ArrayBuffer как Buffer (или хранить их в переменных этих типов), поскольку они больше не являются подклассами этих конкретных типов. Вы должны использовать что-то вроде BaseArrayBuffer<StaticDrawArrayBuffer> и BaseBuffer<ArrayBuffer> для этого.

Answer 3

Я настоятельно рекомендую вам пересмотреть вашу архитектуру. Инициирование как детей, так и родительских классов - плохая, плохая идея. Предположим, однажды вы захотите изменить родительское поведение (потому что вы его используете и требования изменились), оставив ребенка неповрежденным. Что тогда?

Используйте стратегии вместо этого. Укажите интерфейс буфера (зачем он нужен? Что он должен делать?) И дайте каждому экземпляру Стратегию, чтобы выполнить свою задачу.

Тогда вы будете иметь только буфер, который содержит буферы и стратегии для реализации вашей логики:

public interface BufferingStrategy 
{ 
    public Buffer create() ; 
    public Buffer bind(); 
    public Buffer fillData(final float[] data); 
}