Is it a good way to implement Distance with diffrent units

I was looking for some good patterns to have possibility to express distance in different units. I found Martin Fowler article about quantities and I programmed something like:

Here is Distance class ( I think it is not necessery to make it abstract ):

public class Distance {
    double mValue;
    DistanceUnit mUnit;

    public Distance(double value, DistanceUnit unit){
        this.mValue = value;
        this.mUnit = unit;
    }

    public Distance toUnit(DistanceUnit unit){
        double factor = this.mUnit.getMetresFactor() * unit.getMetresFactor();
        double newValue = this.mValue * factor;
        Distance distance = new Distance(newValue, unit);
        return distance;
    }

    @Override
    public String toString(){
        return String.valueOf(mValue);
    }
}

It looks very simple. Conversion toUnit is based on DistanceUnit method getMetresFactor. Each Unit class implements DistanceUnit interface and has method getMetresFactor() like:

public interface DistanceUnit {
    double getMetresFactor();
}


public class Inch implements DistanceUnit {
    @Override
    public double getMetresFactor() {
        return 0.0254;
    }
}


public class Kilometer implements DistanceUnit {
    @Override
    public double getMetresFactor() {
        return 0.001;
    }
}

And the usage is for example:

Distance inches = new Distance(300.0, new Inch());
Distance kilometres = inches.toUnit(new Kilometres());

So it returns the correct value.

Is it good way to store distance in this way? Maybe you know some weaknesses of this approach. Maybe is a good idea to use here a FactoryMethod pattern to construct distance based on unit shortcut like "m" for meter. I think about the amount of classes if I would have a lot of units... Is it good idea to have factory which return factor of meters based on unit name? There will be no classes for units then?