Programmieren in Java - Klassen und Methoden

Bild Referenz: https://commons.wikimedia.org/wiki/File:CPT-OOP-objects_and_classes_-_attmeth.svg

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

    Diese Zugriffsrechte kommen als Wörter vor dem Namen einer Klasse, Variable oder Funktion, bei der Deklarierung dieser. Genau wie wir auch den Datentyp deklarieren.

    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:

1. Main oder Treiber Klasse (vom englischen Driver), die die main-Funktion enthält und die anderen zum erstellen von Objekten verwendet.
2. Objekt Klassen, welche von der Treiber Klasse zu Objekten "verwandelt" werden.

Fangen wir dann mal mit dem ersten Typen an!

---

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.

Der Aufbau einer solchen Klasse ist also:

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

    Eine Objekt-Klasse hat natürlich keine Main-Methode und wird erst verwendet, oder besser gesagt erstellt, mit Hilfe vom "new" Modifizierer, den wir auch letztes mal bei Feldern gesehen haben. Aber was genau passiert wenn wir "new" verwenden? Mit Hilfe von "new" wird die Klasse ein Objekt, indem ein so genannter Konstruktor (constructor auf Englisch) ausgeführt wird. Diesen Konstruktor können wir selbst erstellen, aber es ist auch immer ein Standard oder "default" Konstruktor bereits definiert. Erstellen wir einen selber, wird dann dieser bereits enthaltene Konstruktor überschrieben (override auf Englisch). Der Standard Konstruktor hat keine Parameter und erstellt ein "Leeres" Objekt. Eine Konstruktor ist eine Methode die "public" ist und keinen Rückgabe-Wert (nicht mal void!) hat, so das diese von überall erreichbar ist und nichts zurückgibt.

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:

1. http://www.willemer.de/informatik/java/javaclas.htm
2. http://www.programmierenlernenhq.de/klassen-in-java/
3. http://www.programmierenlernenhq.de/methoden-in-java-was-sind-methoden-und-wie-werden-sie-verwendet/
4. http://www.codeadventurer.de/?p=233
5. https://steemit.com/programming/@drifter1/programming-java-classes-and-methods

    Der Artikel ist zu 90% eine Übersetzung von meinen englischen Artikel, aber enthält ein paar zusätzliche Informationen. Die Referenzen haben dabei geholfen die richtigen deutschen Begriffe zu finden und zu verwenden, da ich Programmieren nicht in Deutsch, sondern in Englisch gelernt habe.

---

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! ;)