Warum deklariert man Variablen in Methodenkopf?

[Keksmanu]

Hi,Wenn ich hier z.b diese Methode habe: "public test(int a){}"
könnte ich dann nicht auch "public test(){ int a}" machen? was ist der Zweck zeugs im Methodenkopf zu deklarieren?

Hoffe man versteht meine Frage 😉
mfg Keks

 

[turtle]

public test(int a) bzw. public test() sind keine gültige Methoden SIgnaturen, da Angabe über den über den Return-Wert fehlt.

Wären welche angegeben, sind es zwei VERSCHIEDEN Methoden
public void test(int a) ist eine Methode mit einem int-Parameter
public void test() ist eine Methode ohne Parameter, also völlig anders.

 

[kaoZ]

Gültige Methodendeklarationen wären z.B

1. Eine Methodendeklaration mit Rückgabetyp void, also ohne Rückgabe und einer Integer Variable als Eingabeparameter

2. Eine Methodendeklaration mit Rückgabetyp Test und einer Integer Variable als Eingabeparameter

public void test(){
  //Methode ohne Rückgabewert und Eingabeparameter
}

public void test(int a){
  //Überladene Methode mit Integer Variable als Eingabeparameter
}

public Test test(int a){

  /*gibt ein neues Test Objekt zurück / Methode zählt NICHT als Überladen,
   *zudem sollten keine identischen Bezeichner für unterschiedliche Methoden genutzt werden. */

  return new Test(); 
}

Das hier wären Beispiele für einen Standardkonstruktor und einen überladenen ( hier der Klasse Test)

public Test(){} // Leerer Standard Konstruktor

public Test(int a){
  // Überladener Konstruktor da selber Name , aber Angabe eines EingabeParameters
}

Konstruktoren erkennst du daran das,

- kein Rückgabewert ( void / Test / usw.)
- keine Modifizierer ( static / final )
- Bezeichner immer Identisch mit dem Klassennamen ( die man zudem immer UpperCamelCase schreibt)

Gibst du keine Konstruktoren an werden durch die JVM bei Objekterzeugung immer die leeren Standardkonstruktoren aufgerufen.

 

[JavaMeister]

Implementiere eine Methode, die zwei ganzzahlen addiert.

Dann sieht man schon, wieso da Parameter rein kommen und wann nicht.

 

[OnDemand]

kaoZ hat es gut auf den Punkt gebracht. Eine Methode hat immer einen Rückgabetypen oder void, wenn sie nix zurückgeben soll.

 

[snueffel]

ich glaube das Problem ist das fehlende Verständnis von einer "Deklaration":

public void(int a)

int a ist hierbei ein Übergabeparameter für die Methode - Die Methode benötigt diesen um "wie gewünscht" zu arbeiten, d.h. es wird immer die gleiche Aktion ausgeführt mit einem bestimmten Wert für a.

void beschreibt hierbei dass die Methode beim Aufruf nichts zurückgibt. Möchte ich jedoch mit einer Methode beispielsweise zwei Ganzzahlen addieren und das Ergebnis erhalten, muss ein Rückgabetyp, in diesem Fall ein int, angegeben werden:

public int addiere(int zahl1, int zahl2)
{
    return zahl1+zahl2;
}

return beschreibt dabei, was zurückgegeben wird: Hier werden die beiden Parameter addiert und dann zurückgegeben. Ein aufruf in der main-Methode könnte dann wie folgt aussehen:

int erg = addiere(1, 1);
System.out.println(erg); // -> 2

 

[Beatsleigher]

Auch wenn hier sehr gute, und vor allem hilfreiche Antworten sind, ich glaube ich kann das hier vereinfachen:

public void method() {  }

ist eine Methode, die keine Parameter annimmt, das heißt, de Methode müsste dann evtl. auf Klassenvariablen zurückgreifen, um einfachste Dinge zu erledigen, und in manchen Fällen ist das ein klarer Verstoß gegen die Prinzipien der objektorientierten Programmierung.

Hier ein Beispiel:
Einmal mit Parameterübergabe, und einmal ohne.

class System {
     // Mit
     public static String getProperty(String identifier) { return <Eigenschaft von identifier>; }

    // Jetzt wird die Methode aufgerufen:
    System.out.println("User name is: " + getProperty("user.home"));

    // Ohne
    public static String identifier = "";
    public static String getProperty() { return <Eigentschaft von identifier>; }

    // Jetzt wird die Methode aufgerufen:
    identifier = "user.home";
    System.out.println("User name is: " + getProperty());
}

Im obigen Beispiel sieht man einen gravierenden Verstoß:
Datenkapselung.

Wenn diese Methode in einer anderen Klasse aufgerufen würde (also, die 2.), und du mit einer andere Klasse/Methode die gleiche Methode in System aufrufst, würdest du evtl. den gleichen Wert bekommen, und dein Programm könnte dir um die Ohren fliegen.
Klar, du könntest die Methoden ohne static erstellen, und Instanzen der Klasse erstellen, aber es geht hier um's Prinzip.
Jetzt zu den Folgen des Verstoßes gegen das Prinzip der Datnkapselung:
(Wie oben gennant), kann man ausversehen den gleichen Wert bekommen, was ein Memoryleak wäre.
Nun, in erster Linie mag es für dich nicht schlimm wirken, es mag sogar bei dir alles perfekt funktionieren.
Nun stell dir aber vor, du packst so eine Monströsität in eine Klassenbibliothek, und irgend ein Nutzer hat dann in einem Programm, welches diese Lib benutzt, zwei Fenster offen, die auf diese Methode zeitgleich zugreifen.
Der Nutzer würde:
a) die gleichen Werte bekommen, was eventuell sogar einen schwerwiegenden Rechenfehler bewirkt, und seiner Firma (jetzt übertrieben) Milliarden an Verlusten kostet, und der Nutzer weiß nicht warum. Im schlimmsten Fall musst du dann dafür aufkommen.
oder
b) der Nutzer kriegt ein Haufen Exceptions, weil, z.B., das Programm versucht, einen String in einen double zu packen, das Programm stürzt ab, der Kunde benutzt das Programm nicht mehr, weil er es scheibenkleisterig findet, und du hast dann einen Kunden weniger, und du musst ihm eventuell sein Geld erstatten.

Das sind nur zwei Beispiele, aber es sind noch viele mehr da.

Ich hoffe ich habe es dir verständlich gemacht, wieso man diese Parameter benutzt 🙂