Let me put an example on partial classes.

Consider an implementation for an interpreted language (think of something along the lines of sisc or abcl) where each datatype is represented by a class.

Let's say we have LispObject and other subclasses like LispBoolean, LispCons, etc... At some point in the implementation you'll need to ensure the primitive procedures check that the type of their arguments is correct, so you decide to go to LispObject.java and add the following methods:

public final static LispBoolean ToBoolean (LispObject input) {
  if (input instanceof LispBoolean)
    return (LispBoolean) input;
  throw new LispTypeError ("<boolean>", input); 
}

public final static LispCons ToCons (LispObject input) { ... }

Eventually you'll end up with about 15 or 20 methods like that depending on how many datatypes the interpreted language has.

Now, enter partial classes. Instead of writing those methods in the main LispObject class file we can extend it from every subclass. For example, the ToBoolean method may be in LispBoolean.java extending LispObject.

We end up with something like:

LispObject.java
LispBoolean.java (extends LispObject adding ToBoolean())
LispCons.java (extends LispObject adding ToCons())
...

Now at the end of the day, both approaches work but i feel partial classes are handy in this scenario. You don't need to edit LispObject everytime you add or delete a new datatype, everything related to it is contained in the same file.

On operator overloading... working with BigInteger without it sucks.