Mit Objekt der Superklasse auf Methode der Subklasse zugreifen

Diskutiere Mit Objekt der Superklasse auf Methode der Subklasse zugreifen im Java Basics - Anfänger-Themen Bereich.
N

Noccctis

Guten Abend,

ich verstehe nicht wieso ich mit dem Erstellen eines Objektes Huhn nicht auch auf die Methode zugreifen kann.
Organismus d = new Huhn; klappt nicht, aber Huhn d = new Huhn; geht.

Ich meine Huhn erbt ja von Organismus, und ich definieren es ja auch als new Huhn.
Was genau verstehe ich hier falsch? Ich kann die Methode nicht abstrakt machen,
da andere Klassen auch von Organismus erben, aber die Methode nicht besitzen sollen.

Java:
public class TestOrganismus {
    public static void main(String[] args) {
        
        Organismus[] lebewesen = new Organismus [5];
        
        //Organismus d = new Huhn geht nicht?
        
        Huhn d = new Huhn(10.3, 3, "Freiland", "Weiß");
        
        lebewesen[0] = d;
        
        System.out.println(d.leistungProJahr());
        
        
        
    }
}
Java:
public abstract class Organismus{

    public String ID;
    public double gewicht;
    static int count =1;
    
    public Organismus(double gewicht){
        
        if(this instanceof Huhn)
        this.ID = "Huhn" + count++;
        
        if(this instanceof Katze)
        this.ID= "Katze" + count++;
        
        if(this instanceof Kartoffel)
        this.ID= "Kartoffel" + count++;
        
        if(this instanceof Pflanze)
        this.ID= "Pflanze" + count++;
        
        if(this instanceof Tulpe)
        this.ID="Tulpe" + count++;
        
        if(this instanceof Orchidee)
        this.ID= "Orchidee" + count++;
        
        
        this.gewicht = gewicht;
        
    }
    
}
Java:
public class Huhn extends Organismus implements Ertrag{

    public int eierProJahr; // Ertrag pro Jahr
    public String haltung; // 'Oekologische Erzeugung', 'Freiland', 'Boden' oder 'Kleingruppen'
    public String farbe;
    
    public Huhn(double gewicht, int eierProJahr, String haltung, String farbe){
        super(gewicht);
        this.eierProJahr = eierProJahr;
        
        if(haltung =="Oekologische Erzeugung" || haltung == "Freiland" || haltung == "Boden" || haltung == "Kleingruppen")
        this.haltung = haltung;
        
        else
        System.exit(0);
        
        this.farbe = farbe;
    }
    
    public String leistungProJahr () {
        String str = "Eier pro Jahr: " + eierProJahr;
        return str;
    }
}
 
Kirby_Sike

Kirby_Sike

Das liegt daran, das soweit ich weiß, man abstrakte Klassen nicht in non abstract Klassen instanzieren kann. Es geht mit Huhn da sie nicht abstrakt ist, jedoch aber von Organismus erbt.
 
H

httpdigest

Du kannst eine Methode nur auf einem Ausdruck aufrufen, dessen statischer/compilezeit-Typ auch diese Methode besitzt.
Im Falle:
Java:
Organismus d = new Huhn(...);
d.leistungProJahr(); // <- Aufruf auf Organismus als statischer Typ
rufst du die Methode leistungProJahr auf einem Ausdruck (nämlich der Variablen `d`) auf, deren statischer Typ nur `Organismus` ist. Du musst dir das so vorstellen, dass die Variable `d` bzw. der Compiler ja überhaupt nicht weiß, welche Instanz die Variable `d` gerade zum Zeitpunkt des Aufrufes enthält. Es könnte ja ein sehr viel komplexerer Ausdruck mit vielen Methodenaufrufen (statt einem einfachen `new Huhn(...)`) sein, der der Variablen als Wert zugewiesen wird.
Den Compiler interessiert nur der statische Typ des Ausdrucks, auf dem du eine Methode aufrufst. Der Ausdruck in diesem Fall ist die Variable `d` und ihr statischer/compilezeit-Typ ist `Organismus`. Und dieser Typ besitzt nun mal die Methode nicht.
Auch, wenn man wie in diesem einfachen Fall sicherlich durch Dataflow/Typeflow-Analyse herausfinden könnte, dass die Variable zum Zeitpunkt des Methodenaufrufes nunmal nur ein Objekt vom Typ `Huhn` enthält, und somit der Methodenaufruf funktionieren könnte, tut das der Java Compiler nunmal leider nicht.

EDIT: Vielleicht noch folgendes, um den Unterschied zwischen statischem/compilezeit-Typ und dynamischem/Laufzeittyp hervorzuheben und zu zeigen, warum der Compiler sich nur für den statischen Typ interessiert:
Java:
Object d = heuteIstDienstag() ? new Integer(3) : new String("blubb");
// ... mehr Code ...
d.intValue();  // <- Integer.intValue()
// Das oben sollte eigentlich Dienstags funktionieren,
// funktioniert aber niemals! Wieso weiß der Compiler nicht,
// dass heute Dienstag ist?!?! Und selbst wenn, was wäre,
// wenn der Code erst morgen ausgeführt würde??
 
Zuletzt bearbeitet:
Wurstkopp

Wurstkopp

Offtopic:

Java:
public String haltung; // 'Oekologische Erzeugung', 'Freiland', 'Boden' oder 'Kleingruppen'
Schau dir mal Java enums an.
 
T

temi

Was du dir auch nochmal überlegen solltest:

Du erzeugst die ID von Organismus, indem du schaust, von welchem Typ die aktuelle Instanz ist. Dadurch machst du die Klasse Organismus abhängig von vielen anderen Klassen. Sobald eine neue Subklasse von Organismus eingeführt wird, musst du auch Organismus anpassen. Das ist nicht gut und auch nicht nötig.
Eine mögliche Lösung wäre z.B. diese:
Java:
public abstract class Organismus {

    private final String id; // Klassen sollten so viel wie möglich verbergen, deshalb 'private' + getID()
    private double gewicht; // hier auch, den Getter habe ich weggelassen
    private static int count =1; //hier auch

    public Organismus(double gewicht){
        this.id = id() + count++;
        this.gewicht = gewicht;
    }

    public String getID() {
        return this.id;
    }

    protected abstract String id();
}

public class Huhn extends Organismus {

    public Huhn(double gewicht) {
        super(gewicht);
    }

    @Override
    protected String id() {
        return "Huhn";
    }
}
Da Organismus als abstrakte Klasse nicht instantiiert werden kann, könnte man die ID aber auch einfach im Konstruktor übergeben:
Java:
public abstract class Organismus {

    private final String id; // Klassen sollten so viel wie möglich verbergen, deshalb 'private' + getID()
    private double gewicht;
    private static int count =1;

    public Organismus(String id, double gewicht){
        this.id = id + count++;
        this.gewicht = gewicht;
    }

    public String getID() {
        return this.id;
    }
}

public class Huhn extends Organismus {

    public Huhn(double gewicht) {
        super("Huhn", gewicht);
    }
}
 
Zuletzt bearbeitet:
J

JustNobody

Oder wenn es immer der Klassenname sein soll, dann kann man natürlich auch einfach ein getClass().getName() aufrufen, um eben diesen zu bekommen.
 
T

temi

Oder wenn es immer der Klassenname sein soll, dann kann man natürlich auch einfach ein getClass().getName() aufrufen, um eben diesen zu bekommen.
Das ist sehr gut und ich würde es das ggf. in eine separate Methode auslagern, damit in den erbenden Klassen darauf Einfluss genommen werden kann:
Java:
public abstract class Organismus {

    private final String ID;
    private double gewicht;
    private static int count =1;

    public Organismus(double gewicht){
        this.ID = id() + count++;
        this.gewicht = gewicht;
    }

    public String getID() {
        return this.ID;
    }

    protected String id() {
        return this.getClass().getName(); // Hier wird ein Standardname aus dem Klassennamen erzeugt
    }
}

// Das Standard-Huhn
public class Huhn extends Organismus {

    public Huhn(double gewicht) {
        super(gewicht);
    }
}

// Von Organismus erbende Klasse können das aber auch ändern, falls erforderlich:
public class Huhn extends Organismus {

    public Huhn(double gewicht) {
        super(gewicht);
    }

    @Override
    protected String id() {
        return "Sup(p)erhuhn";
    }
}
 
Thema: 

Mit Objekt der Superklasse auf Methode der Subklasse zugreifen

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben