Static / non-static (Java)

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! Besuche uns im Byte-Welt-Forum Besuche unseren Chat 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.