Why Method Overloading Can Signal Bad Design

Coming from Java and C++ and moving into PHP and Javascript, one of the problems that I ran into was the fact that PHP and Javascript don't have traditional ways to overload functions. Through traditional computer science eduation, overloading methods is just par for the course. But, as I venture further into advanced architecture, I have to start looking back at this as more just an explaination of a feature of Java than a good coding practice.

To start, method overloading is a simple introduction to polymorphism (which is a very good thing) so students are introduced to code that might look like this

#! java

public int getNum(int a)
{
    return a + 5;
}
public int getNum(int a, int b)
{
    return a + b;
}

But, thinking about this now, I look at this as a terrible design. In Java and C++ overloading is traditionally taught as a way to allow for defaults for values which makes sense, but unfortunately, it is also often used for modestly similar functionality. So in old code I have seen things like:

#! java

public int getNum(String a)
{
    return Integer.parseInt(a);
}
public int getNum(int a)
{
    return a +5;
}
public int getNum(int a, int b)
{
    return a + b;
}

This is terrible design because, the naming has nothing to do with what the function does or just work with defaults. What's great, is that PHP and Javascript don't allow you to overload typecasted methods so the code above would look like:

#! php
public function getNumberFromString($a)
{
    return (int) $a;
}
public function getNumberSum($a, $b = 5)
{
    return $a + $b;
}

This forces better naming and restricts the ability to make these mistakes. And as a second thought, don't worry about having longer named methods, they make for easier to read code and doesn't really cost much in terms of memory or speed.