Okay, wenn du mit C halbwegs vertraut bist, dann versuche ich es mal so:
Wenn du in Java folgende Klasse hast:
Code:
public class Foo {
int counter = 0;
static int staticCounter = 0;
}
Dann wird direkt Speicher für "staticCounter" belegt. Weil diese Variable global (unabhängig von Objekten (= Instanzen der Klasse)) zur Verfügung steht. "counter" belegt erstmal keinen Speicher, weil "counter" Teil einer Instanz der Klasse wäre, aber wir haben ja noch keine Instanz davon erzeugt.
Wenn du nun irgendwo:
aufrufst, dann erzeugst du eine Instanz der Klasse (also ein Objekt) und nun wird Speicher für "counter" belegt. Aber es wird
kein neuer Speicher für "staticCounter" belegt, weil diese Variable Teil der Klasse an sich ist. Und eine Klasse kann (im Normalfall) nur ein einziges mal existieren. Aber du kannst von einer Klasse beliebig viele Objekte (= Instanzen) erzeugen (am "new" Operator erkennbar).
Nehmen wir nun folgendes Beispiel:
Code:
public class Counter {
int value = 0;
public static int instancesCounter = 0;
Counter() {
instancesCounter++;
}
increment() {
value++;
}
}
Und irgendwo wird diese Klasse benutzt:
Code:
public static void main(String[] args) {
// instancesCounter = 0
Counter.instancesCounter++; // instancesCounter = 1
Counter c1 = new Counter(); // instancesCounter = 2
c1.increment(); // value von c1 = 1
Counter c2 = new Counter(); // instancesCounter = 3
c2.increment(); // value von c2 = 1
c1.increment(); // value von c1 = 2
Counter.instancesCounter++; // instancesCounter = 4
}
Dort siehst du nun, dass die statische Variable "instancesCounter" komplett unabhängig von den Objekten ist.
Im Vergleich zu C kann man das so (vereinfacht) veranschaulichen:
- Alles was "static" ist, existiert global nur ein einziges mal
- Ein Objekt (= Instanz einer Klasse) ist quasi ein "struct", aber zusätzlich kann man halt noch Methoden definieren, die mit den Daten dieses structs arbeiten.
In einem C struct könnte man die "increment" Methode so nicht schreiben, weil ein struct
nur Daten enthält. Also würde man in C quasi eine statische Methode nehmen, die das struct übergeben bekommt. Das ist in Java natürlich auch möglich. Aber man macht sowas nicht, weil man dann ja wieder nicht-objektorientierten Code schreiben würde:
Code:
public class Counter {
int value = 0;
static void increment(Counter counterObjekt) {
counterObjekt.value++;
}
}
In C hätte man also ein Counter struct, das einen int value enthält. Und irgendwo würde man die increment Funktion definieren, die ein Counter struct übergeben bekommt und dann den value Wert davon modifiziert.
In den allermeisten Fällen braucht man keine "static" Variablen und/oder Funktionen in Java. Weil man eben mit Objekten arbeitet und auch direkt die Methoden der Objekte benutzt.
In meinen Projekten erstelle ich deshalb meist auch einfach eine "Application" Klasse, die ausschließlich die "main" Methode enthält. Das ist dann im Normalfall die einzige nicht-objektorientierte Klasse im Projekt. Und die ist ausschließlich zum Starten des Programms da:
Code:
public class Application {
public static void main(String[] args) {
Geometry geo = new Geometry();
geo.run();
}
}
public class Geometry {
// ...
public void run() {
// ...
}
}
Ist eine Frage des Geschmacks und der Übersichtlichkeit. Für Mini-Projekte lohnt sich das natürlich meist nicht.
Wo man seine "main" Methode platziert ist Java ziemlich egal. Aber irgendwo muss sie halt stehen. Und wenn das Projekt eh nur aus 1-2 Klassen besteht, dann kann man die main Methode natürlich auch direkt da rein schreiben.
---
Die Objektorientierte Version hat halt den Vorteil der "Kapselung". Das fällt aber erst so richtig auf, wenn auch wirklich mit den Werten in der Klasse arbeitet und das "private" Keyword benutzt. Z.B. kannst du dadurch verhindern, dass ein Objekt negative Werte speichert:
Code:
public class KeineNegativeZahl {
// Objekt-interne Variable
// von außen weiß keiner, dass diese Variable existiert
private int value = 0;
public int getValue() {
// diese Methode ist öffentlich und gibt immer
// das Quadrat von "value" zurück
return value*value;
}
public void setValue(int newValue) {
// diese Methode ist öffentlich und setzt den internen
// Wert nur, wenn der neue Wert >= 0 ist. Wenn der
// neue Wert < 0 ist, dann passiert gar nichts.
if(newValue >= 0) {
value = newValue;
}
}
}
public static void main(String[] args) {
KeineNegativeZahl knz = new KeineNegativeZahl();
// knz.value; Zugriff nicht möglich
knz.getValue(); // Ergebnis = 0, weil 0*0 = 0
knz.setValue(2); // internet wert = 2, weil 2 >= 0
knz.getValue(); // Ergebnis = 4, weil 2*2 = 4
knz.setValue(-1); // internet wert bleibt 2, weil -1 nicht >= 0
knz.getValue(); // Ergebnis = 4, weil sich der interne Wert nicht geändert hat
}
Von außen kann niemand einsehen, was in den Objekten gespeichert ist. Der direkte Zugriff auf "value" ist durch das "private" Keyword untersagt. Die erzeugten Objekte können nur über die beiden "public" Methoden benutzt werden. Dadurch kann man dann sicherstellen, dass sich die Werte innerhalb der Objekte immer in einem konsistenten Zustand befinden. Mit einem C struct wäre das nicht möglich. Bei einem C struct kann jeder alles modifizieren wie er will und es gibt keine Garantie, dass die Werte innerhalb des structs nach der Modifikation noch Sinn ergeben.
Außerdem ist in der objektorientierten Welt sichergestellt, dass man die Funktionsweise eines Objekts komplett austauschen kann. Z.B. könnte ich "int value" durch einen String ersetzen und wenn jemand "setValue(4)" aufruft, speichere ich ein String mit 4 Leerzeichen und benutze die String-Länge als internen Wert. Von außen verhalten sich die Methoden nach wie vor identisch. Das ist der ganze Trick hinter der Kapselung: Man erschafft eine Blackbox, die man von außen über die Methoden bedienen kann. Ob die Blackbox im inneren nun die Daten direkt im Arbeitsspeicher ablegt, oder sie irgendwo im Internet speichert und der NSA bescheid gibt, weiß man nicht. Aber das will man auch gar nicht wissen. Hauptsache die Methoden liefern genau die Werte zurück, die man erwartet.
