Java Grundlagen

1. Erstes Beispiel: Klasse 'EuroMuenze'

public class EuroMuenze {
    private int wert;
    // Erweiterungsmöglichkeiten mit Cents, beliebige Währung, etc. !!

    public EuroMuenze(int wert) {
        this.wert = wert;
    }
    public int getWert() {
        return this.wert;
    }
    public void printInfo() {
        System.out.println(this.wert + "-Euro-Münze");
    }
}

2. Allgemeine Infos

  • public/private:: definiert die Nutzbarkeit/Sichtbarkeit - private nur innerhalb der eigenen Klasse, public auch von außerhalb

  • Java kennt ca. 50 "Schlüsselworte", die z.B. nicht als Variablennamen benützbar sind und dem Compiler helfen, auch nach Fehlern mit der Prüfung fortzufahren.
    Beispiele: class, private, public, boolean, char, int

  • In Java werden Groß- und Kleinbuchstaben unterschieden.

  • für "Indentifier" (Klassen, Variable (Attribute und lokale), Methoden, Konstante, …​) gilt folgende Benennungsregel: erstes Zeichen muss Buchstabe oder '_' sein, danach sind auch Ziffern erlaubt (KEINE '-', Leerzeichen oder irgend etwas anderes!).

  • Klassennamen beginnen IMMER mit einem Großbuchstaben, Rest siehe oben (Identifier)

  • Konstante (die wir später lernen) werden ausschließlich in Großbuchstaben + Ziffern + Unterstrich '_' geschrieben – z.B. Math.PI oder Integer.MAX_VALUE (vor dem Punkt steht die Klasse, in der die Konstante definiert wird)

  • Alles andere (Methoden, Instanzvariable/Attribute, lokale Variable) hat KLEINE Anfangsbuchstaben, danach siehe oben (Identifier)

  • Konstruktoren werden im Finale der Objekterzeugung ausgeführt, bereiten das neue Objekt für die Nutzung vor, heißen exakt wie die Klasse und haben keinen Rückgabetyp - nicht einmal void!

  • es kann mehrere Konstruktoren geben, sie müssen sich aber in der Liste der Parametertypen unterscheiden (Parameter-Namen sind dabei irrelevant!).

  • Wenn kein einziger Konstruktor im Source-Code definiert ist, erstellt der Compiler automatisch einen leeren Standardkonstruktor (das ist derjenige OHNE Parameter)

  • Kommentare gibt es in 2 Formen:

    • Einzeilen-Kommentare beginnen mit // und reichen bis zum Zeilenende (wenn nicht in String-Literalen! – "Hallo // du" beginnt keinen Kommentar). Beispiele siehe unten.Testxxx ii mm

    • ein Block-Kommentar ist eingeschlossen in der Form /* der Block-Kommentar */, wobei er auch über mehrere Zeilen reichen kann (siehe Beispiel im Code unten). Kann überall dort eingefügt werden, wo auch ein Leerzeichen erlaubt ist!

      • Wird oft zum Auskommentieren eines Code-Stücks verwendet.
        Wenn darin schon ein Block-Kommentar vorkommt, gibt es ein Problem:
        Block-Kommentare können NICHT verschachtelt werden – ein weiteres /* wird einfach als Teil des Kommentars betrachtet, aber das erste */ wird als echtes Kommentar-Ende betrachtet. Das eigentlich gemeinte Ende liefert einen Syntax-Fehler!
        Beispiel für das Problem: /* das ist ein /*toller*/ Kommentar */ geht nicht. Man kann den inneren Kommentar "entschärfen", indem man z.B. einen Punkt im Kommentar-Abschluss einfügt: /* das ist ein /*toller *./ Kommentar */.

      • Die recht üblichen '*'-Zeichen an Beginn jeder Fortsetzungszeile (auch Beispiel unten) werden nur wegen der Ästhetik geschrieben, haben keine Bedeutung!

3. Kommentiertes Code-Beispiel Klasse 'Person'

Hier ein etwas ausführlicheres Beispiel mit vielen Kommentaren - bitte diese lesen!

Es werden Konstruktoren, Setter, Getter und Konsolen-Ausgabe (eigenes Textaugabe-Fenster) gezeigt.

public class Person {
    //// Eigenschaften (= Attribute, Properties, Instanzvariable), Zugriff nur innerhalb Klasse
    private String vorname = "-- LEER --";    // es kann gleich Anfangswert gesetzt werden
    private String nachname;        // String ... Text-Inhalt (GROSSER Anfangsbuchstabe!)
    private int gebJahr;            // int ... Ganzahl (ca. -2 bis +2 Milliarden Wertebereich)
    private boolean brille;         // boolean ... Wahrheitswert (nur true oder false möglich)
    private char geschlecht;        // char ... Einzelzeichen, z.B. geschlecht = 'f';

    //////// Konstruktoren ////////
    // heissen exakt gleich wie Klasse, haben KEINEN Rückgabetyp (auch nicht void)
    public Person() {  // Konstruktor ohne Parameter
        setVorname("-- leer --");     // wird später augeführt, "gewinnt" daher
        this.nachname = "-- leer --";  // detto (besser Setter verwenden!)

    }

    // Konstruktor mit allen sinnvollen Parametern:
    public Person(String vorname, String nachname, int gebJahr, boolean brille, char geschlecht) {
        this.vorname = vorname;  // this. erzwingt Zugriff auf Objekt-Eigenschaft statt Param
        setNachname(nachname);   // <-- besser, Setter kann Wert-Prüfung enthalten
        // ... analog f. die restlichen Parameter!
        setGebJahr(gebJahr);
        setBrille(brille);
        setGeschlecht(geschlecht);
    }

    //////// Setters ////////
    // Setter haben einen Parameter (gelicher Typ wie Eigenschaft) und Rückgabetyp void
    public void setVorname(String vorname) { // Setter ... Zeilen-Kommentar
        this.vorname = vorname;  // <-- Zuweisung (assignment) IMMER von RECHTS nach LINKS
    }

    public void setNachname(String nachname) {
        this.nachname = nachname;   // als Parameter-Variable meist selbe Bezeichnung gewaehlt
    }

    public void setGebJahr(int gebJahr) {
        this.gebJahr = gebJahr;
    }

    public void setBrille(boolean brille) {
        this.brille = brille;
    }

    /* Block-Kommentar (kann mehrere Zeilen enthalten - überall, wo Leerzeichen erlaubt)
     * m ... männlich, f ... weiblich (feminin/female), s ... sonstig
     * Beschränkung auf diese Werte kann später erzwungen werden
     */
    public /* Block-Kommentar */ void setGeschlecht(char geschlecht) {
        this.geschlecht = geschlecht;
    }

    //////// Getters (alle anderen analog) ////////
    public String getVorname() {  // Getter
        return this.vorname;
    }

    //////// Konsolen-Ausgabe ////////
    // System.out.println("genau ein Text als Parameter")
    // Text kann mit '+' "zusammengeklebt" werden (Schritt für Schritt von links beginnend)
    // sobald links/rechts vom '+' Text, werden auch andere Datentypen in Text umgewandelt!
    // Variable werden durch ihren gerade enthaltenen Wert ersetzt (wie in Mathe)
    // Text-Literale sind in "" engeschlossen, Einzelzeichen in '', Zahlen stehen für sich,
    // true oder false kann direkt geschrieben werden,
    // alles andere gilt als Variable oder Methode (wenn Klammern dahinter)
    // Attribut-Werte können per Getter: 'getVorname()' oder direkt: 'this.nachname',
    // bei Eindeutigkeit auch ohne 'this.' - 'gebJahr' alleine - aufgerufen werden
    public void printInfo() {
        System.out.println("===== Person =====");
        System.out.println("  Vor" + "name: " + getVorname() + ", Nachname: " + this.nachname);
        System.out.print("  GebJahr: " + this.gebJahr);  // keine Zeilenschaltung am Ende!
        System.out.print(", Brille: " + this.brille);    // detto
        System.out.println(", Geschlecht: " + this.geschlecht);
        // restliche Eigenschaften selbst ergänzen!
        System.out.println("*~*~*~*~*~*~*~*~*~");   // "Zierleiste"
        System.out.println();   // zusätzliche Zeilenschaltung (ergibt Leerzeile)
    }
}

Ausgabe von printInfo() für: vorname = "Evi"; nachname = "Eder"; gebJahr = 2006; brille = true; geschlecht = 'f'; …​

===== Person =====
  Vorname: Evi, Nachname: Eder
  GebJahr: 2006, Brille: true, Geschlecht: f
*~*~*~*~*~*~*~*~*~