Sovraccarico Java vs override

Question

Ciao, voglio solo assicurarmi di avere questi concetti giusti. Il sovraccarico in java significa che puoi avere un costruttore o un metodo con un numero diverso di argomenti o tipi di dati diversi. cioè

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

Che ne dici di questo metodo? Sarebbe ancora considerato un sovraccarico poiché restituisce un diverso tipo di dati?

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

---

La seconda domanda è: cosa ha la precedenza  a java? Si riferisce all'eredità. Facciamo quanto segue:

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;
   }
}

Quindi ora diciamo che ho il seguente

Truck truck = new Truck();

se chiamo

truck.super.getPrice()

questo restituirebbe il prezzo dalla classe del veicolo, 20.000

se chiamo

truck.getPrice()

questo restituirebbe il prezzo nella classe camion, 14.000

La mia conoscenza è corretta per entrambe le domande?

Answer 1

In pratica hai ragione. Il sovraccarico ha più metodi in una singola classe in cui il metodo ha lo stesso nome. Tuttavia, il valore restituito non viene visto come parte della firma del metodo. Pertanto, non è possibile sovraccaricare un metodo modificando solo il valore restituito. Non puoi avere il seguente codice, dal tuo esempio:

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

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

Questo non verrà compilato.

Come Rob ha identificato, credo che intendi scavalcando , e hai quello corretto. Nota con l'override, non è possibile modificare il tipo di ritorno. A partire da Java 5, è possibile restituire un tipo derivato di ciò che ha restituito il metodo della classe base. Prima di Java 5, deve essere dello stesso tipo. Cioè, non puoi fare quanto segue fino a Java 5 e versioni successive:

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 ();
    }
}

Tuttavia, anche in Java 5 e versioni successive, non è possibile eseguire le seguenti operazioni:

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

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

Infine, una grande differenza tra sovraccarico e override che viene spesso trascurato è che il sovraccarico viene deciso al momento della compilazione e l'override viene deciso in fase di esecuzione. Ciò sorprende molte persone quando si aspettano che il sovraccarico venga deciso in fase di esecuzione.

Answer 2

Una corretta; il sovraccarico sta fornendo più firme per lo stesso metodo.

Sostituzione, che è ciò che penso intendi per "sovrascrittura" è l'atto di fornire una diversa implementazione di un metodo ereditato da un tipo di base, ed è fondamentalmente il punto del polimorfismo per ereditarietà, cioè

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

ciò che hai descritto è corretto.

Per ulteriori chiarimenti, dai un'occhiata al concetto di polimorfismo. Wikipedia ha un buon articolo

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

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