Komplexe Zahlen in Java als Klasse

Eine Aufgabe in der Vorlesung „Objektorientiertes Programmieren“ war es, eine Klasse ComplexNumber zur Repräsentation einer komplexen Zahl in Java zu erstellen. Meine kommentierte Musterlösung hilft hoffentlich auch einigen anderen Studenten. Hierzu sollten auch clone, equals, hashCode und toString sinnvoll überschrieben werden.

Die zusammenhängende, unkommentierte Klasse ist übrigens unter „Informatik-Studium – Vorlesungen – Objektorientiertes Programmieren – Komplexe Zahl als Klasse in Java“ zu finden.

/**
 * Repräsentation einer komplexen Zahl.
 *
 * @author Karl Lorey
 * @version 1.0.0
 *
 */
public class ComplexNumber {

Attribute

Zunächst müssen die Eigenschaften einer komplexen Zahl als Attribute dargestellt werden. Dies sind der Real- und der Imaginär-Teil der jeweiligen Zahl.

/**
     * Realteil.
     */
    double re;

    /**
     * Imaginärteil
     */
    double im;

Konstruktoren

Weiterhin sind für die komplexe Zahl Konstruktoren zur Erstellung einer komplexen Zahl zu definieren. Zunächst ein Konstruktor zum Erstellen der Zahl 0.

/**
     * Erstellt 0.
     */
    public ComplexNumber() {
        this(0);
    }

Weiterhin ein konstruktor, zum Erstellen einer reellen Zahl. Eine reelle Zahl ist eine komplexe Zahl mit 0 als Imaginärteil. Es wird der Konstruktor zum Erstellen einer komplexen Zahl aufgerufen und 0 als imaginärteil übergeben.

/**
     * Erstellt eine reelle Zahl.
     *
     * @param real
     *            Reelle Zahl.
     */
    public ComplexNumber(double real) {
        this(real, 0);
    }

Der Konstruktor zum Erstellen einer „normalen“ komplexen Zahl.

/**
     * Erstellt eine komplexe Zahl.
     *
     * @param real
     *            Realteil.
     * @param img
     *            Imaginärteil.
     */
    public ComplexNumber(double real, double img) {
        this.re = real;
        this.im = img;
    }

Um mit einer komplexen Zahl schnell eine weitere komplexe Zahl zu instanziieren zu können, existiert ein Konstruktor, der eine andere komplexe Zahl dupliziert.

/**
     * Erstellt eine komplexe Zahl mithilfe einer anderen komplexen Zahl.
     *
     * @param cn
     *            komplexe Zahl.
     */
    public ComplexNumber(ComplexNumber cn) {
        this.re = cn.re;
        this.im = cn.im;
    }

Rechenoperationen für komplexe Zahlen

/**
     * Addiere eine komplexe Zahl zu dieser Zahl.
     *
     * @param cn
     *            komplexe Zahl die addiert werden soll.
     * @return Das Ergebnis der Addition.
     */
    public ComplexNumber add(ComplexNumber cn) {
        return new ComplexNumber(this.re + cn.re, this.im + cn.im);
    }

    /**
     * Subtrahiere eine komplexe Zahl von dieser Zahl.
     *
     * @param cn
     *            komplexe Zahl die subtrahiert werden soll.
     * @return Das Ergebnis der Subtraktion.
     */
    public ComplexNumber subtract(ComplexNumber cn) {
        return new ComplexNumber(this.re - cn.re, this.im - cn.im);
    }

    /**
     * Multiplizieren eine komplexe Zahl zu dieser Zahl.
     *
     * @param cn
     *            komplexe Zahl die multipliziert werden soll.
     * @return Das Ergebnis der Multiplikation.
     */
    public ComplexNumber multiply(ComplexNumber cn) {
        double re = this.re * cn.re - this.im * cn.im;
        double im = this.im * cn.re + this.re * cn.im;
        return new ComplexNumber(re, im);
    }

    /**
     * Dividiere eine komplexe Zahl durch diese Zahl.
     *
     * @param cn
     *            komplexe Zahl die dividiert werden soll.
     * @return Das Ergebnis der Division.
     */
    public ComplexNumber divide(ComplexNumber cn) {
        // a+bi / c+di
        double cAndDSquared = (cn.re * cn.re + cn.im * cn.im);
        double re = (this.re * cn.re + this.im * cn.im) / cAndDSquared;
        double im = (this.im * cn.re - this.re * cn.im) / cAndDSquared;
        return new ComplexNumber(re, im);
    }

Rechenoperationen für reelle Zahlen

/**
     * Addiere eine reelle Zahl zu dieser Zahl.
     *
     * @param number
     *            reelle Zahl die addiert werden soll.
     * @return Das Ergebnis der Addition.
     */
    public ComplexNumber add(double number) {
        return this.add(new ComplexNumber(number));
    }

    /**
     * Subtrahiere eine reelle Zahl von dieser Zahl.
     *
     * @param number
     *            reelle Zahl die subtrahiert werden soll.
     * @return Das Ergebnis der Subtraktion.
     */
    public ComplexNumber subtract(double number) {
        return this.subtract(new ComplexNumber(number));
    }

    /**
     * Multiplizieren eine reelle Zahl zu dieser Zahl.
     *
     * @param number
     *            reelle Zahl die multipliziert werden soll.
     * @return Das Ergebnis der Multiplikation.
     */

    public ComplexNumber multiply(double number) {
        return this.multiply(new ComplexNumber(number));
    }

    /**
     * Dividiere eine reelle Zahl durch diese Zahl.
     *
     * @param number
     *            reelle Zahl die dividiert werden soll.
     * @return Das Ergebnis der Division.
     */
    public ComplexNumber divide(double number) {
        return this.divide(new ComplexNumber(number));
    }

Getter- und Setter-Methoden

public void setRealPart(double real) {
        this.re = real;
    }

    public double getRealPart() {
        return this.re;
    }

    public void setImaginaryPart(double imaginary) {
        this.im = imaginary;
    }

    public double getImaginaryPart() {
        return this.im;
    }

clone, equals, hashCode und toString

Die clone-Methode dupliziert die komplexe Zahl. Die equals-Methode prüft auf Gleichheit und die hashCode-Methode erstellt einen hashCode mithilfe der Double-Objekte der beiden Attribute.

public ComplexNumber clone() {
        return new ComplexNumber(this.re, this.im);
    }

    public boolean equals(Object o) {
        if (o instanceof ComplexNumber) {
            ComplexNumber cn = (ComplexNumber) o;
            if (cn.re == this.re && cn.im == this.im) {
                return true;
            }
        }
        return false;
    }

    public int hashCode() {
        Double re = this.re;
        Double im = this.im;

        // XOR erhält eine Gleichverteilung
        return re.hashCode() ^ im.hashCode();
    }

    public String toString() {
        return this.re + "+" + this.im + "i";
    }
}

Für Kommentare ist keine E-Mail-Adresse mehr erforderlich

Da Spam-Bots sich nicht von der erforderlichen Angabe einer E-Mail-Adresse abschrecken lassen, Nutzer die Angabe einer E-Mail-Adresse dafür meistens umso mehr stört, ist ab heute zum Kommentieren die Angabe von E-Mail-Adresse (und Name) nicht mehr nötig.

Die Angabe einer E-Mail-Adresse beim Kommentieren ist zukünftig zwar weiterhin gewünscht, aber nicht mehr verpflichtend, da sie technisch eh nur der Gravatar-Anzeige dient. Eure E-Mail-Adresse wird generell nicht veröffentlicht und von mir nur dazu genutzt, euch per E-Mail ausführlich zu antworten, falls ihr eine Frage per Kommentar gestellt habt.

Frohes Kommentieren!

Geheimnisse der Chrome Developer Tools

Patrick Dubroy stellt in seinem Vortrag auf der Øredev Conference die Geheimnisse der Chrome Developer Tools vor. Jeder Web-Entwickler, der mit den Chrome Developer Tools in Google Chrome oder Chromium arbeitet, sollte die im Vortrag vorgestellten Tipps und Tricks einmal gesehen haben.

Die Developer Tools in Google Chrome/Chromium sind ein mächtiges Werkzeug, um zu verstehen, zu debuggen und Web-Anwedungen zu profilen. Während die meisten Web-Entwickler den Grund-Funktionsumfang der Chrome Developer Tools kennen, wissen nur wenige von den wertvollen Funktionen wie der Timeline und der Speicheranalyse. Dieser Vortrag über die Chrome Developer Tools bietet eine Funktions-Übersicht, zeigt zahlreiche Tipps und Tricks und demonstriert die weniger bekannten Funktionen.

Copyright: Namensnennung – NichtKommerziell – KeineBearbeitung 3.0 Unported (CC BY-NC-ND 3.0), Quelle: Vimeo

Wer keine Möglichkeit das Video in voller Länge zu sehen, nur ein einzelnes Feature sucht, oder alle Geheimnisse, Tipps und Tricks lieber schriftlich aufgelistet mag, für den habe ich anschließend eine kleine Liste aller erläuterten Funktionen zusammengstellt.

Vorgestellte Geheimnisse, Tipps und Tricks und weniger bekannte Funktionen der Chrome Developer Tools

Allgemeine Tipps und Tricks

Die Chrome Developer Tools schnell öffnen (2:15)

Die Chrome Developer Tools öffnen per „Strg + Shift + I“ (2:25) oder mit einem Rechtsklick auf „Element untersuchen“ (2:35).

Die Chrome Developer Tools als Seitenleiste anzeigen

Mit einem Klick auf den ersten Button von links in der unteren Leiste können die Chrome Developer Tools wahlweise als Seitenleiste oder in einem neuen Fenster angezeigt werden.

Der Elements-Tab

HTML-Elemente untersuchen (2:50)

Hover hebt Elemente hervor – Elemente die man in den Chrome Developer Tools mit der Maus überfahrt (per hover), werden auf der Seite farbig hervorgehoben (2:59).

Drag & Drop – Elemente können per Drag & Drop verschoben und per Doppelklick bearbeitet werden (3:17). Weiterhin ist per Rechtsklick eine freie Bearbeitung des HTML-Codes möglich. (4:00)

Änderungen rückgängig machen – Änderungen können durch „Strg + Z“ rückgängig gemacht werden (3:40).

Den Stil (Style) untersuchen (4:05)

Weiterer Tipp: Auf der rechten Seite können die CSS-Regeln mit den Chrome Developer Tools untersucht werden. Hier können beispielsweise einzelne Regeln aktiviert oder deaktiviert werden. Weiterhin können auch neue Regeln erstellt werden.

Abmessungen untersuchen (4:45)

Im Tab unter dem „Styles“-Tab können einzelne Abmessungen untersucht werden, also wie groß Elemente tatsächlich sind. Dieser Trick hilft vor allem, wenn man die berechnete Größe eines Elements genauer untersuchen will.

Weitere Eigenschaften untersuchen (5:05)

In den unteren Tabs können Eigenschaften von DOM-Knoten, Event Listener, und andere Eigenschaften genauer untersucht werden.

Sources-Panel (5:38)

Im Sources-Panel der Chrome Developer Tools können CSS- und JavaScript-Dateien live untersucht, bearbeitet und sogar wieder gespeichert werden (per Rechtsklick).

Tipp/Trick: Per Rechtsklick auch lokale Änderungen untersucht und rückgängig gemacht werden (6:15).

Debugging (6:55)

Die Chrome Developer Tools unterstützen auch diverse Debugging-Funktionen wie Breakpoints, wie man sie aus anderen Entwicklungsumgebungen kennt.

Saubere JavaScript-Darstellung (statt „minified JavaScript“, 7:13)

Tipp/Trick: Durch einen Klick auf die geschweiften Klammern „{}“ in der unteren Leiste wird ein möglicherweise minimierter JavaScript-Code wieder sauber formatiert und ist so deutlich lesbarer.

Tipp/Trick: Dies kann nicht nur bei minimiertem JavaScript-Code, sondern auch bei generell schlecht formatiertem Code hilfreich sein.

Console (8:01)

Die Console zeigt Log-Nachrichten und diverse Fehler bei der Ausführung der Webseite an.

Tipp/Trick: Per Klick kann an die entsprechende Stelle gesprungen werden. Weiterhin kann in der Console auch direkt JavaScript-Code ausgeführt werden.

Suche von Knoten im DOM (9:01)

In der Console der Chrome Developer Tools können per inspect-Funktion Knoten im DOM gesucht werden. Beispielsweise kann der -Knoten mit

inspect(document.body)

gefunden werden.

Timeline (10:10)

Die Timeline der Chrome Developer Tools dient zum genauen untersuchen der Nutzerinteraktion (Loading, Scripting, Rendering, Painting). Mithilfe des Aufnahme-Buttons in der unteren Leiste kann eine Aufnahme gestartet werden. Ab dann werden alle Interaktionen und Events zur späteren Untersuchung von den Chrome Developer Tools aufgezeichnet.

Events

So kann beispielsweise die Funktionsweise einer Webseite untersucht werden. Nach der Aufzeichnung werden alle Events aufgelistet.

Tipp/Trick: Mit einem Klick kann nun zur entsprechenden JavaScript-Funktion gesprungen und diese genauer untersucht werden. Dies spart das Erarbeiten des gesamten JavaScript-Codes.

Frames (14:55)

Zum Leistungs-Profiling der Ausführung einer Webseite in Chrome kann der Frames-Tab genutzt werden. Hier werden die Frame-Raten aller Animationen angezeigt und können so genauer inspiziert werden. So ist es möglich, Performance-Bottlenecks bei der Ausführung bzw. dem Rendering in Google Chrome/Chromium zu erkennen und zu eliminieren.

Tipp: Die Chrome Developer Tools zeigen sogar mögliche Bottlenecks per Warnung-Icon neben dem entsprechenden Event an.

Memory (20:30)

Im Memory-Tab kann die Speichernutzung der Webseite in Google Chrome genauer untersucht werden. So kann beispielsweise die Garbage-Collection im Verlauf der Nutzung untersucht werden. Weiterhin werden Dokumenten-Anzahl, DOM-Knoten-Anzahl und die Anzahl der Event-Listener als Diagramm im Zeitverlauf dargestellt. Auch so lassen sich durch eine mangelhafte Speichernutzung entstehende Performance-Einbußen frühzeitig erkennen.

Profiles-Tab (28:06)

Im Profiles-Tab der Chrome Developer Tools können folgende Profile erstellt werden:

  • CPU-Profil
  • CSS-Selektor-Profil
  • Heap-Snapshot-Erstellung
Heap-Snapshot-Erstellung

Auf die Heap-Snapshot-Erstellung wird genauer eingegangen. Sie ermöglicht die Untersuchung des Speichers mithilfe von Snapshots. So können JavaScript-Memory-Leaks erkannt werden. JavaScript Memory-Leaks sind zum Beispiel Objekte, die von der Garbage-Collection nicht erkannt und deshalb nicht freigegeben werden (diese werden zuvor genauer erläutert, alternativ gibt es bspw. einen Artikel von IBM über JavaScript Memory-Leaks).

Resources-Tab (32:50) und Network-Tab (33:00)

Auf die beiden Tabs wird nicht weiter eingegangen. Beide sind zwar nützliche Tools, jedoch zu genüge dokumentiert und bekannt.

Weiterer Tipp: Verschiedene Versionen der Chrome Developer Tools nutzen (33:30)

Patrick Dubroy empfiehlt als letzten Tipp noch die parallele Nutzung von zwei Google Chrome Versionen, namentlich der Stable- und der Canary-, einer täglich geupdateten Version. So können jederzeit neuste Versionen getestet werden, da beide Versionen problemlos parallel laufen.

Weitere Informations-Quellen zu den Chrome Developer Tools

Theme-Wechsel von Tewnty Eleven auf Twenty Twelve

Ich habe das Update auf WordPress 3.5 genutzt, um von Twenty Eleven zum neuen Standard-Theme Twenty Twelve zu wechseln.

Änderungen

Widgets

Widget Twenty Ten Twenty Eleven Twenty Twelve
Sidebar (überall) ja nein ja
Sidebar (Hauptseite) ja ja ja
Footer nein ja nein

Wie in Twenty Ten (ich habe damals auch über den Theme-Wechsel von Twenty Ten auf Twenty Eleven berichtet), gibt es auch in Twenty Eleven wieder eine permanente Sidebar, die auf allen Seiten angezeigt wird. Bei Twenty Eleven war dies nicht der Fall und es gab unter Artikeln zwar einen Footer aber keine Sidebar. Der Footer ist jetzt wieder weg, dafür ist die Sidebar wieder da. Ein Wechsel von Twenty Ten auf Twenty Twelve ist also deutlich einfacher realisierbar, da die Widgets übernommen werden können.

Meine Widget-Wahl in Twenty Twelve

Mit der Absicht möglichst relevante Informationen für neue und bestehende Nutzer anzubieten, habe ich mich für folgende Sidebar-Widgets für Twenty Twelve entschieden:

  1. Text: Ein kleiner Text über mich
  2. Kategorien: Die Kategorien meines Blogs.
  3. Letzte Beträge: Die fünf letzten Beiträge.
  4. Letzte Kommentare: Die fünf letzten Kommentare.
  5. Suchen: Suchfunktion
  6. Schlagwörter-Wolke: Die meist-genutzten Schlagwörter (Tags)

Sie befinden sich auf einer archivierten Version von karllorey.de. Diese Seite wird seit 2015 nicht mehr aktualisiert. Blog-Artikel haben jeweils den Stand des Veröffentlichungsdatums.

Weitere Informationen finden Sie im letzten Blog-Artikel. Meine Webseite finden Sie nun unter karllorey.com.