Frage zu this, super und return

N

Nummer11

Mitglied
Ich habe mal in einem Code gesehen, dass da sowas stand wie: "return this", "return super" oder auch einfach nur "return" .
Was ich nicht verstehe ist, was dann zurückgegeben wird, da ja bei den Beispielen entweder garnichts nach dem return kommt oder ein Schlüsselwort. Kann mir einer vllt an einem Beispielcode erklären, was da genau passiert?
 
return this; gibt einfach eine Referenz auf das gleiche Objekt zurück, d.h. die Methode in der das geschieht hat als Return-Typ die gleiche Klasse wie die zu der diese Methode gehört.
return super; glaube ich nicht dass du das gesehen hast
return; gibt einfach nichts zurück, d.h. methode hat als Return-Typ void.
 
Das Zurückgeben von this kann bequem sein, wenn man mehrere Methoden für eine Referenz aufrufen will (oder eine Methode mehrfach). Man kann dann schreiben:
Java: 
meinObjekt.tuDies().tuDas().tuDas().tuJenes();
 
Was ist überhaupt ein "return"?
Hier drei Beispiele:
Code: 
/*
Prozedur void
Beim Aufruf der Prozedur beispiel wird
als erstes ermittelt, ob eine Bedingung,
hier !vornFrei() erfuellt ist.
Wenn dies der Fall sein sollte, dann
wird die Prozedur an der Stelle abgebrochen.
Wenn vornFrei() sein sollte, dann wird der
Reihe nach abgearbeitet,
sprich vor(), linksUm() usw.
*/
void beispiel() {
    if(!vornFrei()) {
        return;
    }
    vor();
    linksUm();
}
/*
Funktion boolean
Sehr wichtig ist hier, dass die Funktionen
keine Seiteneffekte liefern.
Sprich, es soll nur wahr oder falsch geliefert
werden, ohne, dass an dem Programm etwas veraendert
wird
*/
boolean linksFrei() {
    linksUm();
    if(!vornFrei()) {
        rechtsUm(); //Kein Seiteneffekt
        return false;
    } else {
        rechtsUm(); //Kein Seiteneffekt
        return true;
    }
}

/*
Funktion integer
Einer Variable vom Typ int namens wievielStufen
wird eine int-Prozedur zugewiesen.
*/
int wievielStufen = zaehleStufen();
int zaehleStufen() {
    int stufen = 0;
    while(bedingung()) {
        gehHoch();
        /*
        Var. stufen wird nach jedem Aufruf
        der Prozedur gehHoch()
        um eins erhoeht
        */
        stufen++;
    }
    /*
    Wenn die bedingung erfuellt ist, wird der
    ermittelte Wert (eine Zahl) der Var. wievielStufen
    zugewiesen
    */
    return stufen;
}

/*
Wichtig ist dabei:
Ein return in void kann, muss aber nichts zurueckliefern.
Ein return des Typ n muss ein Wert von Typ n liefen.
Boolean muss wahr oder falsch, Int muss eine Zahl liefern.
*/
 
Javinner hat gesagt.:
Sehr wichtig ist hier, dass die Funktionen
keine Seiteneffekte liefern.
Zum Vergrößern anklicken....
Das hat aber überhaupt nichts mit Rückgabetypen und return zu tun 😉

Javinner hat gesagt.:
Einer Variable vom Typ int namens wievielStufen
wird eine int-Prozedur zugewiesen.
Zum Vergrößern anklicken....
Der Variable wird das Ergebnis des Funktionsaufrufs zugewiesen, eine "Prozedur" kann mein keinem int zuweisen.

Javinner hat gesagt.:
Ein return in void kann, muss aber nichts zurueckliefern.
Zum Vergrößern anklicken....
Ein "return in void"? Eine Methode mit Rückgabetyp void *kann* nichts zurückliefern.
 
Zu "this" kann ich im Augenblick nur dies hier sagen:
Code: 
/*
Jede Klasse hat Attributen und Methoden.
Attribute definieren die Eigenschaften.
Methoden definieren die Befehle.

Angenommen, Klasse StandardKlasse hat nur eine
Attribute blickrichtung und die Methode linksUm()
Nun wuenscht man sich aber mehr Methoden, ohne
die Klasse StandardKlasse zu veraendern.
*/
class StandardKlasse {
    //Attribute
    private int blickrichtung;
    //Methoden
    public void linksUm() {/*Implementierung*/}
}
/*
So wird eine neue Klasse EigeneKlasse von Klasse StandardKlasse
erstellt. In der Klasse EigeneKlasse wird eine neue Methode
rechtsUm() erstellt und, da diese Klasse von der StandardKlasse
die Methode linksUm() geliefert bekommt, kann mit hilfe dieser
die neue Methode erstellt werden.

Wichtig dabei ist, dass StandardKlasse nach wie vor nur
die Methode linksUm() kennt. Die EigeneKlasse kennt bereits
linksUm() und rechtsUm().

Also wird jedes Objekt der Klasse EigeneKlasse auf zwei Methoden
linksUm() und rechtsUm() zugreifen können.
Das Wort "this" dient hier letztendlich als Platzhalter fuer
den Objekt-Bezeichner, sprich, die Klasse EigeneKlasse kann von
mehreren Objekten aufgerufen werden und bei jedem Aufruf ist "this"
der Platzhalter fuer den Bezeichner (Name der Prozedur usw.),
der gerade die Klasse EigeneKlasse aufruft.
*/
class EigeneKlasse extends StandardKlasse {
    //Neue Mehtode rechtsUm()
    void rechtsUm() {
        this.linksUm();
        this.linksUm();
        this.linksUm();
    }
}
/*
Ein finales Beispiel:
Ohne EigeneKlasse
*/
void rechtsUm() {
    this.linksUm();
    this.linksUm();
    this.linksUm();
}
//Aufruf
bezeichner.linksUm();
aber!
rechtsUm(bezeichner);
/*
Mit EigeneKlasse
*/
//Aufruf
bezeichner.rechtsUm();
Uebersichtlicher und einfacher in der Handhabung,
weil dann alles nach bestimmter Art aufgerufen werden kann.
 
Zuletzt bearbeitet:
Code: 
/*
Die Funktion liefert wahr oder falsch.
Die Blickrichtung des Hamsters(Objekt der Klasse Hamster)
wird nicht veraendert
*/
boolean linksFrei() {    //Blickrichtung Ost
    linksUm();            //Blickrichtung Nord     
    if(!vornFrei()) {
        rechtsUm();     //Blickrichtung Ost, kein Seiteneffekt
        return false;
    } else {
        rechtsUm();     //Blickrichtung Ost, kein Seiteneffekt
        return true;
    }
}
JStein52 hat gesagt.:
Was meinst du da zum Beispiel ? Kannst du vielleicht mal ein Gegenbeispiel hinschreiben ?
Zum Vergrößern anklicken....

Dabei handelt es sich nach wie vor um den Hamster-Simulator.
Hier mit Seiteneffekt:
Code: 
/*
Die Funktion liefert wahr oder falsch.
Die Blickrichtung des Hamsters(Objekt der Klasse Hamster)
wird nicht veraendert
*/
boolean linksFrei() {    //Blickrichtung Ost
    linksUm();            //Blickrichtung Nord       
    if(!vornFrei()) {
        rechtsUm();     //Blickrichtung Ost, kein Seiteneffekt
        return false;
    } else {
                         //Blickrichtung Nord, wenn true
        return true;
    }
}
 
Javinner hat gesagt.:
Das Wort "this" dient hier letztendlich als Platzhalter fuer
den Objekt-Bezeichner, sprich, die Klasse EigeneKlasse kann von
mehreren Objekten aufgerufen werden und bei jedem Aufruf ist "this"
der Platzhalter fuer den Bezeichner (Name der Prozedur usw.),
der gerade die Klasse EigeneKlasse aufruft.
Zum Vergrößern anklicken....
Nein, this meint die aktuelle Instanz der Klasse, in der das this steht.
Das hat nichts mit dem Aufrufer der Funktion zu tun, ist absolut kein Platzhalter für einen Bezeichner und erst recht nicht für eine Prozedur.
 
"Das Wort "this" dient hier letztendlich als Platzhalter fuer
den Objekt-Bezeichner" ist das, was ich zu diesem Thema gerade sagen kann. Da ich ein Anfänger bin, kann ich nur das Meinen, was ich bis zum Dato gelesen und ausprobiert habe.

Im übrigen wäre es begrüßenswert, wenn man dem Halbwissen, welches ich ohne Zweifel vorweise, auf eine alte englische Art begegnen würde,
sprich, eine fachliche Ergänzung. So, dass ich und der Ersteller dieses Treads hier "das nächste Level" erreichen. Und das wollen wir doch alle, oder?


Habt also Gnade mit mir 😉 frisch angefangen.

"Das mag ja im Hamster-Simulator falsch sein ... aber wie lautet die allgemeine Aussage ?"
Komm nicht mit, weiß nicht, was du gerade meinst.
 
mrBrown hat gesagt.:
Nein, this meint die aktuelle Instanz der Klasse, in der das this steht.
Das hat nichts mit dem Aufrufer der Funktion zu tun, ist absolut kein Platzhalter für einen Bezeichner und erst recht nicht für eine Prozedur.
Zum Vergrößern anklicken....
War unglücklich erklärt, natürlich muss diese Prozedur/Methode in dem Klassen-Rumpf definiert/erzeugt werden, so dass "this" zum Platzhalter wird.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

super.methode / super.variable und super(variable)
Antworten: 2
super-Konstruktor ist nicht super ;)
Antworten: 6
super-super-Konstruktor?
Antworten: 3
super.super
Antworten: 7
Überschreiben einer "super.super"-Methode
Antworten: 6

Zurück
Oben