Generating Java Classes with Compile-time Value Parameters

I have a very similar model on my application and our solution was to simply keep a map of a dynamic size, similar to your solution 2.

You simply aren't going to need to worry about performance with a java array primative like that. We generate matrixes with upper-bound sizes of 100 columns (read: 100 dimensional vectors) by 10,000 rows, and we have had good performance with much more complex vector types than your solution 2. You might try sealing the class or marking methods as final to speed it up, but I think you're optimizing prematurely.

You can get some code-savings (at the cost of performance) by creating a base class to share your code:

public interface Vector(){

    abstract class Abstract {           
        protected abstract double[] asArray();

        int dimensions(){ return asArray().length; }

        double magnitude(){ 
            double sum = 0;
            for (double component : asArray()) {
                sum += component * component;
            }
            return Math.sqrt(sum);
        }     

        //any additional behavior here   
    }
}

public class Scalar extends Vector.Abstract {
    private double x;

    public double getX(){
        return x;
    }

    @Override
    public double[] asArray(){
        return new double[]{x};
    }
}

public class Cartesian extends Vector.Abstract {

    public double x, y;

    public double getX(){ return x; }
    public double getY(){ return y; }

    @Override public double[] asArray(){ return new double[]{x, y}; }
}

Then of course, if you're on Java-8+, you can use defaulted interfaces to make this even tighter:

public interface Vector{

    default public double magnitude(){
        double sum = 0;
        for (double component : asArray()) {
            sum += component * component;
        }
        return Math.sqrt(sum);
    }

    default public int dimensions(){
        return asArray().length;
    }

    default double getComponent(int index){
        return asArray()[index];
    }

    double[] asArray();

    // giving up a little bit of static-safety in exchange for 
    // runtime exceptions, we can implement the getX(), getY() 
    // etc methods here, 
    // and simply have them throw if the dimensionality is too low 
    // (you can of course do this on the abstract-class strategy as well)

    //document or use checked-exceptions to indicate that these methods throw IndexOutOfBounds exceptions (or a wrapped version)

    default public getX(){
        return getComponent(0);
    }
    default public getY(){
        return getComponent(1);
    }
    //...


    }

    //as a general rule, defaulted interfaces should assume statelessness, 
    // so you want to avoid putting mutating operations 
    // as defaulted methods on an interface, since they'll only make your life harder
}

Ultimately beyond that you're out of options with the JVM. You can of course write them in C++ and use something like JNA to bridge them in --this is our solution for some of the fast matrix operations, where we use fortran and intel's MKL-- but this is only going to slow things down if you simply write your matrix in C++ and call its getters/setters from java.

Consider an enum with each named Vector having a constructor that consists of an array (initialized in the parameter list with the dimension names or similar, or perhaps just an integer for the size or an empty components array - your design), and a lambda for the getMagnitude method. You could have the enum also implement an interface for setComponents/getComponent(s), and just establish which component was which in its usage, eliminating getX, et al. You would need to initialize each object with its actual component values before use, possibly checking that the input array size matches the dimension names or size.

Then if you extend the solution to another dimension, you just modify the enum and lambda.