How do I make a new class by adding methods to an already existing library class in Java?

Question

I am trying to add some convenience methods to Java's BigDecimal and create a CustomBigDecimal class. Say I want to add a method reciprocal(). I have tried doing this with inheritence as follows:

public class CustomBigDecimal extends BigDecimal
{
   .....
   .....
   public CustomBigDecimal reciprocal()
   {
       .....
   }       
}

CustomBigDecimal foo1 = new CustomBigDecimal(1);
CustomBigDecimal foo2 = new CustomBigDecimal(2);
CustomBigDecimal foo2 = foo1.add(foo2); //cannot cast superclass to subclass

The problem with this approach is that I cannot cast a superclass to subclass (for reasons I am well aware of). And all the methods of the superclass return a BigDecimal. I have thought of a solution to solve this using composition as follows:

public class CustomBigDecimal 
{
    private BigDecimal val;
    CustomBigDecimal(BigDecimal val)
    {
       this.val = val;
    } 
    ......
    ......  
    public CustomBigDecimal add(CustomBigDecimal augend)
    {
        return new CustomBigDecimal(val.add(augend.getBigDecimal()));
    }       
    .....
    .....
    public CustomBigDecimal reciprocal()
    {
        ....
    } 
}

But if I go with the second approach, I have to write every method of BigDecimal.

Is there a better approach to solve this problem?

in case 1 you are allowed to return the subclass of the return type of the overridden method (as per [JLS 8.4.8.3](http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.8.3)) so you can return a `CustomBigDecimal` if you subclass; so you can override all of the library methods to return an instance of `CustomBigDecimal` — vandale, Nov 20 '13 at 17:43
super.add() returns a BigDecimal. So even if I override add() how will I convert it to CustomBigDecimal unless I implement the addition myself (in that case there is no point of extending BigDecimal). And the second method is better because I don't have to implement the internal logic behind the methods. Correct me if I am wrong. — Rohan Laishram, Nov 20 '13 at 17:50

score 4 · Accepted Answer · answered Nov 20 '13 at 17:53

4

If you aren't actually changing the representation of BigDecimal itself, and are just adding some helper methods, then you can have another class that contains your helper methods statically. ie

class BigDecimalMethods{
     public static BigDecimal reciprocal(BigDecimal bd){
     }
     //etc
}

answered Nov 20 '13 at 17:53

vandale

3,600
3
22
39

I am doing this right now. But I wanted to know if there's a cleaner approach to solve this like in objective-C (through categories and class extensions) – Rohan Laishram Nov 20 '13 at 17:59
no Java doesn't support those http://stackoverflow.com/questions/4359979/java-equivalent-to-c-sharp-extension-methods – vandale Nov 20 '13 at 18:05

score 1 · Answer 2 · answered Nov 20 '13 at 19:33

Forget about inheritance. It will force you to handle both CustomBigDecimals and non-custom BigDecimals.

Imagine what you would do if you wanted to add a convenience toProperCase() method to the String class (and this is a very common and frequent issue). You would be forced to create a StringUtils class, because the String class is final. The downside is that then you will need to use StringUtils.toProperCase(someString) instead of someString.toProperCase().

If the String class was not final, you could create a subclass and add the method there. But this would sucks, you still could not do someString.toProperCase(), you would need something like:

if (!(someString instanceof MyStringSubclass)) {
    someString = new MyStringSubclass(someString);
}
String somethingElse = ((MyStringSubclass) someString).toProperCase();

And, that code is indeed horrible. In your CustomBigDecimal class, you hit the same issue:

if (!(someBigDecimal instanceof CustomBigDecimal)) {
    someBigDecimal = new CustomBigDecimal(someBigDecimal);
}
CustomBigDecimal somethingElse = ((CustomBigDecimal) someBigDecimal).reciprocal();

And again, that sort of code sucks.

In ruby, javascript and some other languages, you could mixin some new method into an existing class without having to alter it. This would be the correct solution for the problem. Unfortunately, java does not allows this. So, the better solution is the utils approach:

public class BigDecimalUtils {
    private BigDecimalUtils() {}

    public static BigDecimal reciprocal(BigDecimal a) {
       ...
    }
}

The utils approach is an anti-pattern, but since there is no way to mixin a method into an existing java class, it is the best approach to do. Using a subclass is still a worse anti-pattern. The correct solution would be to add mixins to the java language, but this is of course not an option.

Note: I am not considering options regarding in altering the actual classes in the JDK's rt.jar file, nor to emulate that with bytecode-manipulating classloaders. That would be a serious overkill for this.

score 0 · Answer 3 · answered Nov 20 '13 at 17:47

0

You could do something like this:

CustomBigDecimal foo1 = new CustomBigDecimal(1);
CustomBigDecimal foo2 = new CustomBigDecimal(2);
CustomBigDecimal foo3 = new CustomBigDecimal(foo1.add(foo2).intValue());
    // Or floatValue()...

answered Nov 20 '13 at 17:47

quazzieclodo

831
4
10

score 0 · Answer 4 · answered Nov 20 '13 at 17:49

0

You will either have to implement a helper static method or a constructor like so:

public CustomBigDecimal(BigDecimal bigDecimal) {
    super(bigDecimal.toString());
}

CustomBigDecimal foo2 = new CustomBigDecimal(foo1.add(foo2));

answered Nov 20 '13 at 17:49

stackular

1,431
1
19
41

score 0 · Answer 5 · answered Nov 20 '13 at 17:50

But if I go with this approach, I have to implement every method of BigDecimal.

I don't think you will need to implement every method. Rather probably every constructor:

class CustomBigDecimal extends BigDecimal
{

    public CustomBigDecimal(BigInteger val) {
        super(val);
    }

    public CustomBigDecimal(int i)
    {
        super(String.valueOf(i));
    }

    public CustomBigDecimal(String str)
    {
        super(str);
    }
    public CustomBigDecimal(BigDecimal bigDecimal)
    {
       this(bigDecimal.toString());   
    }

   CustomBigDecimal foo1 = new CustomBigDecimal(1);
   CustomBigDecimal foo2 = new CustomBigDecimal(2);
   CustomBigDecimal foo3 = new CustomBigDecimal(foo1.add(foo2).toString());
   CustomBigDecimal foo4 = new CustomBigDecimal(foo1.add(foo2));

}

I was actually looking for a cleaner solution where I can use the CUstomBigDecimal exactly like a BigDecimal. I think using a static helper method would be better than the solution you are suggesting. — Rohan Laishram, Nov 20 '13 at 18:12

Floegipoky · Answer 6 · 2013-11-20T18:32:14.713

0

Vandale's answer is the best solution. However, if you really wanted to do this, just "override" the methods of BigDecimal that return a BigDecimal

public CustomBigDecimal abs() {
    return new CustomBigDecimal(super.abs());
}

The problems with this are that all of your new CustomBigDecimal-returning methods won't actually override BigDecimal's version, and that you'll need to override every constructor (there are a lot), plus an extra CustomBigDecimal(BigDecimal abs)

You can hopefully see how messy this is, and why I think you should go with Vandale's answer

edited Nov 20 '13 at 18:32

answered Nov 20 '13 at 18:08

Floegipoky

3,087
1
31
47

super.abs() returns a BigDecimal and you are trying to cast it to CustomBigDecimal. You cannot cast the super class to the sub class as I have stated in my approach 1. – Rohan Laishram Nov 20 '13 at 18:16
Whoops, brain fart. Fixed. Kind of proves my point about the unwieldiness though. – Floegipoky Nov 20 '13 at 18:33

How do I make a new class by adding methods to an already existing library class in Java?

6 Answers6