Unit of measure class for mass in java I was looking at this answer on SO to handle units in java.  The concept was interesting to me, except I didn't like that it had to be per object that had mass, instead of encapsulating a Mass class on its own so the pattern need not be repeated.  This is what I came up with. 

public class Main
{

  public static void main(String args[]){
    Mass x = Mass.from_oz(2.3);
    System.out.println("x in kg: " + x.get_kg());
    System.out.println("x in oz: " + x.get_oz());

    Mass y = Mass.from_lb(1.2);
    System.out.println("y in kg: " + y.get_kg());
    System.out.println("y in lb: " + y.get_lb());

    Mass z = Mass.add(x, y); 
    System.out.println("x + y in kg: " + z.get_kg());

    z.add(Mass.from_kg(2.0));
    System.out.println("x + y + 2.0kg in kg: " + z.get_kg());

  }  
}

public class Mass{
    private double mass;
    private static double LB_PER_KG = 2.20462;
    private static double OZ_PER_LB = 16;

    private static double lb_to_kg(double value){
        return value * (1/LB_PER_KG);
    }
    private static double kg_to_lb(double value){
        return value * (LB_PER_KG);
    }
    private static double kg_to_oz(double value){
        return value * (LB_PER_KG*OZ_PER_LB);
    }
    private static double oz_to_kg(double value){
        return value * (1/(LB_PER_KG*OZ_PER_LB));
    }

    public double get_kg(){
        return this.mass;
    }
    public double get_lb(){
        return kg_to_lb(this.mass);
    }
    public double get_oz(){
        return kg_to_oz(this.mass);
    }


    public void set_kg(double value){
        this.mass = value;
    }
    public void set_lb(double value){
        this.mass = lb_to_kg(value);
    }
    public void set_oz(double value){
        this.mass = oz_to_kg(value);
    }


    private Mass(double value){
        set_kg(value);
    }

    public static Mass from_kg(double value){
        return new Mass(value);
    }
    public static Mass from_lb(double value){
        return new Mass(lb_to_kg(value));
    }
    public static Mass from_oz(double value){
        return new Mass(oz_to_kg(value));
    }

    public Mass add(Mass rhs){
        this.mass += rhs.mass;
        return this;
    }
    public Mass sub(Mass rhs){
        this.mass -= rhs.mass;
        return this;
    }
    public Mass div(Mass rhs){
        this.mass *= rhs.mass;
        return this;
    }
    public Mass mul(Mass rhs){
        this.mass /= rhs.mass;
        return this;
    }

    public static Mass add(Mass lhs, Mass rhs){
        return new Mass(lhs.mass).add(rhs);
    }
    public static Mass sub(Mass lhs, Mass rhs){
        return new Mass(lhs.mass).sub(rhs);
    }
    public static Mass mul(Mass lhs, Mass rhs){
        return new Mass(lhs.mass).mul(rhs);
    }
    public static Mass div(Mass lhs, Mass rhs){
        return new Mass(lhs.mass).div(rhs);
    }

}


Looking for any criticism, in addition to answers to these questions:


am I doing class arithmetic in java right?  It doesn't have overloading of operators, so I'm not sure what the convention is for arithmetic. 
I didn't use lower camel case for the unit part of functions and variables, despite lower camel case being the convention, I felt it was harder to see toKg or toKG especially when this theoretically could be used with different units where Nm and nm would be two different things. 
is there a better way to manage the conversion functions, seem like I have to add two every time I add a new unit?  what about units that are power of 10 convertible like for kg vs g?  Is there a special pattern I could employ there (eg kg, g, mg, etc...)?
For just Mass, I would define some constants.

public final static Mass kg = new Mass(1);
public final static Mass lb = new Mass(1/2.2, kg);
public final static Mass oz = new Mass(1/16.0, lb);


And define your conversions with the “to” (and “from”) units passed in.

public double in(Mass unit) {
    return mass / unit.mass;
}

public static double convert(double quantity, Mass from, Mass to) {
    return quantity * from.mass / to.mass;
}


Of course, you’d need to remove the “set” members, and make the Mass a constant value class.

private final double mass;

public Mass(double kg) {
    mass =  kg;
}

public Mass(double quantity, Mass unit) {
    mass = quantity * unit.mass;
}


New units just mean defining new class constants.

Mass weight = new Mass( 100, Mass.kg );
double pounds = weight.in( Mass.lb );
double ounces = weight.in( Mass.oz );


As described in the comments, you could expand this to a complete unit calculator, if you tracked the power of each unit dimension in the quantity class.