In practice, you just have to use some common senses and answer some simple questions like:
Do you want the implementation method to be public?
In some cases, it does not make sense to have all parameters at once as some of them might be exclusive.
Does the function with less parameters should call the one with more or vice versa? In the above case, it would make more sense to reverse the direction like this (only one case shown):
public int sum(int x, int y, int w)
{
return sum(x, y) + w;
}
Another fact is that when parameters are of different data types, there might not be a single order that make sense (and you don't necessarily want to use named parameters).
As proposes in one solution, the params alternative can make a lot of sense if you have more that a given number of parameters. For a case like an addition, you might provide optimized version for 2 or 3 parameters and the general one above that.
In practice, you also consider the amount of code. In an example like the one above where it take more code to call the other version and the code is trivial, I might simply write the whole addition in each overload particulary if the function are used a lot.
Also, default values are not always simple constants so overload might sometime make sense because you might get the value using some code. And in cases like a virtual function, I would generally avoid default parameters and only have the implementation function virtual.
Another point would be the validation you might do on parameters or the usefullness of finding specific references or add a breakpoint only in a specific case.
Thus except for some trivial cases where it does not matter much, common sense should tell the more appropriate solution.