Estos conceptos son traídos de la programación orientada a objetos y en muchas ocasiones son confundidos, es por ello que he pensado en escribir esta entrada, corta y directo al grano.

Aunque quizá no lo sepas, la pregunta siguiente: ¿Cuál es la diferencia entre sobrecarga y sobrescritura? es muy común en entrevistas técnicas para puestos de desarrollador de software a todo nivel, desde juniors hasta seniors, y es que no muchos se detienen a entender bien estos conceptos. Comencemos.

Sobrecarga (Overload)

La sobrecarga implica creación de nuevos métodos con diferentes signaturas.

Quizá te preguntes y qué es una signatura? Esta entrada puede ayudarte a entenderla a profundidad.

Pero para darte una definición clara y concisa, una signatura es como un sello distintivo de un método, es lo que le permite al compilador diferenciar un método de otro y está compuesto del nombre del método y de sus parámetros. Respecto a sus parámetros tiene en cuenta 3 cosas: sus tipos, el orden de estos y la cantidad.

Por ejemplo veamos estos tres métodos en C#:

        public void Fibonacci(int numberElements)
        {            
            int[] arreglo = new int[numberElements];
            arreglo[0] = 0;
            arreglo[1] = 1;

            for(int i = 2; i < numberElements; i++)
            {
                arreglo[i] = arreglo[i - 1] + arreglo[i - 2];
            }

            Console.WriteLine(string.Join(",",arreglo));
        }

        public string Fibonacci(int quantityElements)
        {
            int[] arreglo = new int[10];
            arreglo[0] = 0;
            arreglo[1] = 1;

            for (int i = 2; i < quantityElements; i++)
            {
                arreglo[i] = arreglo[i - 1] + arreglo[i - 2];
            }

            return string.Join(",", arreglo);
        }

        public string Fibonacci()
        {
            int[] arreglo = new int[10];
            arreglo[0] = 0;
            arreglo[1] = 1;

            for (int i = 2; i < 10; i++)
            {
                arreglo[i] = arreglo[i - 1] + arreglo[i - 2];
            }

            return string.Join(",", arreglo);
        }

De estos 3 métodos y podemos concluir lo siguiente:

• El primero y el segundo método tienen la misma signatura ya que la signatura no contempla el nombre de los parámetros ni el tipo de retorno, así que aunque retornen distintas cosas y sus parámetros se llamen distinto, tienen la misma signatura ya que los métodos tienen el mismo nombre, la misma cantidad de parámetros y el mismo tipo en sus parámetros.
• El tercer método sí tiene otra signatura respecto a los otros dos, ya que no tiene parámetros entonces se está diferenciando en la cantidad de parámetros.

Para que el código compile tendríamos que quitar o el primero o el segundo método y quedarnos con los dos métodos con distinta signatura, entonces tendríamos esto:

        public void Fibonacci(int numberElements)
        {            
            int[] arreglo = new int[numberElements];
            arreglo[0] = 0;
            arreglo[1] = 1;

            for(int i = 2; i < numberElements; i++)
            {
                arreglo[i] = arreglo[i - 1] + arreglo[i - 2];
            }

            Console.WriteLine(string.Join(",",arreglo));
        }

        public string Fibonacci()
        {
            int[] arreglo = new int[10];
            arreglo[0] = 0;
            arreglo[1] = 1;

            for (int i = 2; i < 10; i++)
            {
                arreglo[i] = arreglo[i - 1] + arreglo[i - 2];
            }

            return string.Join(",", arreglo);
        }

Ahora sí, en este caso estaríamos aplicando sobrecarga ya que tenemos dos métodos con distinta signatura y el compilador los identifica como dos métodos con distinta signatura y por lo tanto no da errores.

Sobrescritura (Override/overwrite)

La sobrescritura es ocultar un método por otro que lo reemplaza, es decir define ese mismo método nuevamente.

A diferencia de la sobrecarga, no busca expandir ni ampliar las capacidades de un método definiendo nuevos métodos con el mismo nombre pero con distinta signatura, sino que busca reemplazar el método por completo.

La sobrescritura se da cuando una clase que hereda de su clase padre, sobrescribe un método de ésta y de esta forma re-define el método de su clase padre, entonces el método de la clase padre queda oculta.

Veamos un ejemplo:

Tenemos la clase Publicacion

    public class Publicacion
    {
        public string Titulo { get; set; }
        public string Categoria { get; set; }
        public string TipoPublicacion { get; set; }
        public string[] Tags { get; set; }

        //métodos
        public virtual void Publicar()
        {
            Console.WriteLine($"Publicacion no especificada");
        }
    }

Y tenemos a su clase hija Libro:

   public class Libro : Publicacion
    {
        //propiedades
        public string Id { get; set; }

        //constructores
        public Libro(string Tipo)
        {
            TipoPublicacion = Tipo;
        }
        public Libro()
        {

        }

        //metodos
        public override void Publicar()
        {
            Console.WriteLine($"Se ha publicado el LIBRO");
        }
    }

En esta ocasión el método Publicar está siendo re-definido en la clase hija Libro.

Aquí hay más artículos relacionados muy buenos:

• https://www3.uji.es/~belfern/Docencia/Presentaciones/ProgramacionAvanzada/Tema1/conceptosPolimorfismoSobrecarga.html#1
• http://codejavu.blogspot.com/2014/05/sobreescritura-y-sobrecarga-de-metodos.html

Si esta entrada te ha gustado entonces compártela 🙂