Sobrecarga de métodos y constructores en Java

En una clase, la sobrecarga (overloading) permite definir más de un constructor o método con el mismo nombre, con la condición de que no puede haber dos de ellos con el mismo número y tipo de parámetros.

EJEMPLO { PruebaPerro } Dada la siguiente clase Perro, donde se ha definido el método cambiar sobrecargado:

public class Perro
{
    private String nombre;
    private int edad;

    public Perro(String nombre, int edad)
    {
        this.nombre = nombre;
        this.edad = edad;
    }

    public String getNombre()
    {
        return nombre;
    }

    public int getEdad()
    {
        return edad;
    }

    public void cambiar(String nombre)
    {
        this.nombre = nombre;
    }

    public void cambiar(int edad)
    {
        this.edad = edad;
    }

    public void cambiar(String nombre, int edad )
    {
        this.nombre = nombre;
        this.edad = edad;
    }
}

Nota: véase que, el método cambiar se ha definido tres veces: con un parámetro de tipo String, con un párametro de tipo int y con dos párametros cuyos tipos son String e int.

Al compilar y ejecutar el siguiente código fuente, donde se invoca al método cambiar pasándole uno o dos argumentos:

public class PruebaPerro
{
    public static void main(String[] args)
    {
        Perro perro1 = new Perro("Chispas", 5);
        Perro perro2 = new Perro("Sombra", 3);
        Perro perro3 = new Perro("Zeus", 7);

        System.out.println(perro1.getNombre() + " tiene " + perro1.getEdad() + " años.");
        System.out.println(perro2.getNombre() + " tiene " + perro2.getEdad() + " años.");
        System.out.println(perro3.getNombre() + " tiene " + perro3.getEdad() + " años.");

        perro1.cambiar("Jaque");
        perro2.cambiar(4);
        perro3.cambiar("Goku", 8);

        System.out.println("\nDespués de los cambios:");

        System.out.println(perro1.getNombre() + " tiene " + perro1.getEdad() + " años.");
        System.out.println(perro2.getNombre() + " tiene " + perro2.getEdad() + " años.");
        System.out.println(perro3.getNombre() + " tiene " + perro3.getEdad() + " años.");
    }
}

En la pantalla, se verá:

Ejecución del programa PruebaPerro escrito en Java, donde se invoca a un método sobrecargado.

EJEMPLO { PruebaEquipo } Dada la siguiente clase Equipo, donde el constructor está sobrecargado:

public class Equipo
{
    private String nombre;
    private String ciudad;
    private int puntos;

    public Equipo(String nombre, String ciudad, int puntos)
    {
        this.nombre = nombre;
        this.ciudad = ciudad;
        this.puntos = puntos;
    }

    public Equipo(String nombre)
    {
        this.nombre = nombre;
        this.ciudad = "ciudad desconocida";
    }

    public String getNombre()
    {
        return nombre;
    }

    public String getCiudad()
    {
        return ciudad;
    }

    public int getPuntos()
    {
        return puntos;
    }
}

Como se puede apreciar, al constructor se le puede invocar pasándole uno o tres argumentos. De modo que, al compilar y ejecutar el siguiente código fuente:

public class PruebaEquipo
{
    public static void main(String[] args)
    {
        Equipo equipo1 = new Equipo("Gladiadores", "Valencia", 5);
        Equipo equipo2 = new Equipo("Ases");

        System.out.println("El equipo " + equipo1.getNombre() + " de " + equipo1.getCiudad() + " tiene " + equipo1.getPuntos() + " puntos.");
        System.out.println("El equipo " + equipo2.getNombre() + " de " + equipo2.getCiudad() + " tiene " + equipo2.getPuntos() + " puntos.");
    }
}

En la pantalla, se mostrará lo siguiente:

Ejecución del programa PruebaEquipo escrito en Java, donde se invoca a un constructor sobrecargado.

Por otra parte, respecto al constructor definido con un parámetro:

public Equipo(String nombre)
{
    this.nombre = nombre;
    this.ciudad = "ciudad desconocida";
}

Se puede decir lo mismo escribiendo:

public Equipo(String nombre)
{
    this(nombre, "ciudad desconocida", 0);
}

Fíjese que, en este segundo caso –por medio de this– desde este constructor se invoca al constructor que tiene tres parámetros para que sea él quien inicialice los atributos del objeto que se va a crear.