226-1 Objektorientiert implementieren

  • 18 Mär. 2018
  • 10:05

    Einfürung in Java JavaDoc

    Zitat eines Forum-Nutzers aus www.java-forum.org: "Das Schlimmste, was es gibt, ist schlecht dokumentierter, oder gar nicht dokumentierter Quellcode. Musste mich auch mal in nicht dokumentierten Quellcode einarbeiten und dazu war das Programm auch noch total unübersichtlich geschrieben. Anfangs dachte ich noch, dass es ja gut sei, dass der Programmierer noch in der Firma ist, nachdem er sich aber selbst auch nicht mehr ausgekannt hat, blieb die ganze Arbeit an mir hängen. Als ich dann immer ärgerlicher wurde und ihn darauf ansprach, was er da für einen Blödsinn verzapft hat, hat er nur blöd gelacht. In der Anfangszeit meiner Programmierung habe ich auch nur wenig dokumentiert, aber nachdem ich das erlebt habe, dokumentiere ich wirklich jede Kleinigkeit." Quellcode zu kommentieren und zu dokumentieren ist wahrscheinlich in den eigenen Programmieranfängen eine äusserst aufwendige und fürs eigene Gefühl auch völlig überflüssige Zeitverschwendung. Wahrscheinlich muss man selber erst erlebt haben, wie der Forum-Nutzer, der oben zitiert wird, dass sich die investierte Zeit auf vielfältige Art lohnt.
    JavaDoc ist ein Programm, das bei der Entwicklung von Java-Programmen benutzt wird und zum Java Development Kit (JDK) gehört. Es ist in der Lage, aus speziell gekennzeichneten Kommentaren innerhalb des Quelltextes technische Dokumentationen im HTML-Format zu erstellen. Diese Dokumentationen enthalten Informationen über die Klassen an sich, darin verfügbare Methoden und vor allem ergänzenden Text, den Programmierer hinzugefügt haben, um die Funktionsweise zu erläutern. JavaDoc durchsucht den Java-Quellcode und generiert daraus automatisch HTML-Dokumente. Damit in diesen HTML-Dokumenten nützliche Informationen stehen, sind jedoch spezielle JavaDoc-Kommentare notwendig (beginnend mit /**). Die Position dieser Kommentare befindet sich vor dem zu kommentierenden Block. Im Kommentar können spezielle JavaDoc-Tags verwendet werden, die eine Kennzeichnung des nachfolgenden Inhalts spezifizieren (@author Name des Authors). Eine Aufstellung wichtiger JavaDoc-Tags befindet sich am Ende des Dokumentes. Ist der Quellcode ausreichend mit Kommentaren ausgestattet, kann die Dokumentation generiert werden. Dazu ist das Tool javadoc.exe aus dem aktuellen JDK notwendig. Ist dies in der Entwicklungsumgebung nicht vorhanden, muss javadoc zuerst installiert werden. Das Tool ist nur im JDK enthalten und nicht im JRE. Es kann also von der Seite http://www.oracle.com/technetwork/java/javase/downloads/index.html das aktuelle JDK heruntergeladen und installiert werden.

    Tag & Parameter

    Beschreibung

    Verwendbar in

    @author name

    Beschreibt den Autor

    Klasse, Interface

    @version version

    Erzeugt einen Versionseintrag. Darf max. einmal pro Klasse oder Interface verwendet werden!

    Klasse, Interface

    @see reference

    Erzeugt einen Link auf ein anderes Element der Dokumentation.

    Klasse, Interface, Instanzvariable, Methode

    @param name description

    Parameterbeschreibung einer Methode

    Methode

    @return description

    Beschreibung des Rückgabewertes einer Methode

    Methode

    @deprecated description

    Beschreibt eine veraltete Methode, die nicht mehr verwendet werden sollte. Sollte immer mit der @Deprecated-Annotation verwendet werden!

    Methode

    @exception classname description

    Beschreibung einer Exception, die von dieser Methode geworfen werden kann.

    Methode

    @throws classname description

    @since jdk-version

    Seit wann die Funktionalität existiert.

    Klasse, Interface, Instanzvariable, Method

    {@inheritDoc}

    Kopiert die Beschreibung aus der überschriebenen Methode.

    Überschreibende Methode

    {@link reference}

    Link zu einem anderen Symbol.

    Klasse, Interface, Instanzvariable, Methode

    {@linkPlain reference}

    Link zu einem anderen Symbol. Der Link wird jedoch als Standardtext angezeigt.

    Klasse, Interface, Instanzvariable, Methode

    {@value}

    Gibt den Wert eines konstanten Feldes zurück.

    Statisches Feld

    {@code}

    Formatiert Text buchstabengetreu mit dem Quelltextzeichensatz und unterdrückt die Interpretierung von beinhalteten HTML oder Javadoc-Tags.

    Klasse, Interface, Instanzvariable, Methode

    {@literal}

    Kennzeichnet buchstabengetreuen Text und unterdrückt die Interpretierung von beinhalteten HTML oder Javadoc-Tags.

    Klasse, Interface, Instanzvariable, Methode

  • 18 Mär. 2018
  • 10:05

    Einfürung in Java Sequenzdiagramm

    Die Struktur eines objektorientierten Programms – die Klassen und die Beziehungen zwischen den Klassen – sind nur die halbe Miete, wenn es darum geht das Programm zu verstehen. Genauso wichtig sind die Dynamik oder die Abläufe im Programm.
    Sequenzdiagramme sind das Mittel der Wahl, wenn es darum geht die Abläufe zur Laufzeit des Programmes zu dokumentieren. Ein Sequenzdiagramm zeigt einen Ausschnitt – einen Film – aus dem Leben des Programms. Es zeigt die während einer bestimmten Zeit vorhandenen Objekte und den Ablauf der Methodenaufrufe bei diesen Objekten. Letzteres wird auch als Abfolge von Meldungen bezeichnet, welche die Objekte einander senden.

    WikiTubia: Sequenzdiagramm

  • 18 Mär. 2018
  • 10:05

    Einfürung in Java Delegation anwenden

    Gute klassenbasierte (und später auch gute objektorientierte) Programmentwürfe sind unser erklärtes Ziel. Dadurch verbessern wir die Qualität unserer Programme und vermindern die Wahrscheinlichkeit von Fehlern. Es gibt verschiedene Entwurfsprinzipien, welche wir anwenden können, um zu diesem Ziel zu gelangen. Eines davon heisst Delegation.
    Delegation in einem Programm funktioniert genau gleich wie im Alltag. Im Kern steht folgende Idee: Der Chef macht nicht alles selber, sondern er kann Arbeiten an seine Mitarbeiter weitergeben, oder eben delegieren. Wichtig ist dabei, dass die Mitarbeiter über die nötigen Mittel und Informationen für die Erledigung der Arbeiten verfügen. In einem klassenbasierten Programm heisst das: Ein Objekt soll in seinen Methoden drin möglichst nicht alles selber machen, sondern Teilaufgaben durch den Aufruf von Methoden bei anderen Objekten an diese delegieren.

    Francisco Iacobelli: Delegate Pattern

  • 18 Mär. 2018
  • 10:05

    Einfürung in Java Klassen entwerfen

    Einer der schwierigeren Schritte beim Entwickeln eines klassenbasierten Programms ist das Finden von guten Klassen. Eine Bemerkung vorweg: Das Finden von Klassen gelingt mit zunehmender Erfahrung immer besser. Allerdings setzt dies voraus, dass Sie ihre eigene Arbeit immer wieder kritisch hinterfragen und nicht mit der erstbesten Lösung zufrieden sind, sondern diese bei Bedarf überarbeiten.
    Der erste Schritt ist, eine Liste mit möglichen Klassen zu erstellen. Gehen Sie dazu durch die Minimalanforderungen an das Programm und markieren Sie im Text Substantive, welche eine Bedeutung für das Projekt haben. Nicht alle Substantive werden später zu einer Klasse. Einige werden stattdessen zu Attributen (Instanzvariablen) einer Klasse oder finden gar keine Entsprechung im Programm. Wählen Sie drei bis vier Substantive aus, von denen Sie ziemlich sicher sind, dass diese eine Klasse repräsentieren. Hier kommen vor allem die Bestandteile in Frage, also „Dinge“, welche während der Ausführung des Programms (zur Laufzeit) als eigenständige Objekte auftreten werden. Versuchen Sie nun in zwei, drei prägnanten Sätzen die Aufgabe dieser Klassen, man spricht von der Verantwortlichkeit, zu beschreiben. Hier müssen wir nun das Single-Responsibilty-Prinzip (SRP) beachten: Jede Klasse sollte nur eine Verantwortlichkeit haben. Wenn wir feststellen, dass zwei, drei Sätze für die Beschreibung nicht ausreichen, haben wir vermutlich das SRP verletzt und müssen die Klasse aufteilen. Auch hier gilt, mit der Erfahrung werden wir klüger. Also nicht von Anfang an nach einer perfekten Lösung suchen, sondern später zurückkommen und allenfalls die Lösung überarbeiten. Wichtig ist: Keine Verantwortlichkeiten auf Vorrat („das könnte dann mal später gebraucht werden“) einbauen! Jetzt geht es darum, die Eigenschaften der von Ihnen in der Aufgabe 2 beschriebenen Klassen genauer festzulegen. Darunter verstehen wir vorerst die Attribute / Instanzvariablen. Später kommen die Operationen / Methoden hinzu. Wir beginnen mit den Attributen. Überlegen Sie sich, welche Informationen die Objekte einer Klasse brauchen, um ihre Verantwortlichkeiten wahrzunehmen Nun wenden wir uns den Operationen / Methoden der einzelnen Klassen zu. Zu diesem Zweck gehen wir nochmals in die Minimalanforderungen. Diese Mal suchen wir nach Verben, welche in Zusammenhang mit beschriebenen Klassen stehen. Diese geben uns Hinweise auf mögliche Operationen / Methoden. Gehen Sie jetzt durch den Text der Minimalanforderungen und suchen Sie wie oben beschrieben nach Operationen / Methoden. Fügen Sie diese in das Klassendiagramm ein. Überlegen Sie sich bei jeder Operation / Methode, welche Parameter benötigt werden und nehmen Sie auch diese ins Klassendiagramm auf. Zum Schluss suchen wir noch nach Beziehungen zwischen den gefundenen Klassen. Beziehungen bestehen überall da, wo ein Objekt eine dauerhafte Referenz auf ein anderes Objekt hat. Das sind typischerweise Instanzvariablen, mit einer Klasse als Typ (wie Sie das in Lektion 7 auch schon gesehen haben). Beziehungen im klassenbasierten Entwurf findet man wiederum, indem man Sätze in der Form „ein …-Objekt kennt ein /mehrere …-Objekte“ Beispiel: „Das Spielfeld kennt alle Zellen“. Daraus leiten wir her, dass die Klasse Spielfeld eine Beziehung zur Klasse Zelle hat. Wir können sogar noch weiter gehen und sagen, dass ein Spielfeldobjekt eine Beziehung zu vielen Zellen-Objekten hat.

    TheSimpleInformatics: Erste eigene Klasse - Objektorientierte Programmierung in Java Teil 2

  • 22 Nov. 2017
  • 10:05

    Einfürung in Java Unit Tests

    Dass bei der Auswahl der Testfall-Menge nicht willkürlich vorgegan- gen werden kann, leuchtet ein. Das Vorgehen muss also nach be- stimmten Prinzipien erfolgen. Es stellt sich nämlich die Frage: Wo sind in einem Programm prinzipiell Fehler zu erwarten? Man unter- scheidet folgende Vorgehensweisen:
    . Intuition
    . Grenzwertanalyse
    . Äquivalenzklassenbildung
    a) Die Intuition
    Gerade beim ersten Punkt wird klar, dass Testen auch eine Angele- genheit der Erfahrung ist. So kann die Frage, welches unter den gege- benen Umständen kritische Punkte in einem Programm sind, nur aufgrund der Erfahrung (Intuition) beantwortet werden. Darum sind erfahrene Programmierer auch die besten Tester. Die Gefahr besteht zwar, dass sie eine gewisse Betriebsblindheit entwickeln, diese kann aber mittels Einbezug des Human-Testing (Pulttest, Walk-Through, Code Inspection und Peer Rating) korrigiert werden.
    b) Die Grenzwert-Analyse
    Die Grenzwert-Analyse ist ein sehr altes Verfahren und den meisten vertraut (vgL Abb. 4.208). Bei dieser Art von Analyse werden die Werte "rund" um die Grenzwerte getestet. Oft wird dabei auch mit dem Grenzwert selbst noch getestet, so dass für jede Grenze drei Werte getestet werden müssen: der Wert unmittelbar vor der Grenze, der Wert unmittelbar danach und die Grenze selber.
    c) Das Bilden von Äquivalenzklassen
    Da es bei komplexen Programmen aus ökonomischen Gründen unmöglich ist, alle Testfälle durchzuspielen, ist das Bilden von Äquivalenzklassen von grosser Bedeutung. Man betrachtet dabei das Programm als Black-Box und beobachtet die Wirkung von Eingabe- werten.

    JUnit.mp4

  • 18 Nov. 2017
  • 19:05

    Einfürung in Java String Klassen

    In java ist String keine Datentyp sondern eine API Integrierte Klasse.
  • 18 Nov. 2017
  • 19:05

    Einfürung in Java Klassen

    Die Klasse definiert die Struktur und das Verhalten aller Objekte dieser Klasse. Um eine Klasse zu schreiben muss man sich zwei Fragen stellen:
    1. Welche Informationen müssen in den einzelnen Objekten gespeichert werden? Daraus ergeben sich die Instanzvariablen der Klasse ( Struktur).
    2. Welches Verhalten bieten die Objekte der Klasse an? Oder anders gefragt (und wohl verständlicher): Welche Operationen sollen mit einem Objekt und den darin gespeicherten Informationen durchgeführt werden können? Daraus ergeben sich die Methoden der Klasse ( Verhalten/Dynamik).

    Klasse Konto.mp4

    Klassendiagramm.mp4

    Klassendiagramm mit modelio.mp4

  • 10 Nov. 2017
  • 12:05

    Einfürung in Java Konstruktoren

    Konstruktoren sind spezielle methodenähnliche Klassenstrukturen, die den Namen ihrer Klasse tragen und beim Erzeugen von Objekten der Klasse über das Schlüsselwort new aufgerufen werden.

    Eine Klasse kann keinen, einen oder mehrere unterschiedliche Konstruktoren besitzen. Sie dienen dazu, ein neu gebildetes Objekt einer Klasse in einen definierten Anfangszustand zu versetzen. Welcher dies ist hängt davon ab, welcher Konstruktor bei der Objektbildung aufgerufen wird. Wird lediglich ein leerer (Standard-) Konstruktor ohne Parameterübergabe benötigt, so muss dieser nicht ausdrücklich angegeben werden. Er wird bei Fehlen vom Compiler automatisch erzeugt. Allerdings ist dies nur der Fall, solange kein weiterer Konstruktor deklariert wurde. Werden neben weiteren Konstruktoren auch ein leerer Konstruktor benötigt, so muss dieser explizit angegeben werden.

    Das Beispiel zeigt eine Klasse mit zwei Konstruktoren. Der erste ist ein Standardkonstruktor, der zweite dient zur Instanzierung einer int Instanzvariablen. Beim Aufruf dieses Konstruktors wird somit ein int-Attribut bereits beim Erzeugen einer Instanz initialisiert. Soll also ein Objekt der Klasse KonstruktorClass erzeugt werden, kann dies ohne oder mit Angabe eines Anfangswertes für die Instanzvariable x geschehen:

    KonstruktorClass konst = new KonstruktorClass();

    oder:

    KonstruktorClass konst = new KonstruktorClass(2);

    Konstruktoren müssen einigen Regeln folgen:

    • Sie tragen immer den Namen der Klasse.
    • Sie können überladen werden (mehrere Konstruktoren).
    • Sie besitzen keinen Rückgabewert.
    • Rufen sie ihrerseits keinen anderen Konstruktor auf, werden sie vom Compiler um den Aufruf des Konstruktors der Basisklasse super() erweitert.

    Konstruktoren.mp4

  • 10 Nov. 2017
  • 09:05

    Einfürung in Java Kontrollstrukturen

    Als Kontrollstrukturen bezeichnet mann Programmir Elemente die zu Entscheidungen im Programm führen.
    Oder auch Itrarationen (wiederholende ausführungen).

    KonsoleUndScanner.mp4

    KonsoleUndScannerMitException.mp4

    Problem lösen.mp4

    Problem lösen 2.mp4

    Problem lösen Implementation.mp4

    ArraysUndReferenzen.mp4

    RefactoringMethodenExtrahieren.mp4

  • 9 Sep. 2017
  • 12:05

    Einfürung in Java Datentypen und Variabeln

    Variablen sind Speicherorte für Daten wie Zahlen, Texte oder Adressen. Java ist eine statisch typisierte Programmiersprache. Das bedeutet, dass zu dem Zeitpunkt, wo das Java-Programm erstellt wird bekannt sein muss, welchen Typ eine Variable hat. Typen können so genannte primitive Datentypen sein oder beliebig komplexe Klassen.
    Primitive Datentypen sind eine Gruppe von Typen, mit denen man Variablen erstellen kann, die Zahlen, einzelne Zeichen oder logische Werte aufnehmen. Für jeden primitiven Datentyp gibt es zudem eine eigene, so genannte Wrapperklasse, die diesen Datentyp aufnimmt. Nachdem wir die einzelnen primitiven Datentypen besprochen haben, besprechen wir die zugehörigen Wrapperklassen und zeigen Vor- und Nachteile auf. Die primitiven Datentypen, ihr typischer Wertebereich und die zugehörige Wrapperklasse haben wir in der folgenden Tabelle für Sie aufgeführt.
    Typname Größe Wrapper-Klasse Wertebereich Beschreibung
    boolean undefiniert java.lang.Boolean true / false Boolescher Wahrheitswert, Boolescher Typ
    char 16 bit java.lang.Character 0 ... 65.535 (z. B. 'A') Unicode-Zeichen (UTF-16)
    byte 8 bit java.lang.Byte -128 ... 127 Zweierkomplement-Wert
    short 16 bit java.lang.Short -32.768 ... 32.767 Zweierkomplement-Wert
    int 32 bit java.lang.Integer -2.147.483.648 ... 2.147.483.647 Zweierkomplement-Wert
    long 64 bit java.lang.Long -263 bis 263-1, ab Java 8 auch 0 bis 264 -1 Zweierkomplement-Wert
    float 32 bit java.lang.Float +/-1,4E-45 ... +/-3,4E+38 32-bit IEEE 754, es wird empfohlen, diesen Wert nicht für Programme zu verwenden, die sehr genau rechnen müssen.
    double 64 bit java.lang.Double +/-4,9E-324 ... +/-1,7E+308 64-bit IEEE 754, doppelte Genauigkeit
    Aufgabe 1
    public class Variablen_ausgeben {
        public static void main(String[] args) {
        // Variablendefinition mit Initialisierung
        boolean lichtschalter = true;
        String name = "nelson";
        byte anzLernende = 24; //byte hat einen genug grossen Int wert um Klassen bis zu 127 Schüller zu Speichern
        double kontoBetrag = 2400.90;
        float betrag = (float) 2.5; //cast Operator
        float betrag = 2.5f; // Alternative Schreibweisse
        char zeichen ='?';
        // Ausgabe der Variablenwerte
        System.out.println("name: " + name);
        System.out.println("anzLernende: " + anzLernende);
        System.out.println("Geld: " + kontoBetrag);
        System.out.println("lichtschalter an?: " + lichtschalter);
        System.out.println("betrag: " + betrag);
        System.out.println("zeichen: " + zeichen);
        }
    }
    
    Aufgabe 2
    public class Variablen_operatoren_2 {
        public static void main(String[] args) {
        int a = 2, b = 3;
        System.out.println(a == 2 && b < 8);
        System.out.println(a != 2 || !(b < 2));
        System.out.println(a == 2 ^ b > 0);
        System.out.println(a == 0 && b++ == 3);
        System.out.println(b);
        System.out.println(a == 0 & b++ == 3);
        System.out.println(b);
        System.out.println(a == 2 || b++ == 3);
        System.out.println(b);
        System.out.println(a == 2 | b++ == 3);
        System.out.println(b);
        }
    }
    
    Aufgabe 3
    public class Variablen_operatoren_3 {
        public static void main(String[] args) {
        int x, y;
        x = 0b10101010;
        y = 0b11110000;
        // 10100000
        x &= y;
        System.out.println(x);
        x = 0b10101010;
        y = 0b00001111;
        // 10101111
        x |= y;
        System.out.println(x);
        x = 0b10101010;
        y = 0b10010000;
        // 00111010
        x ^= y;
        System.out.println(x);
        }
    }
    
    Aufgabe 4
    public class Variablen_operatoren { public static void main(String[] args) { int a = 5; System.out.println((13 / a)); System.out.println(12 / (a/2)); System.out.println(12. % 2.5); System.out.println(++a + " " + a); System.out.println(a++ + " " + a); System.out.println(--a + " " + a); System.out.println( a-- + " " + a); double x = 0.7 + 0.1; double y = 0.9 - 0.1; System.out.println(y - x); } }
  • 2 Sep. 2017
  • 12:05

    Einfürung in Java JFrame

    Als JFrame werden die Klassen Objecte bezeichent die es einem Ermögliechen ein Fester mit Java zu erstellen.

    Top-Down-Zerlegung.mp4

    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    public class Fenster {
    
        /**
        * @param args
        */
        public static void main(String[] args) {
        createAndShowGUI();
        }
    
        private static void createAndShowGUI() {
        //Create and set up the window.
        JFrame frame = new JFrame("Mein Beispiel mit grafischer ausgabe");
        frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
        FlowLayout experimentLayout = new FlowLayout();
        frame.setLayout(experimentLayout);
        JLabel image =  new JLabel(new ImageIcon("src/gibbix.GIF"));
        JLabel text = new JLabel("java-programme in der Gibbix umgebung");
        text.setForeground(Color.blue);
        image.setPreferredSize(new Dimension(250, 150));
        frame.add(image);
        frame.add(text);
        //Display the window.
        frame.pack();
        frame.setVisible(true);
        }
    }
    
  • 25 Aug. 2017
  • 12:05

    Einführung in Java installation Eclipse nano

    Alls erstes mussten wir für das modul ein kleine Java-Konsolenanwendung Programmieren. Eigendlich war dies das sogenante "Hallo welt" Programm.
    Um dies zu realisieren arbeiten wir mit Eclipse nano.

    Eclipseeinführung.mp4

            //Klassen Deklaration Helloworld
            public class Helloword {
            //Aufruf der Main-Methode(Programm einstigs Punkt)
            public static void main(String[] args) {
            //Ausgabe des strings "Hello world" in der Console
            System.out.println("Hello world");}
            }