Einleitung
Java hat einen ziemlich "OOP-Lastigen" Programmier Styl. (Objekt Orientierte Programmierung). Das heißt das man Objekte so sehen soll wie man es in der Echten Welt täte.
In der OOP hat jedes Objekt seine eigene Identität. Ein Apfel ist Ein Objekt, so auch eine Tasse. Auch 2 Äpfel welche gleich aussehen, sind im eigentlichen 2 Seperate Äpfel mit deren eigenen Eigenschaften und Verhalten
Klassen beschreiben wie ein Objekt sein wird / was es haben wird.
In anderen Worten können Klassen wie BluePrints angesehen werden.
Man kann die selbe Klasse als BluePrint für unendlich Objekte benutzen.
Jede Klasse hat einen Namen, Variablen (Attribute) und Methoden (Verhalten). Hier ist ein Beispiels-Bild:
https://api.sololearn.com/DownloadFile?id=2429 |
Funktionen & Variablen
Methoden (Auch Funktionen/Verhalten gennant) sind Annsammlungen von Statements um eine Operation durchzuführen. Wie zB. auch die Methode println(x)
in System.out
.
Funktionen die ein static
-Keyword besitzen können auch nur mit Hilfe der Klasse (BluePrints) aufgerufen werden, aber dann haben diese Methoden auch nur die static
-Variablen/Funktionen der Klasse zu Verfügung.
class MyClass {
public int var = 2;
void hallo(){ System.out.println("Hallo"); }
int addieren(int x1, int x2){ return x1 + x2; }
static void test(){
this.var= 2;// >Fehler: Die Variable "var" kann nur eine erstellte Instanz besitzen.
}
}
Variablen
Eine Klasse kann "2 Typen von Variablen" haben:
- Variable mit static
-Keyword, welche für das gesamte BluePrint gilt
- Normale Variable, welche für jedes Objekt anders ist.
Im oberen Fall ist die Variable var
eine Objekt-Variable. |
Siehe Konstruktor um zu sehen wie man ein neues Objekt erstellt.
Siehe Getter & Setter für extrigen "Variablen-Schutz".
Zugriff Modifizierer
public |
Für Jeden Zugreifbar |
private |
Nur für die Klasse |
protected |
Nur für die Klasse und Sub-Klassen |
static |
Keyword, damit man eine Methode/Variable auch nur durch die Klasse/das BluePrint bekommen kann |
final |
Keyword, dass eine Variable nicht veränderbar ist |
|
|
Konstruktor
Eine Klasse kann außer Funktionen und Methoden noch mehrere Konstruktöre haben.
Ein Konstruktor ist aufgebaut wie eine Methode, aber nur ist er dafür ein neues Objekt seines Klassen-BluePrints zu erstellen.
Ein Konstruktor sieht wie folgt aus: (Syntax)
public KlassenName(...){ Code }
Ein Beispiel für die Klasse MyClass, welche eine Variable var
hat. (aus "Getters und Setters"):
public MyClass(int wert) { // Beim erstellen dieser Klasse muss ein Wert übergeben werden
this.var = wert; // Setzt die Klassen-Variable "val" auf den mitgelieferten Wert
}
Und nun kann man mit:
MyClass instanz1 = new MyClass(224);
Eine neue Instanz/Objekt der Klasse MyClass
erstellen. |
Getter & Setter
Getter & Setter ist ein Konzept in der Programmierung, wo dafür gedacht ist dass man das Setzen einer Variable überprüfen kann, um Fehler zu vermeiden.
Dies macht man, indem man die eigentliche Variable auf private
setzt, und eine Methode zum "Setzten" sowie eine zum "Kriegen" erstellt.
Ein klassisches Beispiel wäre es, dass man einen int
macht, der nur im Positiven bereich gesetzt werden darf:
class MyClass {
private int var = 2;
void setVar(int wert){
if(wert < 0) { wert = 0; } // Angegebenen Wert vor dem setzten überprüfen und ändern
this.var = wert;
}
int getVar(){ return this.var; }
}
Hiermit kann ich mir ziemlich sicher sein, dass mir .getVar()
immer eine positive Zahl gibt.
In jedem Java Programm wird diese Programmierweise bevorzugt, was auch gut ist und man sich auch angewöhnen sollte. |
Kurz gesagt sind Getter und Setter eine "Idioten-Schutz", damit Variablen keinen nicht vorhergesehen Wert erhalten!
Wert VS Referenz
Wenn man einer Methode einen Primitiven-Datentypen übergibt, kann man sich sicher sein dass er nicht verändert wird.
Übergibt man jedoch eine Klasse, können die Variablen des Objektes verändert werden.
Bsp:
void doSomething(int num) { num = 22; }
int num = 5
;
doSomething(num);
System.out.println(num); // Immernoch 5 hier
Aber mit einer Klasse:
class MyClass { int num = 4; }
void doSomething(MyClass obj) { obj.num = 22; }
MyClass obj = new MyClass();
doSomething(obj);
System.out.println(obj.num); // 22
|
|
|
Vererbung
Vererben einer Klasse/Interfaces heißt, dass die Klasse alle Methoden/Variablen hat, von welchem sie erbt.
Dies sieht dann so aus:
Mutter-Klasse:
class A {
public int variable = 2;
public void test(){ System.out.println("Hallo A") }
}
Klasse welche von A erbt:
class B extends A {
@Override // Methode von A überschreiben
public void test(){ System.out.println("Hallo B"); }
}
Code Beispiel
A obj = new A();
obj.test(); // GIbt "Hallo A" aus
obj = new B(); // Wir können die Variable "obj" auf ein Objekt vom Typ "B" setzten, weil B von A erbt
obj.test(); // Gibt "Hallo B" aus
obj.variable = 4; // Und weil "obj" immernoch vom Typ "A" ist, hat es auch immer noch seine Variablen
Zudem kann die Klasse, welche erbt, die Methoden auf ein anderes Verhalten umschreiben. (Den Code der Methode umschreiben) |
|
