method - override java

Sobrecarga de Java vs anulación

Question

Hola, solo quiero asegurarme de que tengo estos conceptos correctos. La sobrecarga en java significa que puede tener un constructor o un método con diferente número de argumentos o diferentes tipos de datos. es decir

public void setValue(){
   this.value = 0;
}
public void setValue(int v){
   this.value = v;
}

¿Qué tal este método? ¿Se seguiría considerando la sobrecarga ya que está devolviendo un tipo de datos diferente?

public int setValue(){
   return this.value;
}

La segunda pregunta es: ¿qué está anulando en java? ¿Se relaciona con la herencia? Vamos a tener lo siguiente:

public class Vehicle{
  double basePrice = 20000;
  //constructor defined
  public double getPrice(){
     return basePrice;
   }
}

public class Truck extends Vehicle{
  double truckPrice = 14000;
  //constructor defined
  public double getPrice(){
     return truckPrice;
   }
}

Así que ahora digamos que tengo el siguiente

Truck truck = new Truck();

si llamo

truck.super.getPrice()

Esto devolvería el precio de la clase Vehículo, 20,000.

si llamo

truck.getPrice()

Esto devolvería el precio en la clase de camiones, 14,000.

¿Mi conocimiento es correcto para ambas preguntas?

Answer 1

Básicamente tienes razón. La sobrecarga es tener múltiples métodos en una sola clase donde el método tiene el mismo nombre. Sin embargo, el valor de retorno no se ve como parte de la firma del método. Por lo tanto, no puede sobrecargar un método cambiando solo el valor de retorno. No puedes tener el siguiente código, de tu ejemplo:

public void setValue() {
   this.value = 0;
}

public int setValue() {
   return this.value;
}

Esto no podrá compilar.

Como Rob identificó, creo que te refieres a anular , y tienes eso correcto. Tenga en cuenta que con el reemplazo, no puede cambiar el tipo de retorno. A partir de Java 5, puede devolver un tipo derivado de lo que devolvió el método de clase base. Antes de Java 5, debe ser del mismo tipo. Es decir, no puede hacer lo siguiente hasta que Java 5 y posteriores:

public class AnimalNoise {}
public class Miaw extends AnimalNoise {}

public class Animal {
    public AnimalNoise makeNoise() {
        return new AnimalNoise();
    }
}

public class Cat extends Animal {
    public Miaw makeNoise() {
        return new Miaw ();
    }
}

Sin embargo, incluso en Java 5 y versiones posteriores, no puede hacer lo siguiente:

public class Animal {
    public String makeNoise() {
        return "silence";
    }
}

public class Cat extends Animal {
    public Miaw makeNoise() {
        return new Miaw ();
    }
}
public class Miaw {}

Finalmente, una gran diferencia entre la sobrecarga y la omisión que a menudo se pasa por alto es que la sobrecarga se decide en el momento de la compilación y la anulación se decide en el tiempo de ejecución. Esto sorprende a muchas personas cuando esperan que la sobrecarga se decida en el tiempo de ejecución.

Answer 2

Correcto; la sobrecarga está proporcionando varias firmas para el mismo método.

Anular, que es lo que creo que entiendes por "sobrescribir" es el acto de proporcionar una implementación diferente de un método heredado de un tipo base, y es básicamente el punto de polimorfismo por herencia, es decir

public class Bicycle implements Vehicle {
    public void drive() { ... }
}

public class Motorcycle extends Bicycle {
    public void drive() {
        // Do motorcycle-specific driving here, overriding Bicycle.drive()
        // (we can still call the base method if it''s useful to us here)
    }
}

Answer 3

Lo que has descrito es correcto.

Para más aclaraciones, eche un vistazo al concepto de polimorfismo. La Wikipedia tiene un buen artículo.

http://en.wikipedia.org/wiki/Polymorphism#Computing

http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming