Sobrecarga de Java vs anulación

Question

Hola, solo quiero asegurarme de tener estos conceptos correctos. Sobrecargar en Java significa que puede tener un constructor o un método con diferentes números 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? ¿Todavía se consideraría una sobrecarga ya que devuelve 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 lo 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

Estás básicamente en lo correcto. 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 puede tener el siguiente código, a partir de su ejemplo:

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

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

Esto no se compilará.

Como Rob identificó, creo que te refieres a anulación , y tienes eso correcto. Nota con anulación, 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 Java 5 y versiones 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 sobrecarga y anulación que a menudo se pasa por alto es que la sobrecarga se decide en tiempo de compilación y la anulación se decide en tiempo de ejecución. Esto sorprende a muchas personas cuando esperan que la sobrecarga se decida en tiempo de ejecución.

Answer 2

Correcto; la sobrecarga proporciona múltiples firmas para el mismo método.

Anulación, que es lo que creo que quiere decir con "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 ha 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