I know there are several similar topics with similar title but I have actually slightly different questions than other topics.

I have designed such a solution which abstract class implements and interface, and in the constructor it calls default method of interface to initialize a map.

Here is my interface:

```
   public interface ICalculator{

        int VALUE_OF_X= 10;
        int VALUE_OF_Y= 50;
        int VALUE_OF_Z = 70;

        Map<String, Integer> CHAR_VAL_MAP = new HashMap<String, Integer>(7);

        default void initValueMap(){
            CHAR_VAL_MAP.put("X", VALUE_OF_X);
            CHAR_VAL_MAP.put("Y", VALUE_OF_Y);
            CHAR_VAL_MAP.put("Z", VALUE_OF_Z);
        }

        public int calculate(final String inStr);
}

```

And created an abstract class:

```
 public abstract  class AbstractCalculator implements ICalculator{

    protected AbstractCalculator(){

        initValueMap();
    }
}

```

My idea was here to ensure that initValueMap method is called implicitly by the abstract class.

And the concreate class which extend abstract class is:

```
public class MyCalculator extends AbstractCalculator{

    public int calculate(final String romanNumberStr){
        // some logic code
    }
}

```

I have basically two question:

1) Is there any design problem or wrong usage of OOP concepts ? 
2) In C++. using const for the parameter is good programming behaviour. But in java word, it is not so common. Is it bad to use final in method parameters?