Methoden und ihre Eigenschaften

[Thisor]

Hey, ich behalte glaub nicht so ganz den Übersicht bei den Methoden und ihren Eigenschaften. Google habe ich bereits benutzt und ich lerne hauptsächlich in Java ist auch eine Insel aber so ganz selbsterklärend finde ich das dann doch irgendwie nicht.

public:
Ist für alle Pakete und Klassen sichtbar, aber nur innerhalb eines Projekts.
private:
Ist nur innerhalb des Pakets für andere Klassen sichtbar.
protected:
Attribute/Eigenschaften sind für die Klassen sichtbar, die nur von der Mutterklasse geerbt werden.

static:
Ist eine statische Methode(was ist damit konkret gemeint?)
Hat einen Rückgabe-Wert(return), kann in der Methode, sofern Parameter gegeben werden, damit weiter arbeiten und kann in der Main-Methode aufgerufen werden.

void:
Diese Methode enthält kein Rückgabe-Wert, kann aber dennoch in der Main-Methode aufgerufen werden (zweck bzw Sinn der Methode?)

Main-Methode: die Haupt-Methode, was das Programm machen soll, welche Methoden aufgerufen werden sollen.

Es gibt aber auch Methoden wie z.b.

static void variablenName

also eine Methode die ein RückgabeWert und zugleich keinen hat?
Die Main-Methode besteht ja auch aus

public static void main

Wofür benutze/brauche ich Void-Methoden und worin genau besteht der Unterschied zwischen dynamische und statische-Methoden?

Und: Was genau sind mit Call-by-Value und Call-by-Reference gemeint?
Dass die Parametern durch Variablen in der Methode aufgerufen (bzw kopiert) werden?
Worin liegt der Unterschied?

 

[Tobse]

1. Public/Protected/Private

Diese heissen "Zugriffsbeschränkungen" oder auf English "access modifiers". Sowohl bei Instanzvariablen als auch bei Methoden verhält es sich so:

modifier  | jeder | Package | Subklassen | Klasse
----------+-------+---------+------------+------------
public    |  JA   |   JA    |     JA     |     JA
----------+-------+---------+------------+------------
protected | NEIN  |   JA    |     JA     |     JA 
----------+-------+---------+------------+------------
<keiner>  | NEIN  |   JA    |    NEIN    |     JA
----------+-------+---------+------------+------------
private   | NEIN  |  NEIN   |    NEIN    |     JA

In der Java-Welt gibt es keine Projekte (das ist nur in der IDE). Wenn etwas public ist, kann jeder darauf zugreiffen, der die entsprechende .class Datei hat.

(siehe: https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)

2. static

Static bedeutet, dass es kein Objekt benötigt, um auf diese Methode aufzurufen. Der Rückgabewert hat mit static überhaupt nichts zu tun.

class Test {
    public static void sth() {}
    public void sthElse() {}

    public static void main(String[] args) {
        Test.sth(); // OK
        (new Test()).sthElse(); // OK
        Test.sthElse(); // Compilerfehler: sthElse muss auf einer Instanz von Test aufgerufen werden
        (new Test()).sth(); // Compilerfehler: sth braucht keine Instanz.
    }
}

3. void

"Diese Methode enthält kein Rückgabe-Wert, kann aber dennoch in der Main-Methode aufgerufen werden." Auch hier: void und static sind zwei völlig verschiedene Dinge. Es ist in Java auch völlig egal, von wo eine Methode aufgerufen wird, sofern der access modifier (siehe oben) es zulässst. Die main-Methode macht da keinen Unterschied.

Void bedeutet, dass die Methode keinen Rückgabewert hat. Das braucht man immer dann, wenn eine Methode zwar etwas tun soll, aber es keinen sinnvollen rückgabewert gibt (z.B. System.out.println).

4. Call-by-Reference / Call-by-Value

Da bist du schon auf der richtigen Spur. Call-by-Value bedeutet, dass der Wert einer Variablen in die aufgerufene Methode kopiert wird. Call-by-Reference bedeutet, dass die aufgerufene Methode nur eine Referenz auf den Wert übergeben bekommt. Alle Änderungen, die die aufgerufene Methode macht, bleiben auch nach dem Aufruf erhalten (anders wie bei Call-by-Value).

In Java wird Call-by-Value bei allen nativen Datentypen genutzt (boolean, short, int, long, float, double). Call-by-Reference kann man bei diesen Datentypen nicht verwenden.
Alle Objekte (oder auch "komplexe Datentypen") werden by-Reference übergeben; Call-by-Value kann man bei Objekten nicht verwenden. Beispiel:

public class Test {
    public int var = 1;
    
    public static void main(String[] args) {
        boolean var2 = true;
        Test objekt = new Test();
        
        methode(objekt, var2);

        System.out.println(var2);
        System.out.println(test.var);
    }

    private static void methode(Test testObjekt, boolean nativerDatentyp) {
        // testObjekt: Call-by-Reference: diese Änderung bleibt
        testObject.var = 5;

        // nativerDatentype: Call-By-Value: diese Änderung findet nur in dieser Methode statt
        nativerDatentype = false;
    }
}

Das gibt folgende Ausgabe:

true
5

 

[Thisor]

Alle Änderungen, die die aufgerufene Methode macht, bleiben auch nach dem Aufruf erhalten (anders wie bei Call-by-Value).

Das heißt dann quasi :

    static double avg(double x, double y) {
        return (x + y) / 2;
    }

    public static void main(String[] args) {

        double x = 3;
        double y = 2;

        avg(x,y);
       
    }

dass ich mit avg(x,y) weiter arbeiten kann, richtig?
Kann ich denn eine neue Methode erstellen, wo die neuen Werte von avg(x,y); weitergegeben werden und damit dann weiter arbeiten?

z.b:

static double calcEverything (avg(x,y))

double i = 0;
i = avg(x,y) + 2 + 3+4;

return i ;
}

Wäre das dann auch zugleich eine überladene Methode?

 

[Tobse]

Richtig, mit avg(x,y) kannst du dann weiterarbeiten. Allerdings nicht so, wie du es da hast sondern so:

static double calc(double x) {
    return x + 2 + 3 + 4;
}


    calc(avg(x, y));

Eine überladene Methode ist etwas völlig anderes. Ich würde vorschlagen, dass du zuerst diese Basics übst, bevor du dich mit überladenen Methoden und Vererbung beschäftigst.

 

[Thisor]

nooiin,
ich muss das wissen in mich reinprügeln 😀
also, ich hab ein testat in ca 4 wochen
btw ich arbeite auch mit Veerbungen, vllt kann es ja sein dass ich bereits überladene Methoden benutze mir das aber nicht bewusst bin 😀

 

[Tobse]

4 Wochen sind genug Zeit ... 😀 wenn du diese Woche noch mit den Grundlagen ohne Vererbung fertig wirst, hast mehr als reichlich zeit für den Rest 🙂 Unstrukturiert und unvollständig lernen bringt dich auch nicht durch den Test 😉