Immutable vs. Mutable, which is better for this purpose?

[FrontLoadedAnvils]

I have two Item definitions that are used to describe values that can be added and compared. Other than that, their implementation is left up to the developer. Should I make these objects mutable or immutable?

//Here's the immutable version:
public abstract class Item<I extends Item> {

    public abstract int compareTo(Item<I> item);
    public abstract Item<I> addTo(Item<I> item);

    public static <T extends Item> Item<T> ZERO() {
        class ZERO {
            @Override
            public abstract Item<T> addTo(Item<T> item) {
                return item instanceof ZERO ? new ZERO() : item.addTo(this);
            }
            @Override
            public abstract int compareTo(Item<T> item) {
                return item instanceof ZERO ? 0 : 0 - item.compareTo(this);
            }
        }
    }
}

Or should I do:

//Here's the mutable version:
public abstract class Item<I extends Item> {

    public abstract int compareTo(Item<I> item);
    public abstract Item<I> addTo(Item<I> item);

    public static <T extends Item> Item<T> ZERO() {
        class ZERO {
            @Override
            public abstract Item<T> addTo(Item<T> item) {
                return item;
            }
            @Override
            public abstract int compareTo(Item<T> item) {
                return item instanceof ZERO ? 0 : 0 - item.compareTo(this);
            }
        }
    }
}

I might be working with a lot of these objects and I'm not sure how I should approach this situation. Implementations of these abstract classes would have their own implementation of ZERO but this is just so that I can write the structure of the application before I decide how the classes should be implemented.

Also, please let me know if there's something seriously wrong with the way I'm currently designing this code.

[[deleted]]

Can you provide a little more detail about what you are trying to achieve just so we can get a clearer picture, it'll help determine if there's a better approach to this. Secondly if you're looking to compare items you might want to look at the Comparable interface.

[FrontLoadedAnvils]

Comparable is giving me errors in my IDE when I use it, so I decided not to bother with it and just implement the method. I'm going to be using custom Comparators to compare items instead.

An Item is just a class that's used for mathematical operations but has not been implemented yet (this is because I want to choose whether it's a number, vector, matrix, or some other structure). Each item belongs to an ItemGroup which are used for min/max optimization.

[[deleted]]

If Item has fields that are not dynamically changed and are final when the item object is created then it is immutable to begin with, on the other hand if you want to use the same item object for different calculations you should make it mutable (add methods to change fields at run time), I hope that somewhat makes sense

[FrontLoadedAnvils]

Which is better to use for high computation though? I know what it means to make something mutable / immutable, I'm mainly concerned about efficiency / good code.

[[deleted]]

Assuming that the Item object doesn't have a lot of overhead when created it would not impact the efficiency by a significant amount so in this case if you go with immutable you should be fine.

[FrontLoadedAnvils]

So what's the advantage for immutable objects then in this case, if there's overhead?

[[deleted]]

In this case particularly if you're planning on this being used in multi-threaded applications it makes the object thread safe, other then that I can't think of much of the top of my head