Extending a class such that any parent class can be cast to it, in Java

Question

I have a feeling this is impossible, but if not it would be very useful.

I’m trying to extend a parent class in a way that the child class only has new methods, no new constructors, no new fields. So the underlying data structure of the child class is identical to the parent class. This tends to occur when I want to give added functions to a built in java class (e.g. Vector3d). Given that the underlying data is identical is it possible in any way to downcast an object initialized as the parent class to the child class so I can use the added functionality. As an example of what I mean see below

import javax.vecmath.Vector3d;

public class Vector3dPlus extends Vector3d{
    //same fields, same constructors as Vector3d

    public double extraMethod(){
        return x+y+z;
    }
}

Try to use the new method added to Vector3d

import javax.vecmath.Vector3d;     

public class Test {

    public static void main(String[] args) {
        Vector3d basic=new Vector3d(1,2,3);

        useExtraMethod(basic); //this line correctly raises an exception, but is there a way around that
    }

    public static void useExtraMethod(Vector3dPlus plus){
        System.out.println(plus.extraMethod());
    }
}

Clearly java gets upset with this because usually we can't guarantee that Vector3dPlus methods will work with all Vector3d. But is there anyway I can say to java that the underlying data structures are the same and so allow all downcasting from all Vector3d to Vector3dPlus.

The current way I deal with this is to put all the extra methods in a generic utilities class, but that's obviously a bit horrible

Answer 1

You can achieve it with method overloading and a copy constructor:

public class Vector3dPlus extends Vector3d {
    public Vector3dPlus(Vector3d vector) {
        super( ... ); // parameters from vector
    }

    // rest of your Vector3dPlus code
}

and in your test class, overload the method:

    public class Test {

        public static void useExtraMethod(Vector3d vector) {
            useExtraMethod(new Vector3dPlus(vector));
        }

        public static void useExtraMethod(Vector3dPlus plus){
             System.out.println(plus.extraMethod());
        }

        public static void main(String[] args) {
           Vector3d basic=new Vector3d(1,2,3);
           useExtraMethod(basic); // this line works now
        }
    }

Answer 2

I wouldn't focus on the underlying data structure of the class hierarchy but more on the external interface that is exposed.

In your example the Vector3DPlus class has an additional method not found on Vector3D. This differentiates its interface from the base class making them not perfectly substitutable. The compiler correctly raises an exception when the base type is passed to a method expecting the sub type.

I don't believe you can avoid some form of type checking to achieve your desired behavior. Somehow you need to ensure that only instances of Vector3DPlus are passed to your method. That is the price of downcasting.

public static void main(String[] args) {
       Vector3d basic=new Vector3d(1,2,3);

       if(basic instanceof Vector3dPlus){
       useExtraMethod(basic); //this line correctly raises an exception, but is there a way around that
       }
}

Answer 3

How about this?

import javax.vecmath.Vector3d;

public class Vector3dPlus extends Vector3d{
    Vector3dPlus {
        super(int a, int b, int c);
    }

    public double extraMethod(){
        return x+y+z;
    }
}

and use like this:

import javax.vecmath.Vector3d;

public class Test {

    public static void main(String[] args) {
       Vector3d basic=new Vector3d(1,2,3);
       Vector3dPlus plus=new Vector3dPlus(1,2,3);

       useExtraMethod(basic);
       useExtraMethod(plus);
    }

    public static void useExtraMethod(Vector3d vector){
        if (vector instanceof Vector3dPlus) {
            System.out.println(((Vector3dPlus) vector).extraMethod());
        }
    }
}

Answer 4

You can achieve it as explained below [there is no other way to achieve this if you dont want to use instanceof that is]:

public class Test {

    public static void main(String[] args) {
        Vector3dPlus basicPlus = new Vector3dPlus(1,2,3);
        Vector3d basic=basicPlus;

        useExtraMethod(basic); 
    }

    public static void useExtraMethod(Vector3dPlus plus){
        System.out.println(plus.extraMethod());
    }
}

Java has internal mechanism to check type casting. You can't bypass the basic fundamental of "child class is of type parent class" but "Parent class is not of type child class"