Question

I have an interface Schema, and another called SchemaParser.
SimpleSchemaParser implements SchemaParser and SimpleSchema implements Schema.

SimpleSchemaParser has a method parseSchema() which returns a Schema. This way, SimpleSchemaParser.parseSchema() would return a Schema object. But I know that SimpleSchemaParser would always return a SimpleSchema. How should I change my design to make this apparent, rather than always having to cast the result to SimpleSchema? Should I go for generics in this case?

Answer 1

You can indeed use generics, but they’re not required:

class SchemaExample 
{
    interface Schema 
    {
        // methods go here
    }

    interface SchemaParser 
    {
        Schema parseSchema();
    }

    class SimpleSchema implements Schema 
    {
        // implementation of Schema's methods
    }

    class SimpleSchemaParser implements SchemaParser 
    {
        @Override
        public SimpleSchema parseSchema() 
        {
            // real business logic here...
            return new SimpleSchema();
        }   
    }

    void usage() 
    {
        SimpleSchema schema = new SimpleSchemaParser().parseSchema();
    }
}

A slightly broader question is: why do you care which implementation of schema is returned? Are there methods that only exist on SimpleSchema? Can these move up to the interface Schema?