Generally, its better OO design to wrap primative values in a
meaningful class.  Instead of "int distanceInMeters", you would have a
class Distance { private int meters; }, with the appropriate
getMeters() method.  This allows you to decouple the actual storage
value (integer meters) with the representation (some Distance).

This allows you to change the Distance class to use, for instance,
centimeters or inches, without changing ANY code that references
Distance (the Distance class would do the necessary conversions in the
getMeter/setMeter methods, and you would add getInch/setInch, etc...)

As for serialization, this allows you to version the value as well.
You can intercept the serialization and do any necessary conversions
in one place, rather than having to do it for the same primitive value
in many places...

Using primitive values too often is sometimes known as the Primitive
Obsession code-smell (Refactorying, Martin Fowler).

If your value has a semantic meaning, and you don't have an
*overwhelming* reason not to, you should wrap your primitives in
meaningful classes.

If you write a naked int to a ObjectOutputStream it will be autoboxed
into an Integer.  See http://mindprod.com/jgloss/autoboxing.html

If you have an int field in a  class vs a link to an Integer Object,
the stream will be more compact, as will RAM. It will be written as a
primitive int.

It can be fun to look at serialised object streams with a hex editor.
You can learn quite a bit even if you only understand a small fraction
of the format.  See http://mindprod.com/jgloss/serialization.html
for a link to the format spec.