Programming Books

https://drive.google.com/open?id=0B18_gfM_Pmu-bEpyVU8wOTVPbjQ

• Clean Code
• code complete 2nd edition
• Effective Java
• HeadFirstDesignPatterns
• Java Performance Tuning
• Java Performance the definitive Guide
• Python High Performance Programming
• Software Architecture Design Pattern
• Working Effectively with Legacy Code

Analoge Uhr in Java

Analoge Uhr in Java

Wie programmiert man eigentlich eine analoge Uhr?

Ist eigentlich nicht so schwierig, jedoch braucht man dazu ein bisschen Trigonometrie und ein Verständnis von Thread. Das ergebnis dieses kleinen Tutorials sieht folgendermassen aus;

Wir werden dazu keine Engine,Library oder so was in der art verwenden. Wir überschreiben lediglich die Paint methode des Frames und zeichnen ganz normale Java Lines mit dem Graphic object. Dazu habe ich ein Modell erstellt mit dem Namen Clock, dieses gibt uns pro Sekunde die verschiedenen Coordinaten zum zeichnen, welche es berechnet hat.

Man muss also eine Formel haben die von Sekunden, Minuten und Stunden auf die Coordinaten der Zeiger kommt. Diese sieht wie folgt aus:

    private void calculateCorrs(){
        this.Sec = new Date().getSeconds();
        this.Minute = new Date().getMinutes();
        this.Hour = new Date().getHours();
        int xsecond = (int) (Math.cos(Sec * 3.14f / 30 - 3.14f / 2) * 120 + ORIGIN.x); 
        int ysecond = (int) (Math.sin(Sec * 3.14f / 30 - 3.14f / 2) * 120 + ORIGIN.y);
        this.secCorr = new Point(xsecond,ysecond);
        int xminute = (int) (Math.cos(Minute * 3.14f / 30 - 3.14f / 2) * 100 + ORIGIN.x); 
        int yminute = (int) (Math.sin(Minute * 3.14f / 30 - 3.14f / 2) * 100 + ORIGIN.y); 
        int xhour = (int) (Math.cos((Hour * 30 + Minute / 2) * 3.14f / 180 - 3.14f / 2) * 80 + ORIGIN.x); 
        int yhour = (int) (Math.sin((Hour * 30 + Minute / 2) * 3.14f / 180 - 3.14f / 2) * 80 + ORIGIN.y);
        this.minCorr = new Point(xminute,yminute);
        this.hourCorr = new Point(xhour,yhour);
    }

Der Punkt Origin ist der Punkt welche alle drei Zeiger gemeinsam haben. Nähmlich die Mitte unserer Uhr. In diesem Fall hat das Frame eine Grösse von 350 auf 350 und der Origin ist somit 175,175.

Jetzt noch die update und Paint Methode und das ganze sollte ziehmlich klar werden.

Update:

    @Override
    public void update(Observable o, Object arg) {
        zeichne = true;
        Clock c = (Clock)o;
        this.secCorr = c.getSecCorr();
        this.minCorr = c.getMinCorr();
        this.hourCorr = c.getHourCorr();
        this.repaint();
        this.revalidate();
    }

Paint:

@Override
    public void paint(Graphics g) {
        super.paint(g);
        Graphics2D g2 = (Graphics2D) g;
        if(zeichne){
            RenderingHints rh = new RenderingHints(this.renderHints);
            g2.setRenderingHints(rh);
            g2.setColor(Color.BLACK);
            g2.setColor(Color.red);
            g2.drawLine(Center.x, Center.y, secCorr.x, secCorr.y);
            g2.setColor(Color.WHITE);
            g2.drawLine(Center.x, Center.y, minCorr.x,minCorr.y);
            g2.drawLine(Center.x, Center.y, hourCorr.x, hourCorr.y);
            g2.drawLine(175,25,175,40);
            g2.drawLine(175, 335, 175, 350);
            g2.drawLine(0, 175, 15, 175);
            g2.drawLine(335, 175, 350, 175);
            g2.drawString("12",168,55);
            g2.drawString("3", 325,180);
            g2.drawString("6", 172,325);
            g2.drawString("9",20,180);
        }
    }

Die Striche von 6,12,3,9 sind hardcoded. Das ist in unserem Fall nicht problematisch, da das Fenster nicht resizeble ist.

Der weitere Code erklärt sich von selbst, diesen kann man unter meinem Github Profil finden.

Das Repo : https://github.com/marcin96/AnalogClock.git

MVC - Pattern mit Java

Das MVC Pattern #Java

Hinweis: Dieses Tutorial baut auf der Netbeans Entwicklungsumgebung und der Gui Library Swing auf.

MVC, was ist das?

Nun vielleicht zuerst was mvc überhaupt bedeuted. Und zwar Model View Controller. Dies ist ein Muster das verwendet wird um Software zu strukturieren. In den Jahren hat es sich sehr gut durchgesetzt da man somit viel besser mit anderen Programmieren zusammen arbeiten kann. Dieses Muster wie auch viele andere dienen dazu die Software Elemente klar und logisch voneinander zu trennen. Daraus ergeben sich viele Vorteile. Zum einen findet man so viel schneller einen Fehler, zum anderen ist man viel flexibler wenn es Fehler gibt, das heisst, das programm stürtzt nicht einfach ganz ab sondern nur ein teilbereich funktioniert nicht. Wenn man es richtig macht. Und zu guter letzt sorgt es für mehr Transparenz wenn man in einer Gruppe arbeitet.

Wie funktioniert es?

In diesem Abschnitt möchte ich klären für was die einzelnen Bestandteile zuständig sind.

Model:

Im Model befindet sich jegliche Programmlogik, darunter versteht man die verarbeitung von Daten, sei es um Berechnungen anzustellen oder einen Text zu filtern. Wenn man jetzt ein Programm auf mehreren Platformen realieseren möchte, kann man dank diesem Pattern die Logik nur einmal schreiben und sie dann immer wieder verwenden.

View:

Die View ist für jegliche Darstellung der Daten zuständig. Sie verwalted die Gui( Graphische Benutzeroberfläche). In Java gehen darunter jegliche librarys wie swing, awt oder das neuste Kind JavaFx.

Controller:

Der Controller steuert das ganze. Er ist für die Steuerung verantwortlich. Das heisst er nimmt jegliche Benutzereingaben oder mehr abstract gesagt signale entgegen und verarbeited diese. Die werden an das Model übergeben, unsere Datan werden angepasst und die Gui wir upgadated mit den neuen Daten.

Wieso benutzt man es?

Wie schon vorher erwähnt versteht man das MVC pattern als einen Bestandteil der professionellen Softwareentwicklung.

In Verbindung mit Java

Jetzt kommen wir zu unserem Beispiel.

Wir möchten ein Programm realisieren das mit dem MVC pattern arbeited.

Und was soll dieses Porgramm können?

Nun, machen wir es doch so einfach wie möglich um uns auf das Hauptthema zu konzentrieren.

Unser kleines Java-Programm so anhand von einem click Hallo Welt schreiben.

Zuerst aber sollten wir unsere Packages auch dementsprechend strukturieren, das ganze sollte so aussehen:

Gut jetzt fangen wir mit dem simplen Model an. Für diese Applikation werden wir nur eines brauchen.

Nichts weltbewägendes.

Das Model muss aber von Observable erben. Und wie wir sehen gibt es uns den String "Hallo Welt" zurück. Wichtig ist noch das wir bei jeder veränderung der zu anzuzeigenden Daten immer den Observer benachrichtigen müssen. Mit den zwie Zeile, this.setChanged(); und this.notifyObservers();

Jetzt gehen wir rüber zu unserem View. Dort fügen wir ein JLabel ein und bennen es halloText.

Und natürlich auch einen Button, den halloButton.

So sollte es aussehen.

Die Klasse muss so angepasst werden, dass sie Observer implementiert. Dadurch muss sie auch die Methode update überschreiben.

Und natürlich unsere update Methode:

Wir kasten das Observable objekt nach unserem Model und updaten quasi den Text unsere Labels.

Natürlich müssen wir auf die reaktion irgendwie reagiere, Dafür brauchen wir einen Controller.

Jetzt müssen wir das View noch einmal bearbeiten bevor wir alles verknüpfen, wir brauchn dort eine Methode die unseren Controller registriert. Nennen wir sie auch gleich "registerController".

Zu guter letzt müssen wir noch alles in der main Methode verknüpfen und dan ist es schon fertig.

Der Code sieht so aus:

Jetzt funktioniert unsere Applikation.