Objektorientierte Programmierung OOP

Die java.lang API muss nicht explizit aufgerufen werden. Sie wird immer automatisch importiert. 

• Object,

• String und StringBuilder,

• System,

• Class,

• Hüllklassen für primitive Datentypen,

• Throwable und diverse weitere Ausnahmeklassen sowie

• Math.

Objekte der Klasse Class repräsentieren zur Laufzeit jeweils eine existierende Klasse oder Schnittstelle. Sie speichern Informationen wie den Namen und die Oberklasse sowie die deklarierten Methoden, Attribute und Konstruktoren. Für jedes Objekt kann mit Hilfe der Methode getClass() das zugehörige Class-Objekt erfragt werden.

Für solche Zwecke gibt es sogenannte Hüllklassen (engl. wrapper class). Diese Klassen heißen Byte, Short, Integer, Long, Float, Double, Character und Boolean. Seit Version 5 können primitive Werte automatisch in entsprechende Hüllobjekte umgewandelt werden (engl. auto boxing)auto boxingauto boxing und umgekehrt ebenso:

    int zahl = 1;    Integer zahlObjekt = zahl;    int summe = zahl + zahlObjekt;

Die Hüllklassen bieten weiterhin einige nützliche Methoden. Mit Hilfe der statischen Methode parseInt() der Klasse Integer kann beispielsweise ein entsprechender Wert aus einer Zeichenkette gewonnen werden.

Das Paket java.util stellt verschiedenste Klassen und Schnittstellen zur Verfügung. Diese reichen von Klassen zur Repräsentation von Daten (Date und Calendar) und Währungen (Currency) bis zu einer Vielzahl von Datenstrukturen, wie wir sie in der letzten Kurseinheit kennen gelernt haben.

Das Paket java.io enthält Klassen, die das Schreiben und Lesen von Daten über unterschiedliche Ein- und Ausgabegeräte und Dateien unterstützen.

Die primitiven Datentypen weisen alle nur einen begrenzten Wertebereich auf. Um mit beliebig großen Zahlen arbeiten zu können, stellt das Paket java.math die Klasse BigInteger und BigDecimal zur Verfügung.

public void printLeapYears(int fromYear, int toYear) {

        GregorianCalendar calendar = new GregorianCalendar();        for (int year = fromYear; year <= toYear; year++) {            if (calendar.isLeapYear(year)) {                System.out.println(year);            }        }    }

Die Methode

    public static boolean isLowerCase(char ch)

der Klasse java.lang.Character leistet das Gewünschte.

public double radius(double flaeche) {

        return Math.sqrt(flaeche / Math.PI);    }

Zum Einlesen verwenden wir in der Regel die Klasse BufferedReader, da diese es ermöglicht, ganze Zeilen einzulesen. Die Konstruktor erwartet einen weiteren Reader. Wollen wir vom Standardeingabestrom lesen, so verwenden wir einen InputStreamReader. Wollen wir Daten aus einer Datei einlesen, so ist FileReaderdie richtige Wahl. Die folgenden Anweisungen lesen solange Eingaben von der Tastatur, bis die Zeichenkette"Ende" eingegeben wird oder keine Eingaben mehr erfolgen. Der Datenstrom sollte am Ende immer mit der Methode close() geschlossen werden. Wenn Daten eingelesen werden, kann es vorkommen, dass unvorhergesehene Ereignisse diese Aktion unterbrechen. In einem solchen Fall wird eine IOExceptiongeworfen. Diese können wir mit einer try-Anweisung abfangen und behandeln. Da auch das Schließen des Datenstroms eine IOException werfen kann, wird es im finally-Block einer inneren try-Anweisung behandelt.

    //  neuen  Reader  anlegen    BufferedReader br = new BufferedReader(                                new InputStreamReader(System.in));    try {        try {            // erste Zeile einlesen            String line = br.readLine();            // solange nicht "Ende" eingelesen wird            while (line != null && !"Ende".equals(line)) {                // Zeichenkette verarbeiten                // ...                // nächste Zeile einlesen                line = br.readLine();            }        } finally {            // Datenstrom schließen            br.close();        }    } catch (IOException e) {        System.out.println("Fehler beim Einlesen.");    } 

import java.io.FileReader;import java.io.BufferedReader;import java.io.FileNotFoundException;import java.io.IOException;public class Rechner {    private String dateiname;    public Rechner(String filename) {        this.dateiname = filename;    }    public long addiere() {        long summe = 0;        try {            BufferedReader br = new BufferedReader(                                  new FileReader(this.dateiname));            try {                String line = br.readLine();                while (line != null) {                    summe += Long.parseLong(line);                    line = br.readLine();                }            } finally {                br.close();             }        }        catch (FileNotFoundException e) {            System.out.println("Datei wurde nicht gefunden.");        } catch(IOException e) {            System.out.println("Datei kann nicht gelesen werden.");        } catch(NumberFormatException e) {            System.out.println("Datei enthält unzulässige "                                                + "Zeichen.");        }        return summe;    }}

importieren java.util.Scanner;importieren java.io.File;Import java.io.FileNotFoundException;public class ScannerRechner {    private String dateiname;    öffentlichen ScannerRechner (String filename) {        this.dateiname = filename;    }    public long addiere () {        langen summe = 0;        try {            Scanner sc = new Scanner (new File (this.dateiname));            while (sc.hasNextLong ()) {                summe + = sc.nextLong ();            }        } Catch (FileNotFoundException e) {            System.out.println ("Datei wurde nicht gefunden.");        }        zurück summe;    }}

Import java.io.FileReader;importieren java.io.PrintWriter;Import java.io.FileNotFoundException;import java.io.IOException;public class Filter {    private String dateinameIn;    private String dateinameOut;    öffentliche Filter (String infile, String outfile) {        this.dateinameIn = infile;        this.dateinameOut = outfile;    }    public void filter () {        try {            BufferedReader br = new BufferedReader (                                neue FileReader (this.dateinameIn));            PrintWriter pw = new PrintWriter (this.dateinameOut);            try {                String line = br.readLine ();                while (line! = null) {                    if (line.length ()> 0                             && Character.isUpperCase (                                    line.charAt (0))) {                        pw.println (line);                    }                    line = br.readLine ();                }            } Finally {                br.close ();                 pw.flush ();                pw.close ();            }        } Catch (FileNotFoundException e) {            System.out.println ("Datei wurde nicht gefunden.");        } Catch (IOException e) {            System.out.println ("Datei can Nicht Gelesen Werden.");        }     }}

Generische Klassen [JLS:  8.1.2,  9.1.2] besitzen zusätzlich zu ihrem Namen noch eine oder mehrere Typvariablen [JLS:  4.4]. Diese Typvariablen werden auch als Typparameter bezeichnet. Die Typparameter werden in spitzen Klammern angeben. Eine Liste von Zeichenketten würde mit dem Typ List<String> und eine Liste von ganzen Zahlen mit dem Typ List<Integer> deklariert werden. Dabei ist zu beachten, dass Typparameter nur Klassen und keine primitiven Datentypen sein können.

Ein Iterator bietet die Möglichkeit, die Elemente eine Datensammlung linear zu durchlaufen, ohne dabei Details über die Struktur der Datensammlung zu kennen. Die Schnittstelle Collection besitzt die Methodeiterator(), die ein java.util.Iterator-Objekt java.util.Iterator für den aktuellen Container zurückliefert.

• hasNext(), die prüft, ob es noch weitere unbesuchte Elemente gibt,

• next(), die das nächste Element zurückliefert und dann den Iterator auf das folgende Element setzt, sowie

• remove(), die das letzte vom Iterator zurückgelieferte Element aus der Sammlung entfernt.

    public void print(Collection<String> c) {        // ungültige Argumente abfangen        if (c == null) {            return;        }        // Iterator erzeugen        Iterator<String> it = c.iterator();        // solange Elemente vorhanden        while (it.hasNext()) {            // nächstes Element holen            String s = it.next();            // Element ausgeben            System.out.println(s);        }    }

Beachten Sie, dass es sich sowohl bei Iterator als auch bei Iterable um generische Typen handelt.

void findeKuerzesteUndLaengsteZeichenkette(List<String> l) {    if (l == null || l.isEmpty()) {        return;    }    String min = l.get(0);    String max = l.get(0);    for (String s : l) {        if (s.length() < min.length()) {            min = s;        }        if (s.length() > max.length()) {            max = s;        }    }    System.out.println(min);    System.out.println(max);}

class Bubblesorter<T extends Comparable<T>> {    public void sort(T[] feld) {        // es werden maximal feld.length - 1 Durchläufe benötigt        for (int i = 0; i < feld.length - 1; i++) {            // solange keine Vertauschungen vorgenommen werden            // ist das Feld sortiert            boolean sorted = true;            // Durchlaufe das Feld, in jedem Durchlauf muss            // ein Element weniger berücksichtigt werden            for (int j = 0; j < feld.length - 1 - i; j++) {                if (feld[j].compareTo(feld[j + 1]) > 0) {                    // wenn linkes größer                    // dann vertausche                    T temp = feld[j];                    feld[j] = feld[j + 1];                    feld[j + 1] = temp;                    // Feld ist nicht sortiert                    sorted = false;                }            }            if (sorted) {                // keine Vertauschungen, Feld ist                // folglich vollständig sortiert                break;            }        }    }}

Set<String> menge = new HashSet<String>();    String a = "Hallo Welt!";    String b = "Hallo";    String c = "Welt!";    String d = b + " " + c;    menge.add(a); // liefert true    menge.add(b); // liefert true    menge.add(c); // liefert true    menge.add(d); // liefert false, da gleiche Zeichenkette                   // schon enthalten    menge.size(); // liefert 3    menge.contains(b); // liefert true    menge.contains(d); // liefert true    menge.contains("Test"); // liefert false    menge.remove(d); // liefert true, da zu löschender Wert                     // enthalten    menge.size(); // liefert 2

Map<Integer,String> m = new HashMap<Integer,String>();    String a = "Hallo";    String b = "Welt!";    m.put(10, a); // liefert null, da vorher kein Wert zu 10                  // gespeichert war    m.put(12, b); // liefert null, da vorher kein Wert zu 12                  // gespeichert war    m.get(10); // liefert "Hallo"    m.get(4); // liefert null, da kein zugehöriger Wert              // gespeichert ist    m.put(10, "Test"); // liefert "Hallo", da dieser vorher mit                       // dem Wert 10 verknüpft war    m.get(10); // liefert "Test"    m.size(); // liefert 2, da nur zwei verschiedene Paar              // gespeichert sind    m.remove(12); // liefert "Welt!"    m.size(); // liefert 1

public interface Paar<S,W> {    /**     * liefert den gespeicherten Schluessel     * @return den gespeicherten Schluessel     */    public S liefereSchluessel();    /**     * liefert den gespeicherten Wert     * @return den gespeicherten Wert     */    public W liefereWert();    /**     * speichert einen neuen Schluessel     * @param schluessel der neue Schluessel     */        public void setzeSchluessel(S schluessel);    /**     * speichert einen neuen Wert     * @param wert der neue Wert     */      public void setzeWert(W wert);    /**     * vergleich das gegebene Paar mit diesem     * @param p das zu vergleichende Paar     * @return true, wenn sowohl Schlüssel als auch Wert gleich     * sind, d.h. equals() true liefert, sonst false     */    public boolean istGleich(Paar<S,W> p);}

public class PaarImpl<S,W> implements Paar<S,W> {    private S schluessel;    private W wert;        public S liefereSchluessel() {        return this.schluessel;    }    public W liefereWert() {        return this.wert;    }        // ...}

public class PaarImpl<S,W> implements Paar<S,W> {    private S schluessel;    private W wert;        public PaarImpl(S schluessel, W wert) {        this.setzeSchluessel(schluessel);        this.setzeWert(wert);    }        public S liefereSchluessel() {        return this.schluessel;    }    public W liefereWert() {        return this.wert;    }        public void setzeSchluessel(S schluessel) {        this.schluessel = schluessel;    }        public void setzeWert(W wert) {        this.wert = wert;    }        public boolean istGleich(Paar<S,W> p) {       return this.istSchluesselGleich(p.liefereSchluessel())            && this.istWertGleich(p.liefereWert());    }        private boolean istSchluesselGleich(S andererSchluessel) {        if (schluessel == null) {            return andererSchluessel == null;        }        return schluessel.equals(andererSchluessel);    }        private boolean istWertGleich(W andererWert) {        if (wert == null) {            return andererWert == null;        }        return wert.equals(andererWert);    }}

public class X<E extends F & G> {} 

Damit die Elemente direkt beim Einfügen sortiert werden können, muss der Typparameter E die folgende Einschränkung E extends Comparable<E> erfüllen. Um eine generische Listenklasse zu erhalten, müssen wir zunächste die Klasse ListNode anpassen.

public class ListNode<T> {    private T entry;    private ListNode<T> next;        public ListNode(T value) {        this(value, null);    }        public ListNode(T value, ListNode<T> nextNode) {        this.entry = value;        this.next = nextNode;    }        public void setEntry(T value) {        this.entry = value;    }    public void setNext(ListNode<T> nextNode) {        this.next = nextNode;    }        public T getEntry() {        return this.entry;    }        public ListNode<T> getNext() {        return this.next;    }}

Anschließend können wir die Klasse LinkedList oder SortedList ebenfalls anpassen. Exemplarisch ist nachfolgend nur die Klasse SortedList gezeigt.

public class SortedList<E extends Comparable<E>> {    private ListNode<E> head;        public SortedList() {        this.head = null;    }        public void add(E value) {        this.head = add(this.head, value);    }        private ListNode<E> add(ListNode<E> node, E value) {        if (node == null) {            return new ListNode<E>(value, node);        }        if (node.getEntry().compareTo(value) > 0) {            return new ListNode<E>(value, node);        }        node.setNext(add(node.getNext(), value));        return node;    }}