Anulación de método

Ilustración

La anulación de métodos , en la programación orientada a objetos , es una característica del lenguaje que permite que una subclase o clase secundaria proporcione una implementación específica de un método que ya es proporcionado por una de sus superclases o clases principales. La implementación en la subclase anula (reemplaza) la implementación en la superclase al proporcionar un método que tiene el mismo nombre, los mismos parámetros o firma, y ​​el mismo tipo de retorno que el método en la clase principal. ^[1] La versión de un método que se ejecuta será determinada por el objetoque se utiliza para invocarlo. Si se utiliza un objeto de una clase principal para invocar el método, se ejecutará la versión de la clase principal, pero si se utiliza un objeto de la subclase para invocar el método, se ejecutará la versión de la clase secundaria. ^[2] Algunos lenguajes permiten a un programador evitar que se anule un método.

Ejemplos específicos de idiomas

Ada

Ada proporciona anulación de métodos de forma predeterminada. Para favorecer la detección temprana de errores (p. Ej., Una falta de ortografía), es posible especificar cuándo se espera que un método sea realmente invalidante o no. Eso será verificado por el compilador.

 el tipo  T  es  nuevo  Controlado  con  ......;  procedimiento  Op ( Obj : in  out  T ;  Data : in  Integer ); el tipo  NT  es  nuevo  T  con  registro nulo ;  anulación  -  procedimiento  indicador de anulación Op ( Obj : in  out  NT ;  Data : in  Integer );  anulación  -  procedimiento  indicador de anulación Op ( Obj : in  out  NT ;  Data : in  String );  - ^ El compilador emite un error: el subprograma "Op" no se reemplaza

C #

C # admite la anulación de métodos, pero solo si se solicita explícitamente mediante los modificadores overridey virtualo abstract.

abstracta  clase  Animal {  pública  cadena  Nombre  {  get ;  establecer ;  }  // Métodos  public  void  Drink ();  comer vacío virtual público  (); public void Go (); }     class  Cat  :  Animal {  Public  New  String  Name  {  get ;  establecer ;  }  // Métodos  public  void  Drink ();  // Advertencia: oculta la bebida heredada (). Utilice una nueva  anulación pública  void Eat (); // Anula el eat () heredado. public new void Go (); // Oculta el go () heredado. }        

Al anular un método con otro, las firmas de los dos métodos deben ser idénticas (y con la misma visibilidad). En C #, los métodos de clase , indexadores , propiedades y eventos pueden anularse.

Los métodos no virtuales o estáticos no se pueden anular. El método de base reemplazado debe ser virtual , extracto , o de anulación .

Además de los modificadores que se usan para anular métodos, C # permite ocultar una propiedad o método heredado. Esto se hace usando la misma firma de una propiedad o método pero agregando el modificador newdelante de él. ^[3]

En el ejemplo anterior, ocultar provoca lo siguiente:

Cat  cat  =  nuevo  Cat ();cat . Nombre  =  … ;  // accede a Cat.Name cat . Comer ();  // llama a Cat.Eat () cat . Ir ();  // llama a Cat.Go () (( Animal ) cat ). Nombre  =  … ;  // accede a Animal.Name! ( Gato ( animal ) ). Comer (); // ¡llama a Cat.Eat ()! ( Gato ( animal ) ). Ir (); // llama a Animal.Go ()!  

C ++

C ++ no tiene la palabra clave superque una subclase puede usar en Java para invocar una versión de superclase de un método que quiere anular. En su lugar, se utiliza el nombre de la clase principal o base seguido del operador de resolución de alcance . Por ejemplo, el siguiente código presenta dos clases , la clase base Rectangley la clase derivada Box. Boxanula el método de la Rectangleclase Print, para que también imprima su altura. ^[4]

#include  <iostream>// ------------------------------------------------ --------------------------- class  Rectangle  {  public :  Rectangle ( doble  l ,  doble  w )  :  length_ ( l ),  width_ ( w )  {}  virtual  void  Print ()  const ; privado :  doble  longitud_ ;  doble  ancho_ ; };// ------------------------------------------------ --------------------------- void  Rectangle :: Print ()  const  {  // Método de impresión de la clase base.  std :: cout  <<  "Longitud ="  <<  longitud_  <<  "; Ancho ="  <<  ancho_ ; }// ------------------------------------------------ --------------------------- class  Box  :  public  Rectangle  {  public :  Box ( doble  l ,  doble  w ,  doble  h )  :  Rectángulo ( l ,  w ),  height_ ( h )  {}  void  Print ()  const  override ; privado :  doble  altura_ ; };// ------------------------------------------------ --------------------------- // Método de impresión de la clase derivada. void  Box :: Print ()  const  {  // Invocar el método de impresión principal.  Rectángulo :: Imprimir ();  std :: cout  <<  "; Altura ="  <<  altura_ ; }

El método Printen clase Box, al invocar la versión principal del método Print, también puede generar las variables privadas lengthy widthde la clase base. De lo contrario, estas variables son inaccesibles Box.

Las siguientes declaraciones se instanciar objetos de tipo Rectangley Box, y llamar a sus respectivos Printmétodos:

int  main ( int  argc ,  char **  argv )  {  Rectángulo  rectángulo ( 5.0 ,  3.0 ); // Salidas: Longitud = 5.0; Ancho = 3.0  rectángulo . Imprimir (); Caja  caja ( 6.0 ,  5.0 ,  4.0 ); // El puntero al método más anulado en la vtable en Box :: print,  // pero esta llamada no ilustra la anulación.  caja . Imprimir (); // Esta llamada ilustra la anulación.  // salidas: Longitud = 6.0; Ancho = 5.0; Altura = 4.0  static_cast < Rectángulo &> ( cuadro ). Imprimir (); }

En C ++ 11 , similar a Java, un método que se declara finalen la superclase no se puede anular; además, se puede declarar un método overridepara que el compilador compruebe que anula un método en la clase base.

Delphi

En Delphi , la anulación del método se realiza con la anulación de la directiva , pero solo si un método se marcó con las directivas dinámicas o virtuales .

La palabra reservada heredada debe llamarse cuando desee llamar al comportamiento de superclase

tipo  TRectangle  =  clase  privada  FLength :  Double ;  FWidth :  Doble ;  propiedad pública  Longitud leer FLength escribir FLength ; propiedad Ancho leer FWidth escribir FWidth ;            procedimiento  Imprimir ;  virtual ;  terminar ; TBox  =  clase ( TRectangle )  procedimiento público  Print ; anular ; terminar ;   

Eiffel

En Eiffel , la redefinición de funciones es análoga a la anulación de métodos en C ++ y Java. La redefinición es una de las tres formas de adaptación de características clasificadas como redeclaración . La declaración también cubre el efecto , en el que se proporciona una implementación para una característica que fue diferida (abstracta) en la clase principal, y la indefinición , en la que una característica que fue efectiva (concreta) en la principal se vuelve a aplazar en la clase heredera. Cuando se redefine una característica, la clase heredera conserva el nombre de la característica, pero las propiedades de la característica, como su firma, contrato (respetando las restricciones de las condiciones previas y posteriores), y / o la implementación será diferente en el heredero. Si el rasgo original en la clase padre, llamado precursor del rasgo heredero , es efectivo, entonces el rasgo redefinido en el heredero será efectivo. Si se aplaza el precursor, se aplazará la característica del heredero. ^[5]

La intención de redefinir una característica, como messageen el ejemplo siguiente, debe declararse explícitamente en la inheritcláusula de la clase heredera.

class  THOUGHT feature  message  - Mostrar mensaje de pensamiento  do  print  ( "Me siento como si estuviera estacionado en diagonal en un universo paralelo.% N" )  end endclase  ASESORAMIENTO hereda  PENSAMIENTO  redefinen el  mensaje  final característica de  mensaje  - Precursor  hacer  de impresión  ( "Advertencia: Las fechas en calendario están más cerca de lo que parecen% N" )  extremo final

En clase, ADVICEla característica messagerecibe una implementación que difiere de la de su precursor en clase THOUGHT.

Considere una clase que usa instancias para ambos THOUGHTy ADVICE:

clase  APLICACIÓN crear  hacer característica  hacer  - Ejecutar aplicación.  hacer  ( crear  { PENSAMIENTO }). mensaje ;  ( crear  { CONSEJO }). final del mensaje  final

Cuando se crea una instancia, la clase APPLICATIONproduce la siguiente salida:

Me siento como si estuviera estacionado en diagonal en un universo paralelo.Advertencia: las fechas en el calendario están más cerca de lo que parecen.

Dentro de una función redefinida, se puede acceder al precursor de la función mediante el uso de la palabra clave del idioma Precursor. Suponga que la implementación de se modifica de la siguiente manera:{ADVICE}.message

 mensaje  - Precursor  do  print  ( "Advertencia: Las fechas en el calendario están más cerca de lo que parecen.% N" )  Precursor  end

La invocación de la función ahora incluye la ejecución de y produce el siguiente resultado:{THOUGHT}.message

Advertencia: las fechas en el calendario están más cerca de lo que parecen.Me siento como si estuviera estacionado en diagonal en un universo paralelo.

Java

En Java , cuando una subclase contiene un método que anula un método de la superclase, también puede invocar el método de la superclase utilizando la palabra clave super . ^[2] Ejemplo:

class  Thought  {  public  void  message ()  {  System . fuera . println ( "Me siento como si estuviera estacionado en diagonal en un universo paralelo" );  } }El  consejo de la clase  pública amplía el pensamiento { @Override // La anotación @Override en Java 5 es opcional pero útil. public void message () { System . fuera . println ( "Advertencia: las fechas en el calendario están más cerca de lo que parecen." ); } }           

La clase Thoughtrepresenta la superclase e implementa una llamada a un método . La subclase llamada hereda todos los métodos que podrían estar en la clase. Sin embargo, la clase anula el método , reemplazando su funcionalidad de .message()AdviceThoughtAdvicemessage()Thought

 Aparcamiento de  pensamientos =  nuevo  pensamiento (); estacionamiento . mensaje ();  // Imprime "Me siento como si estuviera estacionado en diagonal en un universo paralelo". Fechas de  pensamiento =  nuevo  consejo ();  // Fechas de polimorfismo . mensaje ();  // Imprime "Advertencia: las fechas en el calendario están más cerca de lo que parecen".

La superreferencia puede ser

public  class El  consejo  extiende el  pensamiento  {  @Override  public  void  message ()  {  System . fuera . println ( "Advertencia: las fechas en el calendario están más cerca de lo que parecen." );  super . mensaje ();  // Invocar la versión del método de los padres.  }

Hay métodos que una subclase no puede anular. Por ejemplo, en Java, un método que se declara final en la superclase no se puede anular. Los métodos que se declaran privados o estáticos tampoco se pueden invalidar porque son implícitamente finales. También es imposible que una clase declarada final se convierta en una superclase. ^[6]

Kotlin

En Kotlin podemos simplemente anular una función como esta: tenga en cuenta que la función debe estar abierta

fun  main ( args :  Array < String > )  {  var  t  =  test ( 5 )  var  s  =  test2 ( 6 )  t . myFun ()  s . myFun () } prueba de clase  abierta ( var a : Int ) { diversión abierta myFun () = println ( a ) }         class  test2 ( var  b  :  Int )  :  test ( b )  {  override  fun  myFun ()  =  println ( "método reemplazado" ) }

Python

En Python , cuando una subclase contiene un método que anula un método de la superclase, también puede llamar al método de la superclase llamando a ^{[7] en} lugar de . Ejemplo:super(Subclass, self).methodself.method

class  Pensamiento :  def  __init__ ( self )  ->  None :  print ( "¡Soy un nuevo objeto de tipo Thought!" )  def  message ( self )  ->  None :  print ( "Me siento como si estuviera estacionado en diagonal en un universo paralelo . " )clase  Consejo ( pensamiento ):  def  __init__ ( yo )  ->  Ninguno :  super ( consejo ,  yo ) . __init__ ()  def  message ( self )  ->  None :  print ( "Advertencia: las fechas en el calendario están más cerca de lo que parecen" )  super ( Advice ,  self ) . mensaje ()t  =  Thought () # "¡Soy un nuevo objeto de tipo Thought!" t . message () # "Me siento como si estuviera estacionado en diagonal en un universo paralelo.a  =  Advice () # "¡Soy un nuevo objeto de tipo Pensamiento!" a . message () # "Advertencia: las fechas en el calendario están más cerca de lo que parecen" # "Me siento como si estuviera estacionado en diagonal en un universo paralelo.# ------------------ # Introspección:isinstance ( t ,  Thought ) # Verdaderoisinstance ( a ,  Advice ) # Verdaderoisinstance ( a ,  Thought ) # Verdadero

Ruby

En Ruby, cuando una subclase contiene un método que anula un método de la superclase, también puede llamar al método de la superclase llamando a super en ese método anulado. Puede utilizar un alias si desea mantener el método anulado disponible fuera del método anulado como se muestra con 'super_message' a continuación.

Ejemplo:

El  mensaje de definición de pensamiento de  clase pone "Me siento como si estuviera estacionado en diagonal en un universo paralelo". fin fin    clase  Consejo  <  alias de pensamiento  : super_message : def del mensaje mensaje pone "Advertencia: las fechas en el calendario están más cerca de lo que parecen" super end end        

Notas

1. Flanagan, 2002, p. 107
2. Lewis y Loftus, 2006, p.454
3. Mössenböck, Hanspeter (25 de marzo de 2002). "C # avanzado: anulación de métodos" (PDF) . http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/ : Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik. págs. 6–8 . Consultado el 2 de agosto de 2011 .
4. Malik, 2006, p. 676
5. Meyer 2009, página 572-575
6. Deitel y Deitel 2001, p.474
7. en Python 3 - ver https://docs.python.org/3/library/functions.html#super Archivado 2018-10-26 en Wayback Machinesuper().method

Ver también

• Herencia de implementación
• Semántica de herencia
• Sobrecarga de métodos
• Polimorfismo en programación orientada a objetos
• Patrón de método de plantilla
• Herencia virtual
• Encabezado HTTP X-HTTP-Method-Override

Referencias

• Deitel, H. M y Deitel, PJ (2001). Cómo programar en Java (4ª ed.). Upper Saddle River, Nueva Jersey: Prentice Hall.
• Lewis, J. y Loftus, W. (2008). Java: Soluciones de software (6ª ed.). Boston, MA: Pearson Addison Wesley.
• Malik, DS (2006). Programación C ++: Diseño de programas que incluye estructura de datos. (3ª ed.). Washington, DC: Curso de tecnología.
• Flanagan, David. (2002). Java en pocas palabras. Obtenido de http://oreilly.com/catalog/9780596002831/preview#preview
• Meyer, Bertrand (2009). Toque de clase: aprender a programar bien con objetos y contratos . Saltador.

Enlaces externos

• Anulación del método Java por Hemanth Balaji
• Introducción a los conceptos de OOP y más por Nirosh LwC
• Métodos de anulación y ocultación de Sun Microsystems