Búsqueda de sitios web

Diferencia entre sobrecarga de métodos y anulación de métodos en Python

Los métodos son importantes cuando se trata de la programación orientada a objetos (OOP) de Python. Son cruciales para aislar la funcionalidad dentro de una clase y darle a las cosas la capacidad de realizar funciones particulares. Sin embargo, dos conceptos de programación orientada a objetos (sobrecarga de métodos y anulación de métodos) en ocasiones pueden provocar malentendidos. En este artículo se analizarán las distinciones entre estas dos ideas y sus aplicaciones en Python.

Sintaxis

Al utilizar el verbo "def", el nombre, los argumentos y el cuerpo del método son necesarios para definir un método en Python.

def method_name(parameter1, parameter2, ...):
   # method body
   return value

Tabla de comparación

Refers to defining multiple methods with the same name but different parameters

Se refiere a definir un método en una subclase que tiene el mismo nombre que el de su superclase</p>

Can be achieved in Python using default arguments

Se puede lograr definiendo un método en una subclase con el mismo nombre que el de su superclase</p>

Allows a class to have multiple methods with the same name but different behaviors based on the input parameters

Permite que una subclase proporcione su propia implementación de un método definido en su superclase </p>

The choice of which method to call is determined at compile-time based on the number and types of arguments passed to the method

La elección de qué método llamar se determina en tiempo de ejecución en función del objeto real al que se hace referencia </p>

Not supported natively in Python

Compatible de forma nativa con Python</p>

Ejemplo

Ejemplo 1: sobrecarga de métodos

La sobrecarga de métodos se refiere a la definición de múltiples métodos con el mismo nombre pero con diferentes tipos de parámetros o número de parámetros. En Python, la sobrecarga de métodos se logra utilizando argumentos predeterminados.

class MyClass:
   def my_method(self, arg1, arg2=None):
      if arg2:
         print(arg1 + arg2)
      else:
         print(arg1)

# Calling the method with one argument
obj = MyClass()
obj.my_method(10)

# Calling the method with two arguments
obj.my_method(10, 20)

Producción

10
30

Definimos un método llamado "mi_método" en este ejemplo que acepta dos argumentos, el segundo de los cuales es opcional. El método sumará los dos argumentos si hay un segundo argumento; De lo contrario, se imprimirá el primer argumento.

Ejemplo 2: anulación de método

La anulación de métodos, por otro lado, se refiere a definir un método en una subclase con el mismo nombre que el de su superclase. Luego, el método de la subclase anula el método de la superclase.

class Animal:
   def speak(self):
      print("Animal Speaking!")
class Dog(Animal):
   def speak(self):
      print("Dog barking!")
obj = Dog()
obj.speak()

Producción

Dog barking!

Tenemos un subtipo "Perro" y una superclase "Animal" como se ve arriba. El método "hablar" de la clase "Animal" es anulado por la función "hablar" de la clase "Perro". Ahora, veamos un bloque completo de código Python con sobrecarga de métodos y anulación de métodos:

class Parent:
   def my_method(self, arg1, arg2):
      print("Parent my_method")
class Child(Parent):
   def my_method(self, arg1):
      print("Child my_method")
obj = Child()
obj.my_method("Hello")

Producción

Child my_method

Tenemos una superclase llamada "Padre" en este caso, así como una subclase llamada "Hijo". La clase "Hijo" tiene un método llamado "mi método" que sólo acepta un parámetro, mientras que el método "mi método" de la clase "Padre" acepta dos argumentos. El método "mi método" se invoca cuando se llama en una instancia de clase "secundaria" porque solo acepta un argumento.

Ejemplo

class Shape:
   def area(self):
      pass
class Rectangle(Shape):
   def __init__(self, length, breadth):
      self.length = length
      self.breadth = breadth
   def area(self):
      return self.length * self.breadth
class Circle(Shape):
   def __init__(self, radius):
      self.radius = radius
   def area(self):
      return 3.14 * self.radius * self.radius
   def area(self, diameter):
      self.radius = diameter / 2
      return 3.14 * self.radius * self.radius
r = Rectangle(5, 10)
print("Area of rectangle:", r.area())
c = Circle(7)
print("Area of circle with radius 7:", c.area())
print("Area of circle with diameter 10:", c.area(10))

Producción

Area of rectangle: 50
Area of circle with radius 7: 153.86
Area of circle with diameter 10: 78.5

Aquí, tanto el Círculo como el Rectángulo modifican el método area() de la clase básica Forma. Mientras que la clase Círculo anula el método area() para calcular el área de un círculo con un radio específico, la clase Rectángulo define su propia versión del método area() para calcular el área de un rectángulo. Al agregar una segunda función area() que determina el área de un círculo con un diámetro específico, la clase Circle también demuestra la sobrecarga de métodos. En este caso, la superclase "Padre" y la subclase "Niño" están presentes. Mientras que la clase "Hijo" sólo toma un argumento, el método "mi método" para la clase "Padre" admite dos.

El rectangular tiene 50 pies cuadrados cuando se crea una instancia de la clase Rectángulo y se utiliza su método area(). La función área() de la clase Círculo devuelve el área del círculo, que es aproximadamente 153,86 cuando usamos una instancia con un radio de 7. Por último, pero no menos importante, usamos un círculo con un diámetro de 10 y llamamos a la función área() de la clase Círculo para encontrar el área del círculo, que es aproximadamente 78,5.

Conclusión

Comprender las sutiles diferencias entre la sobrecarga de métodos y la llamada a métodos es esencial al explorar el mundo de la programación orientada a objetos. Con frecuencia se confunden ambos, lo que puede causar problemas e incertidumbre en el futuro. La técnica de especificar numerosos métodos con el mismo nombre pero con parámetros distintos se conoce como sobrecarga de métodos. Esto contrasta con la anulación de métodos, que implica crear un método con el mismo nombre que uno de la superclase en un subtipo. Para anular un método en Python, se debe proporcionar un método con el mismo nombre que el de la superclase. Los números preestablecidos se utilizan con frecuencia como solución para la sobrecarga de funciones.

Artículos relacionados