Static / non-static (Java): Unterschied zwischen den Versionen

Aus Byte-Welt Wiki
Zur Navigation springenZur Suche springen
(Rechtschreibfehler und Typos korrigiert/entfernt)
K
 
(Eine dazwischenliegende Version desselben Benutzers wird nicht angezeigt)
Zeile 11: Zeile 11:
  
 
{|
 
{|
|style="width:30em"|<code=java>public class ExternalClass {
+
|style="width:30em"|<syntaxhighlight lang="java">public class ExternalClass {
  
 
   public static int number=5;
 
   public static int number=5;
Zeile 32: Zeile 32:
 
   }
 
   }
  
}</code=java>
+
}</syntaxhighlight>
 
|style="width:1em"|
 
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {
+
|style="width:30em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public static void main(String[] args) {
 
   public static void main(String[] args) {
Zeile 56: Zeile 56:
 
       
 
       
 
       
 
       
</code=java>
+
</syntaxhighlight>
 
|}
 
|}
  
 
Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
 
Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
 
{|
 
{|
|style="width:61em"|<code=java>public class MyProgram {
+
|style="width:61em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public static int number=5;
 
   public static int number=5;
Zeile 94: Zeile 94:
  
 
}     
 
}     
</code=java>
+
</syntaxhighlight>
 
|}
 
|}
  
Zeile 103: Zeile 103:
  
 
{|
 
{|
|style="width:61em"|<code=java>public class MyProgram {
+
|style="width:61em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public static void main(String[] args) {
 
   public static void main(String[] args) {
Zeile 113: Zeile 113:
  
 
}     
 
}     
</code=java>
+
</syntaxhighlight>
 
|}
 
|}
  
Zeile 126: Zeile 126:
  
 
{|
 
{|
|style="width:30em"|<code=java>public class ExternalClass {
+
|style="width:30em"|<syntaxhighlight lang="java">public class ExternalClass {
  
 
   public int number=5;
 
   public int number=5;
Zeile 150: Zeile 150:
 
   }
 
   }
  
}</code=java>
+
}</syntaxhighlight>
 
|style="width:1em"|
 
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {
+
|style="width:30em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public static void main(String[] args) {
 
   public static void main(String[] args) {
Zeile 177: Zeile 177:
 
       
 
       
 
       
 
       
</code=java>
+
</syntaxhighlight>
 
|}
 
|}
  
Zeile 185: Zeile 185:
  
 
{|
 
{|
|style="width:61em"|<code=java>public class MyProgram {
+
|style="width:61em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public int number=5;
 
   public int number=5;
Zeile 222: Zeile 222:
  
 
}
 
}
</code=java>
+
</syntaxhighlight>
 
|}
 
|}
  
Zeile 229: Zeile 229:
 
Beispiele für die Verwendung von nicht-statische Methoden im JRE:
 
Beispiele für die Verwendung von nicht-statische Methoden im JRE:
 
{|
 
{|
|style="width:61em"|<code=java>import javax.swing.*;
+
|style="width:61em"|<syntaxhighlight lang="java">import javax.swing.*;
 
import javax.swing.border.*;
 
import javax.swing.border.*;
 
import java.awt.*;
 
import java.awt.*;
Zeile 277: Zeile 277:
 
   }
 
   }
 
    
 
    
}</code=java>
+
}</syntaxhighlight>
 
|}
 
|}
  
Zeile 286: Zeile 286:
  
 
{|
 
{|
|style="width:61em"|<code=java>import javax.swing.*;
+
|style="width:61em"|<syntaxhighlight lang="java">import javax.swing.*;
 
import javax.swing.border.*;
 
import javax.swing.border.*;
 
import java.awt.*;
 
import java.awt.*;
Zeile 335: Zeile 335:
 
   }
 
   }
 
    
 
    
}</code=java>
+
}</syntaxhighlight>
  
 
Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.
 
Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.
Zeile 343: Zeile 343:
  
 
{|
 
{|
|style="width:61em"|<code=java>import javax.swing.*;
+
|style="width:61em"|<syntaxhighlight lang="java">import javax.swing.*;
 
import javax.swing.border.*;
 
import javax.swing.border.*;
 
import java.awt.*;
 
import java.awt.*;
Zeile 387: Zeile 387:
 
    
 
    
 
}
 
}
</code=java>
+
</syntaxhighlight>
  
 
Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:
 
Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:
  
 
{|
 
{|
|style="width:61em"|<code=java>import javax.swing.*;
+
|style="width:61em"|<syntaxhighlight lang="java">import javax.swing.*;
 
import javax.swing.border.*;
 
import javax.swing.border.*;
 
import java.awt.*;
 
import java.awt.*;
Zeile 443: Zeile 443:
 
   }
 
   }
 
    
 
    
}</code=java>
+
}</syntaxhighlight>
  
 
Hier sieht man noch mal, dass statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.
 
Hier sieht man noch mal, dass statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.
Zeile 457: Zeile 457:
  
 
{|
 
{|
|style="width:30em"|<code=java>public class BaseClass {
+
|style="width:30em"|<syntaxhighlight lang="java">public class BaseClass {
  
 
   public static void printFirstText() {
 
   public static void printFirstText() {
Zeile 467: Zeile 467:
 
   }
 
   }
 
    
 
    
}</code=java>
+
}</syntaxhighlight>
  
<code=java>public class ExternalClass extends BaseClass{
+
<syntaxhighlight lang="java">public class ExternalClass extends BaseClass{
  
 
   public static void printSecondText() {
 
   public static void printSecondText() {
Zeile 475: Zeile 475:
 
   }
 
   }
 
    
 
    
}</code=java>
+
}</syntaxhighlight>
  
 
|style="width:1em"|
 
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {
+
|style="width:30em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public static void main(String[] args) {
 
   public static void main(String[] args) {
Zeile 498: Zeile 498:
 
    
 
    
 
    
 
    
    </code=java>
+
    </syntaxhighlight>
 
|}
 
|}
  
Zeile 506: Zeile 506:
  
 
{|
 
{|
|style="width:30em"|<code=java>public class ExternalClass {
+
|style="width:30em"|<syntaxhighlight lang="java">public class ExternalClass {
  
 
   public static void myStaticMethod() {
 
   public static void myStaticMethod() {
Zeile 520: Zeile 520:
 
   }
 
   }
  
}</code=java>
+
}</syntaxhighlight>
 
|style="width:1em"|
 
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {
+
|style="width:30em"|<syntaxhighlight lang="java">public class MyProgram {
  
 
   public static void main(String[] args) {
 
   public static void main(String[] args) {
Zeile 536: Zeile 536:
 
    
 
    
 
    
 
    
    </code=java>
+
    </syntaxhighlight>
 
|}
 
|}
  
Zeile 544: Zeile 544:
 
{{Fragen stellen}}
 
{{Fragen stellen}}
  
[[Kategorie:Java]]
+
[[Kategorie:Tutorials (Java)]]
 
[[Kategorie:Java Grundlagen]]
 
[[Kategorie:Java Grundlagen]]

Aktuelle Version vom 7. April 2018, 17:25 Uhr

Der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen

Das kleine Wort static macht einen großen Unterschied.


Statische Methoden

Wer nicht-objektorientierte Sprachen wie C kennt, dem dürften statische Methoden vertraut sein. In nicht-objektorientierten Sprachen heißen Methoden "Funktionen". Und im Grunde genommen sind statische Methoden genau das: Funktionen wie in C.

Wenn man von einer anderen Klasse auf statische Methoden oder Variablen zugreifen möchte, dann ruft man sie zusammen mit dem Klassennamen auf:

public class ExternalClass {

  public static int number=5;
  private static String text="Anfangstext";

  public static void myStaticMethod() {
    System.out.println("statische Methode aufgerufen");
  }

  public static double add(double a, double b) {
    return a + b;
  }

  public static void printText() {
    System.out.println(text);
  }

  public static void changeText() {
    text = "geaenderter Text";
  }

}
public class MyProgram {

  public static void main(String[] args) {
    ExternalClass.myStaticMethod();
    System.out.println( ExternalClass.add(17.65, 9.23) );
    System.out.println( ExternalClass.number );
    ExternalClass.number = 13;
    System.out.println( ExternalClass.number );
    ExternalClass.printText();
    ExternalClass.changeText();
    ExternalClass.printText();
  }

}
       
       
       
       
       
       
       
       

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:

public class MyProgram {

  public static int number=5;
  private static String text="Anfangstext";

  public static void myStaticMethod() {
    System.out.println("statische Methode aufgerufen");
  }

  public static double add(double a, double b) {
    return a + b;
  }

  public static void printText() {
    System.out.println(text);
  }

  public static void changeText() {
    text = "geaenderter Text";
  }

  public static void main(String[] args) {
    MyProgram.myStaticMethod();
    System.out.println( MyProgram.add(17.65, 9.23) );
    System.out.println( MyProgram.number );
    MyProgram.number = 13;
    System.out.println( MyProgram.number );
    MyProgram.printText();
    MyProgram.changeText();
    MyProgram.printText();
  }

}

Der Einsatzzweck für statische Methoden ist somit ähnlich wie bei Funktionen von nicht-objektorientierten Sprachen. Statische Variablen sind ein zentraler Ort an dem etwas gespeichert wird.

Beispiele für die Verwendung von statische Methoden im JRE:

public class MyProgram {

  public static void main(String[] args) {
    System.out.println( Math.PI );       // PI ist eine statische Variable in der Klasse Math
    System.out.println( Math.E );        // E ist eine statische Variable in der Klasse Math
    System.out.println( Math.sin(2) );   // sin() ist eine statische Methode in der Klasse Math
    System.out.println( Math.log(7) );   // log() ist eine statische Methode in der Klasse Math
  }

}

PI ist halt überall immer 3.141..., sin(2) ist überall 0.909..., etc.


Nicht-Statische Methoden

Nicht-Statische Methoden und Variablen kommen vor allem in objektorientierten Sprachen vor. Um diese aufrufen zu können, muss mit new eine Instanz von der Klasse erstellt werden. Und an dieser kann man dann die Methoden aufrufen. Die Methoden gehören dann zur Instanz:

public class ExternalClass {

  public int number=5;
  private String text="Anfangstext";

  public ExternalClass() {
  }

  public void myNonStaticMethod() {
    System.out.println("nicht-statische Methode aufgerufen");
  }

  public double add(double a, double b) {
    return a + b;
  }

  public void printText() {
    System.out.println(text);
  }

  public void changeText() {
    text = "geaenderter Text";
  }

}
public class MyProgram {

  public static void main(String[] args) {
    ExternalClass ec1 = new ExternalClass();
    ec1.myNonStaticMethod();
    System.out.println( ec1.add(17.65, 9.23) );
    System.out.println( ec1.number );
    ec1.number = 13;
    System.out.println( ec1.number );
    ec1.printText();
    ec1.changeText();
    ec1.printText();

    ExternalClass ec2 = new ExternalClass();
    ec2.printText();
    ec1.printText();

    ec2.number = 29;
    System.out.println( ec1.number );
    System.out.println( ec2.number );
  }

}
       
       

Zwar existieren nun genau die gleichen Methoden und Variablen wie bei dem Beispiel mit den statischen Methoden, jedoch existieren sie für jede Instanz unabhängig voneinander.

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es ähnlich aus. In der eigenen Klasse wird jedoch statt einem Instanznamen das Schlüsselwort this verwendet:

public class MyProgram {

  public int number=5;
  private String text="Anfangstext";

  public MyProgram() {
    this.myNonStaticMethod();
    System.out.println( this.add(17.65, 9.23) );
    System.out.println( this.number );
    this.number = 13;
    System.out.println( this.number );
    this.printText();
    this.changeText();
    this.printText();
  }

  public void myNonStaticMethod() {
    System.out.println("nicht-statische Methode aufgerufen");
  }

  public double add(double a, double b) {
    return a + b;
  }

  public void printText() {
    System.out.println(text);
  }

  public void changeText() {
    text = "geaenderter Text";
  }

  public static void main(String[] args) {
    MyProgram p = new MyProgram();
  }

}

Für mehr Informationen zur vorgenommenen Umformung bitte auf Vererbung_(Java) nachlesen.

Beispiele für die Verwendung von nicht-statische Methoden im JRE:

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;


public class MyProgram {

  public static void main(String[] args) {
    JFrame f = new JFrame("MyProgram");
    JPanel p = new JPanel();
    JButton b1 = new JButton("Button 1");
    JButton b2 = new JButton("Button 2");
    JButton b3 = new JButton("Button 3");
    JLabel l1 = new JLabel("Label 1");
    JTextArea ta = new JTextArea();
    
    p.add(b1);
    p.add(b2);
    p.add(b3);
    p.add(l1);
    p.add(ta);
    
    ta.setPreferredSize(new Dimension(100,50));  // setPreferredSize ist eine nicht-statische
                                                 // Methode der Klasse JTextArea, von dem ta eine
                                                 // Instanz ist
    ta.setBorder(new LineBorder(Color.blue));
    ta.setText( b2.getText() );                  // Hier wird die Methode getText() von der
                                                 // Instanz b2 verwendet und ta mit setText()
                                                 // zugewiesen
    
    b1.setPreferredSize(new Dimension(180, 70)); // Die Groesse des Buttons von b1 wird mit
                                                 // der Methode setPreferredSize(), die in JButton
                                                 // definiert wurde, veraendert
    b3.setPreferredSize(new Dimension(160, 90)); // Andere Instanzen von Buttons bleiben davon
                                                 // unberührt und koennen ebenfalls mit der gleichen
                                                 // Methode eine andere Groesse erhaltem
    
    b1.setBackground(Color.red);                 // Auch hier wieder:
    b3.setBackground(Color.green);               // zwei verschiedene Buttons, die mit Hilfe der
                                                 // gleichen Methode setBackground() eine andere
                                                 // Hintergrundfarbe erhalten.
    
    f.add(p);
    f.pack();
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setVisible(true);
  }
  
}


Verwirrungen um static / non-static

So unterschiedlich statische und nicht-statische Methoden sind, so kommt es doch bei Anfängern zu Verwirrungen, da es manchmal so aussieht, als täten beide genau dasselbe:

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;


public class MyProgram {

  public static int myStaticVar=0;
  
  public int myNonStaticVar=0;
  
  public static void myStaticMethod() {
    myStaticVar *= 7;    // ist das gleiche wie
                         // myStaticVar = myStaticVar * 7;
  }
  
  public void myNonStaticMethod() {
    myNonStaticVar *= 13;  // ist das gleiche wie
                           // myNonStaticVar = myNonStaticVar * 13;
  }

  public MyProgram() {
    myStaticVar = 6;
    myNonStaticVar = 5;
    
    System.out.println(myStaticVar);
    System.out.println(myNonStaticVar);
    
    myStaticMethod();
    myNonStaticMethod();

    System.out.println(myStaticVar);
    System.out.println(myNonStaticVar);

    myStaticMethod();
    myNonStaticMethod();
    
    System.out.println(myStaticVar);
    System.out.println(myNonStaticVar);
  }

  public static void main(String[] args) {
    new MyProgram();  // aehnlich wie
                      // MyProgram mp = new MyProgram();
                      // bloß, dass in diesem Fall nur der Konstruktor aufgerufen
                      // wird. Jedoch nicht eine Instanz zur weiteren verwendung in
                      // main() erhalten bleibt.
  }
  
}

Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.

Das liegt aber daran, weil man bei statischen Methoden den Klassennamen der Einfachheit halber weglassen kann und bei nicht-statischen Methoden das this. Ausgeschrieben sieht das Programm folgendermaßen aus:

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;


public class MyProgram {

  public static int myStaticVar=0;
  
  public int myNonStaticVar=0;
  
  public static void myStaticMethod() {
    myStaticVar *= 7;
  }
  
  public void myNonStaticMethod() {
    myNonStaticVar *= 13;
  }

  public MyProgram() {
    MyProgram.myStaticVar = 6;
    this.myNonStaticVar = 5;
    
    System.out.println(MyProgram.myStaticVar);
    System.out.println(this.myNonStaticVar);
    
    MyProgram.myStaticMethod();
    this.myNonStaticMethod();

    System.out.println(MyProgram.myStaticVar);
    System.out.println(this.myNonStaticVar);

    MyProgram.myStaticMethod();
    this.myNonStaticMethod();
    
    System.out.println(MyProgram.myStaticVar);
    System.out.println(this.myNonStaticVar);
  }

  public static void main(String[] args) {
    new MyProgram();
  }
  
}

Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;


public class MyProgram {

  public static int myStaticVar=0;
  
  public int myNonStaticVar=0;
  
  public static void myStaticMethod() {
    myStaticVar *= 7;
  }
  
  public void myNonStaticMethod() {
    myNonStaticVar *= 13;
  }

  public MyProgram() {
  }

  public static void main(String[] args) {
    MyProgram mp1 = new MyProgram();
    MyProgram mp2 = new MyProgram();
 
    MyProgram.myStaticVar = 6;
    mp1.myNonStaticVar = 5;
    mp2.myNonStaticVar = 8;
    
    System.out.println( MyProgram.myStaticVar );
    System.out.println( mp1.myNonStaticVar );
    System.out.println( mp2.myNonStaticVar );
    
    MyProgram.myStaticMethod();
    mp1.myNonStaticMethod();
 
    System.out.println( MyProgram.myStaticVar );
    System.out.println( mp1.myNonStaticVar );
    System.out.println( mp2.myNonStaticVar );
    
    mp2.myNonStaticMethod();
    mp2.myNonStaticMethod();
    mp2.myNonStaticMethod();
    mp2.myNonStaticMethod();

    System.out.println( MyProgram.myStaticVar );
    System.out.println( mp1.myNonStaticVar );
    System.out.println( mp2.myNonStaticVar );
  }
  
}

Hier sieht man noch mal, dass statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.


Besonderheiten von statischen Methoden

Am Anfang haben wir statische Methoden als äquivalent zu Funktionen in C und anderen nicht-objektorientierten Sprachen kennengelernt. Um den Unterschied zwischen statischen und nicht-statischen Methoden zu verstehen, ist es auch für den Anfang ganz sinnvoll es so zu erklären. Aber in der objektorientierten Sprache Java, gibt es dann doch einige Zusätze, die es in C z.B. nicht gibt.

Statische Methoden lassen sich genauso wie nicht-statische Methoden ableiten:

public class BaseClass {

  public static void printFirstText() {
    System.out.println("Dieses ist ein Text in BaseClass");
  }
  
  public static void printSecondText() {
    System.out.println("Und noch ein Text in BaseClass");
  }
  
}
public class ExternalClass extends BaseClass{

  public static void printSecondText() {
    System.out.println("Ein Text in ExternalClass");
  }
  
}
public class MyProgram {

  public static void main(String[] args) {
     BaseClass.printFirstText();       // normaler Aufruf
     BaseClass.printSecondText();      // normaler Aufruf    
     ExternalClass.printFirstText();   // Methode ist von BaseClass abgeleitet
     ExternalClass.printSecondText();  // Methode, die die von BaseClass
                                       // ueberschrieben hat
  }
  
}
    
    
    
    
    
    
    
    
    
    


Es gibt etwas ähnliches wie einen Konstruktor für statische Methoden:

public class ExternalClass {

  public static void myStaticMethod() {
    System.out.println("die statische Methode wurde aufgerufen.");
  }
  
  public static void myOtherStaticMethod() {
    System.out.println("eine weitere Methode wurde aufgerufen.");
  }
  
  static {
    System.out.println("Es wurde zum erstem Mal statisch auf diese Klasse zugegriffen.");
  }

}
public class MyProgram {

  public static void main(String[] args) {
     System.out.println(
       "Noch ist kein Zugriff auf ExternalCLass erfolgt.");
     ExternalClass.myStaticMethod();
     ExternalClass.myOtherStaticMethod();
     ExternalClass.myStaticMethod();
  }
  
}
    
    
    
    

Diese Möglichkeit wird insbesondere eingesetzt, wenn man statischen Variablen direkt am Anfang bestimmte Werte zuweisen möchte. So kann es sein, daß der Anfangswert der Variablen erst berechnet werden muß. Oder es handelt sich um eine Liste, die sich nur mit Hilfe einer Schleife befüllen lässt.


Fragen

Das Thema wurde nicht ausreichend behandelt? Du hast Fragen dazu und brauchst weitere Informationen? Lass Dir von uns helfen!

Wir helfen dir gerne!


Dir hat dieser Artikel gefallen? Oder Du hast Fehler entdeckt und möchtest zur Berichtigung beitragen? Prima! Schreibe einen Kommentar!

Du musst angemeldet sein, um einen Kommentar abzugeben.