Verwenden einer Methode der Elternklasse mit der Variablen der Kindklasse ohne Überschreiben

Question

Ich entwerfe derzeit zwei Klassen in Java, und habe einige Probleme mit meinem aktuellen Problem der Vererbung zu verstehen, also habe ich einen einfachen Beispielcode in der Hoffnung, dass jemand kann mir helfen zu verstehen, was vor sich geht.

Also in diesem Beispiel eine Elternklasse (für allgemeine Zwecke könnten wir es Klasse Car nennen) und eine Kindklasse (Klasse RedCar). Die Elternklasse, die abstrakt ist, enthält eine Attributdistanz und enthält eine Methode von computeVelocity, die die Eingabeargumentzeit (doppelt) nimmt und einen doppelten Wert der Entfernung dividiert durch die Zeit zurückgibt (wodurch Geschwindigkeit gegeben ist).

Die Kindklasse hat einen Konstruktor, RedCar (double inputDistance). Es sollte auch Zugriff auf die Methode computeVelocity haben, ohne es zu überschreiben.

Hier ist das Problem. Logisch verstehe ich, dass computeVelocity die Variable inputDistance nicht von RedCar verwenden sollte, weil sie eine Methode einer anderen Klasse aufruft. Was ich jedoch wissen möchte, ist, wie man diese Methode in die RedCar-Klasse bringt, damit sie innerhalb der Klasse mit den Argumenten verwendet werden kann, die dem Konstruktor übergeben werden. Hier

ist ein Beispiel für den Code

//Car Class 
public abstract class Car{ 
    //abstract variable 
    private double distance; 
    //compute velocity method 
    public double computeVelocity(double time){ 
    return distance/time; 
    } 
} 




//RedCar Class 
public class RedCar extends Car{ 
    public double distance; 

    public RedCar (double inputDistance){ 
     this.distance = inputDistance; 
    } 
    //This is currently my method but I believe this already constitutes as overridding 
    public double computeVelocity(double hours){ 
     Car.super.computeVelocity(hours); 
    } 
} 

Answer 1

Wie in einigen Kommentaren angegeben Sie antworten, die Sie nicht wirklich brauchen, und sollte nicht den Abstand zweimal haben (einmal in der übergeordneten Klasse und einmal in der Kindklasse). Verwenden Sie den Abstandsparameter aus der übergeordneten Klasse und es gibt keinen Grund, Ihre Methode zu überschreiben. Sie können Ihre übergeordnete Klassenmethode mit dem Schlüsselwort super aufrufen.

Hoffe, das hilft.

Answer 2

Da die private Instanzvariable in der Unterklasse geerbt ist, aber in der Unterklasse nicht verfügbar ist (Sie können die Reflektion verwenden, um darauf zuzugreifen). Sie haben zwei Möglichkeiten, den Wert für die private private Double-Distanz der Car-Instanz anzugeben, indem Sie die öffentliche Setter- oder Getter-Methode bereitstellen oder den geschützten oder öffentlichen Konstruktor bereitstellen und diesen Konstruktor aus der Unterklasse aufrufen.

Siehe den Link Do subclasses inherit private fields? inherit-Private-Felder

Constructor in der Superklasse, die den Wert in dem privaten Abstand Variable weil privates Mitglied nur mit dem dort eigenen Elemente durch ihre eigene Methode und Konstrukteur bedeutet.

protected Car(double distance){ 
    this.distance = distance; 
    } 

Und auch Sie haben keine Notwendigkeit, den Abstand Variable wieder in der Unterklasse zu definieren, da Sie nicht in Ihrer Methode computeVelocity (der Unterklasse) verwendet wird. Da die Unterklassenmethode die Superklassenmethode und die Superklassenmethode aufruft, verwenden Sie eine eigene private doppelte Distanz. Ihre Distanzvariable definiert also eine Unterklasse, die nicht von der Superklassenmethode verwendet wird.

Nachdem Sie den geschützten Konstruktor in der Superklasse bereitgestellt haben, können Sie ihn vom Konstruktor der Unterklasse mit dem Schlüsselwort super aufrufen. Das Schlüsselwort super ruft den Konstruktor der Superklasse auf. Da wir den Konstruktor in der Superklasse angeben, fügt Java keinen Standardkonstruktor in der Superklasse hinzu. Und fordern, dass Konstruktor von Unterklasse mit Super den Wert in privaten Doppel Abstand zuweisen Variable

 public RedCar(double inputDistance) { 
    super(inputDistance); 

     } 

und richtige Art und Weise der Super-Klasse-Methode aufzurufen ist, keine Notwendigkeit, Car.Super

public double computeVelocity(double hours) { 
     return super.computeVelocity(hours); 
    } 

Answer 3

Ihre Klasse RedCar erbt Klasse Car. So ist Car nicht nur eine andere Klasse. Wenn Sie eine RedCar Instanz erstellen, sind alle Teile von Car ebenfalls verfügbar. A RedCarist einCar.

In Ihrer Lösung haben Sie sowohl in der Oberklasse als auch in der Unterklasse ein Feld distance angelegt. Tatsächlich haben Sie zwei Felder mit dem Namen distance in jeder RedCar Instanz.

Hier kommt die Sichtbarkeit in Betracht. Obwohl die private Variable distance Teil von RedCar ist, ist sie nur in der Klasse Car sichtbar. Wenn nur die in Car definierten Methoden auf distance zugreifen müssen, muss die Sichtbarkeit nicht geändert werden. Aber Sie brauchen eine Möglichkeit, um die distance einzustellen. Wenn sich der Wert im Laufe der Zeit nicht ändert, sollten Sie einen Konstruktor in die Klasse Car aufnehmen.

Die Sichtbarkeit der Methode computeVelocity(), die in Car definiert wurde, ist öffentlich, daher muss sie in der Unterklasse nicht wiederholt werden. Da ein RedCar ein Car ist, können Sie computeVelocity() auf jeder RedCar Instanz aufrufen.

public abstract class Car{ 
    private double distance; 

    // Constructor with visibility protected. 
    // So it is visible in each subclass and must be 
    // called by each subclass constructor. 
    // Btw.: It is common practice to use the same name 
    // for input parameters as for fields. The field 
    // variable can be accessed with the "this" keyword. 
    protected Car(double distance) { 
    this.distance = distance; 
    } 

    //compute velocity method 
    public double computeVelocity(double time){ 
    return distance/time; 
    } 
} 


public class RedCar extends Car{ 
    public double distance; 

    public RedCar (double distance){ 
    // Call the Car constructor 
    super(distance) 
    } 

    // No need to repeat the definition of 
    // computeVelocity unless you want to redefine 
    // the behaviour.. 
} 

Dann, wenn Sie erstellen RedCar Beispiel:

RedCar redCar = new RedCar(100.0); 

zuerst die RedCar Konstruktor aufgerufen wird, die dann ruft die Car Konstruktor, der die distance Feld 100.0 setzt.

Sie können die Methode aufrufen:

double velocity = redCar.computeVelocity(60.0);