web-dev-qa-db-fra.com

Surcharge Java vs surcharger

Bonjour, je veux juste m'assurer que j'ai bien compris ces concepts. La surcharge en Java signifie que vous pouvez avoir un constructeur ou une méthode avec un nombre d'arguments ou un type de données différent. c'est à dire

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

Que diriez-vous de cette méthode? Serait-il toujours considéré comme une surcharge puisqu'il renvoie un type de données différent?

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

La deuxième question est: qu'est-ce qui est primordial en java? Cela a-t-il un rapport avec l'héritage? Disons que j'ai le suivant:

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

Alors maintenant, disons que j'ai ce qui suit

Truck truck = new Truck();

si j'appelle 

truck.super.getPrice()

cela retournerait le prix de la classe de véhicule, 20.000

si j'appelle

truck.getPrice()

cela retournerait le prix dans la classe camion, 14 000

Est-ce que mes connaissances sont correctes pour les deux questions?

javaoverloadingoverwrite
16
user69514

Vous avez fondamentalement raison. Surcharger, c'est avoir plusieurs méthodes dans une même classe où la méthode porte le même nom. Cependant, la valeur de retour n'est pas considérée comme faisant partie de la signature de la méthode. Ainsi, vous ne pouvez pas surcharger une méthode en modifiant uniquement la valeur de retour. Vous ne pouvez pas avoir le code suivant, tiré de votre exemple:

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

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

Cela échouera à compiler.

Comme Rob l'a identifié, je pense que vous voulez dire prévaloir , et vous avez raison. Remarque: en cas de remplacement, vous ne pouvez pas modifier le type de retour. A partir de Java 5, vous pouvez renvoyer un type dérivé de ce que la méthode de classe de base a renvoyé. Avant Java 5, il devait s'agir d'un type identique. Autrement dit, vous ne pouvez pas effectuer les opérations ci-dessous avant Java 5 et les versions suivantes:

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

Cependant, même dans Java 5 et les versions ultérieures, vous ne pouvez pas effectuer les opérations suivantes:

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

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

Enfin, une grande différence entre la surcharge et la surcharge qui est souvent négligée est que la surcharge est décidée au moment de la compilation et que la priorité est décidée au moment de l'exécution. Cela surprend de nombreuses personnes lorsqu'elles s'attendent à une surcharge lors de l'exécution.

32
Eddie

Correct; la surcharge fournit plusieurs signatures pour la même méthode.

Remplacer, ce que je pense que vous entendez par "remplacer" est l'acte de fournir une implémentation différente d'une méthode héritée d'un type de base, et constitue fondamentalement le point de polymorphisme par héritage, c'est-à-dire.

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)
    }
}
6
Rob

ce que vous avez décrit est correct.

Pour plus de précisions, jetez un coup d'œil au concept de polymorphisme. Le Wikipedia a un bon article

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

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

0
Luixv