CODEWITHSUNDEEP
javaooppolymorphism
Lucia Pasarin
Lucia Pasarin

Reputation: 2308

Implementing methods from an interface but with different parameters

I am looking for a good way to have different implementations of the same method which is defined in an interface but with different parameter types. Would this be possible?

In order to clarify this, suppose I have an interface Database and two implementing classes Database1 and Database2. Database has a method createNode(...) and another one modifyNode(...). The problem is that for Database1 the return type of the createNode method should be a long (the identifier). For Database2, however, it would be an object specific from the technology (in this case OrientDB but this doesn't matter too much, it is simply something that extends Object, of course). And also both create(...) return types should be used as one of modifyNode(...) parameters.

What I was thinking to do is:

`public interface Database {
    public Object createNode(...);
    public void modifyNode(Object id, ...);
    ...
 }`

public class Database1 { 
    @Override
    public Object createNode(...) { 
        ...
        long result = // obtain id of created node
        return Long.valueOf(result);
    }

    @Override
    public void modifyNode(Object id, ...) { 
        ...
        // use id as ((Long)id).longValue();
    }
}

public class Database2 { 
    @Override
    public Object createNode(...) { 
        ...
        SomeObject result = // obtain id of created node
        return result;
    }

    @Override
    public void modifyNode(Object id, ...) { 
        ...
        // use id as (SomeObject)id
    }
}

I wanted to know if there is a better way to do this. Specially to avoid Long -> long and long -> Long conversions. I saw many similar questions here in StackOverflow but none of them were what I was looking for. Thank you very much in advance.

Upvotes: 4

Views: 7818

Answers (2)

lifus
lifus

Reputation: 8482

Here's an example of Generics

Database

public interface Database<T> {
    public T createNode(...);
    public void modifyNode(T id, ...);
    ...  
}

Database1

class Database1 implements Database<Long> { 
    @Override
    public Long createNode(...) { 
        ...
        long result = // obtain id of created node
        return result;
    }

    @Override
    public void modifyNode(Long id, ...) { 
        ...
        // use id
    }
}

Database2

public class Database2 implements Database<SomeObject> { 
    @Override
    public SomeObject createNode(...) { 
        ...
        SomeObject result = // obtain id of created node
        return result;
    }

    @Override
    public void modifyNode(SomeObject id, ...) { 
        ...
        // use id as (SomeObject)id
    } 
}

Btw, don't worry about autoboxing. You are using JDK >= 5 since there are @Override annotations.

Upvotes: 6

Achintya Jha
Achintya Jha

Reputation: 12843

I think you want Generic Methods.

Generic methods are methods that introduce their own type parameters. This is similar to declaring a generic type, but the type parameter's scope is limited to the method where it is declared. Static and non-static generic methods are allowed, as well as generic class constructors.

The syntax for a generic method includes a type parameter, inside angle brackets, and appears before the method's return type. For static generic methods, the type parameter section must appear before the method's return type.

Upvotes: 2

Related Questions