Bild Referenz: 
Intro
Hallo, ich bin's @drifter2! Der heutige Artikel ist an meinem englischen Artikel "Java Classes and Methods" basiert, dem wir heute zu Deutsch übersetzen werden und zusätzlich auch "optimieren" werden. Wir werden also heute über die so genannten Klassen reden mit denen wir Objekte darstellen. Dabei werden wir auch über die wichtigsten Methoden/Funktionen reden, etwas das natürlich auch enthält wie man Methoden generell definieren kann. Also, fangen wir dann mal direkt an!Klassen-Aufbau
Jede Klasse(Class auf Englisch) in Java ist meistens eine separate .java Datei, aber das muss nicht unbedingt der Fall sein, da wir auch Innere (Inner) und Äußere (Outer) Klassen definieren können. Eine solche Klasse besteht aus Variablen und Funktionen, die wir in OOP meistens Daten oder Attributen und Methoden nennen (auf Englisch attributes und methods). Die Sichtbarkeit der ganzen Klasse und von den Daten und Methoden die diese Klasse enthält, kann mit folgenden Zugriffsrechten geregelt werden:- public (Global)): Zugriff von überall
- private (Privat): Zugriff nur in der Klasse
- protected (Geschützt): Zugriff nur in der Klasse und den Unterklassen die diese enthält, und zusätlich in der "package" wo die Klasse drinne ist
- default (Voreinstellung): Zugriff nur in der Klasse und der "package" wo die Klasse drinne ist
Von all dem könnt ihr bestimmt bereits verstehen, das der Grundaufbau einer Klasse wie folgend aussieht:
public class KlassenName{
// DATEN: Variablen
// METHODEN: Funktionen
// Innere Klassen
}
Dieser Code muss in einer Java-Datei mit dem Namen "Klassen_Name.java" abgespeichert werden. Zusätzlich sollte ihr auch folgendes beachten:
- Alle DATEN sollten privat sein, aber manchmal definieren wir auch globale um das programmieren zu verleichtern.
- Die METHODEN sind meistens global, außer es handelt sich um Methoden die von anderen Methoden der Klasse ausgeführt werden und nicht nützlich sind vom Objekt, wenn dieses in einer anderen Klasse verwendet wird.
Es gibt zwei grundsätzliche Typen von Klassen:
- Main oder Treiber Klasse (vom englischen Driver), die die main-Funktion enthält und die anderen zum erstellen von Objekten verwendet.
- Objekt Klassen, welche von der Treiber Klasse zu Objekten "verwandelt" werden.
Main oder "Treiber" Klasse
Diese Klasse enthält die main-Funktion vom ganzen Java-Programm und wird als erstes ausgeführt. Sie benutzt die anderen Klassen um mit denen Objekte zu erstellen. Dabei können wir:- auf den Wert einer Variable eines gewissen Objekts zugreifen und diesen z.B. ändern
- Funktionen eines Objektes ausführen
- mehrere Objekte vergleichen usw.
public class KlassenName{
//DATEN: Variablen und Objekte von Objekt-Klassen
//METHODEN: die main-Methode (die nur hier existiert) und andere
//meistens verwenden wir nur Methoden der Objekte
public static void main(String[] args){ // Main Methode
}
// Innere Klassen: diese könnten z.B. die verwendeten Objekt-Klassen sein
}
Der Klassen Name für die Treiber-Klasse ist meistens "Driver". Und das ist auch was ihr gerade benötigt. Gehen wir also jetzt in Objekt Klassen ein!
Objekt Klassen und Konstruktoren
Objekt Klassen werden als Objekte in der Treiber-Klasse verwendet. Das heißt das diese folgendes enthalten müssen:- Informationen, Attribute oder Eigenschaften (Variablen) die ein Objekt beschreiben
- Methoden die uns bei der Verwendung dieser Informationen helfen
Ein Konstruktor wird wie folgend geschrieben:
// Standard Konstruktor
public KlassenName(){
}
// Selbst-geschriebener Konstruktor
public KlassenName(//Parameter){
// Eigener Code der z.B. Variablen initialisieren kann
}
// wir können unendlich viele haben!
Getters und Setters
Wie vorhin bereits erwähnt wurde sind die Daten meistens Privat. Das heißt aber nicht das andere Klassen keinen Zugriff auf diese Variablen mit einer anderen Sicheren und Kontrollierbaren Weise haben! Wenn eine gewisse Information Privat ist definieren wir so genannte Getter und Setter Methoden für diese Variable, so dass diese "normal" verwendet werden kann. Der Getter (vom englischen Wort "get", welches "erhalten" bedeutet) ist eineMethode mit dem selben Datentyp wie die Variable, ohne Parameter, welche den Wert der Variable zurückgibt. Der Setter (vom englischen Wort "set", welches "setzen" bedeutet) ist eine Methode welche vom Datentyp void ist und einen Parameter hat, welcher den Wert den wir zu der Variable geben wollen enthält. Dabei kontrollieren wir ob der Wert "richtig" ist. Sagen wir mal wir reden über eine Kontonummer. Diese darf natürlich keinen negativen Wert haben. Das können wir sehr leicht beim Setter von der Kontonummer kontrollieren!Diese Methoden, für eine Variable vom Typen "variable_type" mit Namen 'v', sehen wie folgend aus:
//Getter
public variable_type getVariable(){
return v;
}
//Setter
public void setVariable(variable_type v){
// Die Variable dieser Klasse (this.v) nimmt den Wert vom Parameter 'v'
this.v = v;
}
toString() Methode
Die Zeichenketten (String) Darstellung eines Objekts/einer Klasse kann sehr leicht mit der Methode "toString()" genommen werden. Dies ist eine enthaltene Methode, die wir überschreiben (override auf Englisch), so dass wir am Ende das bekommen das wir wollen. Dabei verketten wir meistens die Werte von allen Variablen/Daten in der Objekt-Klasse, so dass diese ein gewisses Format haben.Sagen wir mal wir haben eine Objekt-Klasse welche eine Zeichenkette mit Namen "name" und eine Ganzzahl mit Namen "alter" enthält. Das heißt das wir eine Person darstellen mit Namen und Alter. Die toString() Methode könnte wie folgend aussehen:
@Override // zum überschreiben
public String toString() {
// Wir wollen folgendes ausdrucken:
// "Name: nameWert, Alter: alterWert"
// In Code ist das:
return "Name: " + name + ", Alter: " + alter;
}
Ähnlich kann man auch die Methode "equals()" überschreiben, welche zum vergleichen von Klassen verwendet wird. Die Methode "equals()" gibt einen Boolean-Wert zurück.
Methoden
Die Erstellung "eigener" Methoden ist sehr ähnlich und abhängig vom Klassen-Typ. Bei Objekt-Klassen erstellen wir Globale (public) Methoden, genau wie wir auch die Getter und Setter definiert haben. Das sieht wie folgend aus:
public Rückgabetyp MethodenName(//Parameter){
//Code
return v; // Wenn "void" braucht man das nicht
}
Bei der Treiber-Klasse muss man die Methoden als "public static" definieren, da hier ja kein Objekt erstellt wurde. Bei Objekt-Klassen wird ja ein gewisser Speicher zugewiesen, da wir die Methoden mit Hilfe des Objekts ausführen, welches "erstellt" wurde. Eine Methode sieht also dann wie folgend aus:
public static Rückgabetyp MethodenName(//Parameter){
//Code
return v; // Wenn "void" braucht man das nicht
}
Der eigentliche Unterschied ist also das wir das Stichwort "static" verwenden müssen!
Komplettes Beispielprogramm
Sagen wir mal wir wollen ein Programm erstellen welches Studenten-Objekte erstellt und dessen Werte ausdruckt. Das heißt das wir zwei Klassen brauchen: Die Treiber-Klasse und eine Objekte-Klasse für den Studenten. Wir werden 2 Studenten-Objekte erstellen und ausdrucken. Beim ersten werden die Daten mit Hilfe von den Getter und Setter Methoden initialisiert. Beim zweiten werden wir das selbe mit Hilfe eines überladenen (overloaded auf Englisch) Konstruktors machen, der die Werte der Variablen als Parameter nimmt. Der zweite wird zusätzlich mit Hilfe der toString() Methode bei der Konsole ausgedruckt. Ein Student wird eine ID, einen Namen und einen Nachnamen haben, welche vom Typ Integer, String und String sein werden. Diese Werte werden keine Eingabe vom Benutzer sein.Treiber-Klasse (Driver):
public class Driver { // Driver.java
public static void main(String[] args) {
// 2 Studenten/Objekte
Student s1;
Student s2;
// Standard Konstruktor verwenden
s1 = new Student();
// Werte mit Setters setzen
s1.setID(100);
s1.setName("Tom");
s1.setNachname("Williams");
// Ausdrucken mit Hilfe von Getters
System.out.println(s1.getID() + " " + s1.getName() + " " + s1.getNachname());
// Überladenen Konstruktor verwenden
s2 = new Student(101, "John", "Smith");
System.out.println(s2);
}
}
Studenten Klasse (Student):
public class Student { // Student.java
// DATEN
private int ID;
private String name;
private String nachname;
// METHODEN
// Konstruktoren
// Standard Konstruktor
public Student() {
ID = 0;
name = surname = null;
// wir könnten hier auch die Setter verwenden
}
// Überladener Konstruktor
public Student(int ID, String name, String nachname) {
this.ID = ID;
this.name = name;
this.nachname = nachname;
// wir könnten hier auch die Setter verwenden
}
// Getters-Setters
// ID
public int getID() {
return ID;
}
public void setID(int ID) {
this.ID = ID;
}
// Name
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// Nachname
public String getNachname() {
return nachname;
}
public void setNachname(String nachname) {
this.nachname = nachname;
}
// Andere Methoden
@Override
public String toString() {
return ID + " " + name + " " + nachname;
}
}Beim Ausführen wird natürlich folgendes ausgedruckt:
100 Tom Williams
101 John Smith
Referenzen:
- http://www.willemer.de/informatik/java/javaclas.htm
- http://www.programmierenlernenhq.de/klassen-in-java/
- http://www.programmierenlernenhq.de/methoden-in-java-was-sind-methoden-und-wie-werden-sie-verwendet/
- http://www.codeadventurer.de/?p=233
- https://steemit.com/programming/@drifter1/programming-java-classes-and-methods
Vorherige Artikel
- Von C nach Java -> Ähnlichkeiten mit C, OOP, Ein- und Ausgabe über die Konsole, Array-Feld Objekt, C-like Beispielprogramm
Schlusswort
Und das war's dann auch mit dem heutigen Artikel und ich hoffe euch hat dieser Artikel gefallen! Beim nächsten Artikel werden wir über die so genannte Komposition von Objektes reden. Zusätzlich werden wir auch mehr in Arrays-Felder eingehen, etwas das uns in ArrayList Objekte bringen wird, mit denen wir "dynamische" Felder erstellen können.
Keep on drifting! ;)