Abstract function with different parameters

Question

I want to declare an abstract class with an abstract function calc() and use this with different types of parameter.

public abstract class AbstractCalculation{
    public abstract double calc();
    ...
}

public StringClass extends AbstractCalculation{
    public double calc(String a, String b);
}

public DoubleClass extends AbstractCalculation{
    public double calc(double a, double b);
}

How can I solve this problem?

https://en.wikipedia.org/wiki/Generics_in_Java – luk2302 Mar 27 '18 at 09:50 — luk2302, Mar 27 '18 at 09:50

Youcef LAIDANI · Accepted Answer · 2018-03-27T10:01:15.467

Maybe you mean to use Generics like this :

public abstract class AbstractCalculation<T> {
    public abstract double calc(T...params);//Here you can pass N param with any type
}

To extends from this abstract class, you can use :

public class DoubleClass extends AbstractCalculation<Double> {

    @Override
    public double calc(Double... params) {
        //Your action here
    }
}

public class StringClass extends AbstractCalculation<String> {

    @Override
    public double calc(String... params) {
        //Your action here
    }
}

Vicky Thakor · Answer 2 · 2018-03-27T09:59:52.437

Use Generics https://docs.oracle.com/javase/tutorial/java/generics/why.html

public abstract class Calculator<T, R>{
    public  abstract Double calc(T t, R r);
}

StringClass.java

public class StringClass extends Calculator<String, String>{

    @Override
    public Double calc(String t, String r) {
        return null; //TODO your logic
    }
}

DoubleClass.java

public class DoubleClass extends Calculator<Double, Double>{

    @Override
    public Double calc(Double t, Double r) {
        return null; //TODO your logic
    }
}

In case you want flexible return type.

CalculatorV1.java

public abstract class CalculatorV1<T, R, V> {
    public abstract V calc(T t, R r);
}

DoubleClassV1.java

public class DoubleClassV1 extends CalculatorV1<Double, Double, Integer>{

    @Override
    public Integer calc(Double t, Double r) {
        return null; //TODO your logic
    }
}

score 1 · Answer 3 · edited Mar 27 '18 at 10:18

You can do that by using Generics but you can't use primitive datatypes with them.

To learn more about Generics see here.

public abstract class AbstractCalculation<T, V> {
    public abstract T calc(T t, V v);
    ...
}

Now extend this class with Types.
Like:

class IntegerAddImpl extends AbstractCalculation<Integer, Integer> {
    @Override
    public Integer calc(Integer t, Integer v) {
        return t + v;
    }
}
class StringAddImpl extends AbstractCalculation<String, String>{
    @Override
    public String calc(String t, String v) {
        return t + v;
    }
}

Abstract function with different parameters

3 Answers3