Static / non-static (Java): Unterschied zwischen den Versionen
(→Besonderheiten von statischen Methoden) |
K |
||
| Zeile 541: | Zeile 541: | ||
Diese Möglichkeit wird insbesondere eingesetzt, wenn man statischen Variablen direkt am Anfang bestimmte Werte zuweisen möchte. | 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. | 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== | ||
| + | Wir haben im Thema Einiges ungeklärt gelassen? Du brauchst weitere Informationen? Dann stelle deine Fragen dazu im [http://forum.byte-welt.net/ Byte-Welt-Forum]. | ||
[[Kategorie:Java]] | [[Kategorie:Java]] | ||
[[Kategorie:Java Grundlagen]] | [[Kategorie:Java Grundlagen]] | ||
Version vom 22. Dezember 2015, 15:25 Uhr
Inhaltsverzeichnis
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-objektorientiersten 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:
<code=java>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";
}
}</code=java> |
<code=java>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();
}
} </code=java> |
Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
<code=java>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();
}
} </code=java> |
Der Einsatzzweck für statische Methoden ist somit ähnlich wie bei Funktionen von nicht-objketorientierten Sprachen. Statische Variablen sind ein zentraler Ort an dem etwas gespeichert wird.
Beispiele für die Verwendung von statische Methoden im JRE:
<code=java>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
}
} </code=java> |
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, muß erst 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:
<code=java>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";
}
}</code=java> |
<code=java>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 ); } } </code=java> |
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:
<code=java>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();
}
} </code=java> |
Für mehr Informationen zur vorgenommenen Umformung bitte auf Vererbung_(Java) nachlesen.
Beispiele für die Verwendung von nicht-statische Methoden im JRE:
| <code=java>import javax.swing.*;
import javax.swing.border.*; import java.awt.*;
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);
}
}</code=java> |
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 das Selbe:
| <code=java>import javax.swing.*;
import javax.swing.border.*; import java.awt.*;
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.
}
}</code=java> 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:
|
