12. Begleitende Themen

12. Begleitende Themen

 Java und andere Frameworks

Stefan Schneider Thu, 08/26/2010 - 15:28

12.1 Java API

12.1 Java API

Das Java API ist eine plattformunabhängige Bibliothek die zum Javalaufzeitsystem gehört. Das Java API ist ein wichtiger Grund für die Popularität von Java. Man findet hier tausende von Klassen die bekannte Probleme korrekt und effizient lösen. Hieraus ergeben sich eine Reihe von Vorteilen

  • die Produktivität steigt
  • der selbstimplementierte Code wird geringer
    • die Qualität steigt
    • Testaufwände sinken
    • der Transport des Codes vereinfacht sich
  • die Klassen im Java API sind hocheffizient implementiert und untertützen oft zusätzliche Konzepte wie
    • Internationalisierung
    • Multithreading (Nebenläufigkeit)
  • Die Verwendung dieser Klassen garantiert auch, dass die Anwendungen auf den unterschiedlichsten Plattformen laufen.

Der beste Zugang zum Java API findet über die online Dokumentation von JDK Standard Edition 7  statt.

Vorsicht: Will man Anwendungen schreiben, die auch mit älteren JDKs funktionieren sollen so sollte man sich an die Schnittstellen der Klassen der älteren JDKs halten.

Das API wächst von Version zu Version und enthält eventuell Klassen und Methoden die in einer älteren Version von Java nicht enthalten sind.

Im Folgenden werden einige ausgewählte Klassen und Methoden des Java API vorgestellt. Die Liste ist nicht vollständig, sie enthält nützliche Klassen die im Rahmen dieses Kurses verwendet werden:

Anonymous (not verified) Thu, 10/20/2011 - 14:14

12.1.1 Konsolen Ein- und Ausgabe

12.1.1 Konsolen Ein- und Ausgabe

Konsolenausgabe mit System.out

Die Klasse System gehört zum Paket java.lang und muss nicht mit einem Importbefehl deklariert werden. Man kann sie direkt benutzen. das Attribut System.out ist eine Instanz der Klasse PrintStream. Es erlaubt Ausgaben auf der Konsole in den folgenden Varianten:

  • System.out.println(a): a kann ein beliebiger Typ sein. Am Ende der Zeile wird ein Zeilenumbruch eingefügt. Die nächste Konsolenausgabe wird in einer neuen Zeile beginnen.
  • System.out.print(a): a kann ein beliebiger Typ sein. Am Ende der Zeile wird kein Zeilenumbruch angefügt. Man kann durch mehrere Aufrufe Ausgaben in der gleichen Zeile durchführen.
  • System.out.printf(formatString,a): a kann ein beliebiger Typ sein.Der String formatString erlaubt die Formatierung des Objekts a.
  • System.out.flush(): Stellt sicher das die gesamte Ausgabe auch gedruckt wird. Daten werden oft in einem "Stream" gepuffert da einzelnes abarbeiten der Daten ineffizient ist.

Konsoleneingaben mit System.in

Einlesen eines Texts mit Hilfe von System.in und eines InputStreamReader. Dies geschieht am besten mit einer eigenen Methode:

import java.io;
...
public static String StringLesen (){
     // liest einen vom Benutzer eingegebenen Text (String) ein
      BufferedReader keyboard = 
         new BufferedReader( new InputStreamReader(System.in));
      try {
         return keyboard.readLine();
      } catch (IOException e) {
         throw new RuntimeException( e );
      }
}

Konsoleneingaben mit java.util.Scanner

Die Klasse Scanner erlaubt das einfache lesen von primitiven Typen und Zeichenketten mit Hilfe regulärer Ausdrücke.

Man kann z.Bsp eine Ganzzahl(Integer) wie folgt einlesen:

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

Der Scanner kann auch mit anderen Begrenzungen als Leerzeichen umgehen. Hier ein Beispiel mit dem Text "Trenner" als Begrenzung:

String input = "47 Trenner 11 Trenner Montag Trenner Dienstag Trenner";
     Scanner s = new Scanner(input).useDelimiter("\\s*Trenner\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close();

Wird das folgende Ergebnis liefern:

47
11
Montag
Dienstag

Parsen von Übergabeparametern mit einer eigenen Methode

Im folgenden Beispiel wird gezeigt wie man eine beliebige Anzahl von Eingabeparameter in einer eigenen Methode einliest und in Ganzzahlen umwandelt.

public class MethodenDemo {

    public static void main(String[] args) {

        int[] zahlenFeld;
        zahlenFeld = ganzZahlenEingabe(args);
        System.out.println(args.length + " arguments found");
        for (int i = 0; i < zahlenFeld.length; i++) {
            System.out.println("zahlenFeld[" + i + "] = " + zahlenFeld[i]);
        }
    }

    public static int[] ganzZahlenEingabe(String[] myArgs) {
        int[] z = new int[myArgs.length];
        if (myArgs.length > 0) {
            try {
                for (int i = 0; i < myArgs.length; i++) {
                    z[i] = Integer.parseInt(myArgs[i]);
                }
            } catch (NumberFormatException e) {
                System.err.println("Input Error: " + e.getMessage());
                System.exit(1);
            }
        }
        return z;
    }

}

Das Programm erzeugt die folgenden Ausgaben:

$ java MethodenDemo 33 22 11
3 arguments found
zahlenFeld[0] = 33
zahlenFeld[1] = 22
zahlenFeld[2] = 11
Stefan Schneider Thu, 08/26/2010 - 15:45

12.1.2 Swing

12.1.2 Swing

 Die folgenden Seiten zeigen einen stark vereinfachten Überblick über die wichtigsten Swing Klassen und Methoden. Es werden hier nur die Klassen und Methoden dokumentiert, die im Rahmen des Kurses benötigt werden.

Stefan Schneider Sun, 01/23/2011 - 12:41

JFrame

JFrame

 Die Klasse JFrame erlaubt das Erzeugen von eigenen Fenstern für eine Javaanwendung.

Die API Dokumentation zur Klasse JFrame enthält die vollständige Dokumentation aller Methoden dieser Klasse.

Im Folgenden werden die wichtigsten Methoden (für den Kontext des Kurses) in ihrer natürlichen Benutzungsreihenfolge vorgestellt.

JFrame Übersicht
Methode Beschreibung Geerbt von
Konstruktor: JFrame() Erzeugen eines (noch) unsichtbaren Fensters ohne einen Titel -
Konstruktor: JFrame(String title) Erzeugen eines (noch) unsichtbaren Fensters mit einem Titel -
void setSize(int breite, int hoehe) Setzen der Fenstergröße durch Breite und Höhe in Pixel java.awt.Window
setLayout(LayoutManager manager) Durch das Setzen eines Layout Managers wird die Anordnung der Komponenten vorbestimmt  -
Component add(Component comp) Hinzufügen einer Komponente zum Container  java.awt.Container 
setJMenuBar(JMenuVar  menubar) Hinzufügen einer Menüleiste zum Fenster -
setDefaultCloseOperation(int Operation) Aktion die beim Schließen des Fensters geschieht. Mögliche Konstanten als Parameter: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, EXIT_ON_CLOSE -
pack() Berechnen des Layouts des Fensters java.awt.Window 
setVisible(boolean visible) Erlaubt ein Fenster anzuzeigen oder auszublenden java.awt.WIndow

 

Beispiel

... eines sehr einfachen Fensters welches mit der Klasse JFrame erzeugt wurde:

import javax.swing.JFrame;
import javax.swing.JLabel; ... JFrame hf = new JFrame();
// 1. Gewünschte Größe setzen
// 1. Parameter: horizontale Größe in Pixel
// 2. Parameter: vertikale Größe
hf.setSize(220,230); // Setzen des Titels
hf.setTitle("Java Anwendung");
// Setzen des Feldes mitdem Text "Mustertext"
hf.add(new JLabel("Mustertext")); // Beim Schliessen wird das Programm beendet
hf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Sas JFrame sichtbar machen
hf.setVisible(true);

Ergibt das folgende Fenster:

Anmerkung: Das hier gezeigte Fenster benutzt das Standard "Look and Feel" von MacOS. Die Rahmendekoration sieht bei anderen Betriebssystemen bzw. anderen "Loak and Feel" Themen anders aus. Der oben gezeigt Code ist jedoch plattformneutral.

Stefan Schneider Sun, 01/23/2011 - 12:46

JMenuBar, JMenu, JMenuItem

JMenuBar, JMenu, JMenuItem

 Die Klassen JMenuBar, JMenu, JMenuItem , erlauben Konfiguration von Menüleisten, Pulldownmenüs und Menülisteneinträge für Fenster die mit JFrame erzeugt wurden.

Im Folgenden werden die wichtigsten Methoden (für den Kontext dieses Kurses) aufgeführt. Die obengenannten Klassen sind sehr viel mächtiger als hier beschrieben. Sie haben zusätzliche Methoden für:

  • Lokalisierung
  • unterschiedliche Arten von Menüeinträgen
  • konfigurierbares Look and Feel
  • Untermenüs
  • markieren von Einträgen
  • Anklicken durch Buchstaben Abkürzungen der Tastatur
  • etc.

Die Klasse JMenuBar

JMenuBar
Methode Beschreibung Geerbt von
Konstruktor: JMenuBar() Erzeugen einer Menüleiste für ein JFrame Fenster -
JMenu add(JMenu c) Hinzufügen eines Menüs zur Leiste -

Die Klasse JMenu

JMenu
Methode Beschreibung Geerbt von
Konstruktor: JMenu() Erzeugen einer Menüspalte am Ende der Menüleiste -
Konstruktor: JMenu(String title) Erzeugen einer Menüspalte mit Titel am Ende der Menüleiste -
JMenuItem add(JMenuItem c) Hinzufügen eines Menüeintrags am Ende des Menüs -

 

Die Klasse JMenuItem

JMenu
Methode Beschreibung Geerbt von
Konstruktor: JMenuItem(String text) Erzeugen eines Menüeintrags mit einem gegebenen Text -
void addActionListener(ActionListener l) Registrieren eines Listeners der aufgerufen wird wenn der Menülisteneintrag geklickt wird java.swingx.AbstractButton
void  setEnabled(boolean) Anzeigen oder ausblenden eines Menülisteneintrags -

Beispiel

... Menüs mit einem einzigen Eintrag :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;    
import javax.swing.JMenu;  
import javax.swing.JMenuBar;  
import javax.swing.JMenuItem;
... 
JFrame hf = new JFrame();
JMenuBar menueleiste;
JMenu ablageMenue;
JMenuItem beendenMenueEintrag;
menueleiste = new JMenuBar();
ablageMenue = new JMenu("Ablage");
beendenMenueEintrag = new JMenuItem("Beenden");
beendenMenueEintrag.addActionListener(this);
beendenMenueEintrag.setEnabled(true);

ablageMenue.add(beendenMenueEintrag);
menueleiste.add(ablageMenue);

hf.setJMenuBar(menueleiste);
hf.setVisible(true);

Einen einfachen Actionlistener kann man als Klasse mit der folgenden Methode implementieren:


    public void actionPerformed(ActionEvent e) {
JMenuItem source = (JMenuItem) (e.getSource());
                if (source == beendenMenueEintrag)
                    System.exit(0);
}

beendenMenueEintrag muss hier auf das gleiche Objekt wie bei der obigen Erzeugung der Menüleiste zeigen. Der Actionlistener beendet die Anwendung bei Aufruf!

Hierdurch ergibt sich das folgende Fenster:

Anmerkung: Das hier gezeigt Fenster benutzt das Standard "Look and Feel" von MacOS. Die Rahmendekoration sieht bei anderen Betriebssystemen bzw. anderen "Look and Feel" Themen anders aus. Der oben gezeigt Code ist jedoch plattformneutral.

Stefan Schneider Sun, 01/23/2011 - 19:22

12.1.3 GUI IO (Swing)

12.1.3 GUI IO (Swing)

Java bietet mit AWT (Another Window Tool Kit) und Swing reichhaltige Bibliotheken zum Entwurf von graphischen Benutzeroberflächen.

Hinweis: "Swing" (Schaukel) ist der Projektname. Swing ist Teil der Java Foundation Classes (JFC).

Einfache grafische "Swing" Oberfläche

Das folgende Beispiel dient als einfaches Rahmenprogramm für Text Ein- und Ausgaben.

Es übernimmt die Erzeugung eines Fensters mit:

  • Eingabefeld für einen Text
  • Ausgabefeld für einen Text
  • 3 Buttons zum Verarbeiten des Texts in drei Methoden

Der eigene Algorithmus wird in der Methode public String executeOperation1(String) oder der beiden anderen executeOpteration Methoden implementiert.

Hierzu werden die folgenden Swing-Klassen verwendet

  • JFrame: Erzeugen eines Fensters
  • JLabel: Erzeugen eines festen Texts
  • JTextField: Textfelder zur Ein- und Ausgabe von Texten
  • JButton: Knopf(Button) zum Triggern einer Aktion
  • ActionListener:Ausführen einer Aktion. Hier als anonyme Klasse implementiert.

Das erscheinende Fenster sieht wie folgt aus:

Das Fenster nach einer Texteingabe ("Eingabe"):

Das Fenster nach dem Drücken des Knopf "Do twice". Es wurde die Methode executeOperation2() aufgerufen:

Die Methoden executeOperation1(), executeOperation2(), executeOperation3() erlauben eine Implementierung des eigenen Algorithmus. Der erforderliche String in der Rückgabe wird dann im Fenster angezeigt.

Anbei das Beispielprogramm mit der Klasse DemoFrame:

package s2.swing;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;

public class DemoFrame extends javax.swing.JFrame {
    private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;

                      
    private void initComponents() {
        jLabel1 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jTextField2 = new javax.swing.JTextField();

        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();
        
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("My first JFrame");
        jLabel1.setText("Input Text:");
        jTextField1.setText("Input");
        jTextField2.setText("Output");
        jTextField2.setEditable(false);

        jButton1.setText("Do once:");
        jButton2.setText("Do twice:");
        jButton3.setText("Do three times:");

        JPanel radioPanel = new JPanel(new GridLayout(1, 0));
        radioPanel.add(jButton1);
        radioPanel.add(jButton2);
        radioPanel.add(jButton3);

        jButton1.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton1)
                        jTextField2.setText(
                                executeOperation1(jTextField1.getText()));
                    }
                }
          );
          jButton2.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton2)
                        jTextField2.setText(
                                executeOperation2(jTextField1.getText()));
                    }
                }
          );
          jButton3.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton3)
                        jTextField2.setText(
                                executeOperation3(jTextField1.getText()));
                    }
                }
          );

        this.setBounds(300, 300, 200, 30);
        setMinimumSize(new Dimension(200,30));
        getContentPane().add(jLabel1, BorderLayout.WEST);
        getContentPane().add(jTextField1, BorderLayout.CENTER);
        getContentPane().add(radioPanel, BorderLayout.NORTH);
        getContentPane().add(jTextField2, BorderLayout.SOUTH);
        pack();
   }
    public DemoFrame() {
        initComponents();
    }

    public static void main(String[] args) {
 
        DemoFrame f1 = new DemoFrame();
        f1.setVisible(true);

    }

    public String executeOperation1(String s) {
        // Add Application logic here:
        String result = "Button 1:" + s;
        return (result) ;
    }
    public String executeOperation2(String s) {
        // Add Application logic here:
        String result = "Button 2:" + s + s;
        return (result) ;
    }
    public String executeOperation3(String s) {
        // Add Application logic here:
        String result = "Button 3:" + s + s +s;
        return (result) ;
    }
}

Als Download in GitHub.

Eine Swingoberfläche zum Erfassen von drei Texten

Die Klasse DemoFrame1 stellt drei Eingabefelder zum Erfassen von Texten zur Verfügung und erlaubt das Starten von 3 Operationen:

Implementierung der Klasse DemoFrame 1

package s2.swing;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
 *
 * @author s@scalingbits.com
 */
public class DemoFrame1 extends javax.swing.JFrame {

    private ButtonGroup buttonGroup1;
    private JPanel jPanel1;
    private JLabel jLabel1;
    private JTextField jTextFieldin[];
    private JTextField jTextField2;
    private JButton jButton1;
    private JButton jButton2;
    private JButton jButton3;
    /**
     * Anzahl der Eingabefelder
     */
    private int inFields = 3;

    /**
     * Initialisieren aller Komponenten
     */
    private void initComponents() {
        jLabel1 = new JLabel();
        jTextFieldin = new JTextField[inFields];
        for (int i = 0; i < inFields; i++) {
            jTextFieldin[i] = new JTextField();
        }
        jTextField2 = new JTextField();

        jButton1 = new JButton();
        jButton2 = new JButton();
        jButton3 = new JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("My second JFrame");

        jLabel1.setText("Input Text:");

        // Belegen alle Eingabefelder mit Standwerten
        for (int i = 0; i < inFields; i++) {
            jTextFieldin[i].setText("Input" + i);
        }
        // Belegen des Augabefeldes mit Standartwert
        jTextField2.setText("Output");
        jTextField2.setEditable(false);

        // Erzeugen dreier Buttons
        jButton1.setText("Do once:");
        jButton2.setText("Do twice:");
        jButton3.setText("Do three times:");

        // Ezeugen einer Datenstruktur(Panel) die drei Buttons aufnimmt
        JPanel radioPanel = new JPanel(new GridLayout(1, 0));
        radioPanel.add(jButton1);
        radioPanel.add(jButton2);
        radioPanel.add(jButton3);

        // Führe Operation 1 aus wenn Button 1 gedrückt wird
        jButton1.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == jButton1) {
                    jTextField2.setText(executeOperation1(
                            jTextFieldin[0].getText(),
                            jTextFieldin[1].getText(),
                            jTextFieldin[2].getText()));
                }
            }
        });

        // Führe Operation 2 aus wenn Button 2 gedrückt wird
        jButton2.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == jButton2) {
                    jTextField2.setText(executeOperation2(
                            jTextFieldin[0].getText(),
                            jTextFieldin[1].getText(),
                            jTextFieldin[2].getText()));
                }
            }
        });

        // Führe Operation 3 aus wenn Button 3 gedrückt wird
        jButton3.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == jButton3) {
                    jTextField2.setText(executeOperation3(
                            jTextFieldin[0].getText(),
                            jTextFieldin[1].getText(),
                            jTextFieldin[2].getText()));
                }
            }
        });

        // Allgemeine Konfiguration des Fensters
        this.setBounds(300, 300, 200, 30);
        setMinimumSize(new Dimension(200, 30));
        // Einfügen der Eingabeaufforderung links
        getContentPane().add(jLabel1, BorderLayout.WEST);
        // Panel zum verwalten von mehreren Eingabefelder
        JPanel inputPanel = new JPanel(new GridLayout(inFields, 0));
        for (int i = 0; i < inFields; i++) {
            inputPanel.add(jTextFieldin[i]);
        }
        // Einfügen des Panels mit Eingabefeldern in der Mitte
        getContentPane().add(inputPanel, BorderLayout.CENTER);
        // Einfügen des Panels mit Buttons oben
        getContentPane().add(radioPanel, BorderLayout.NORTH);
        // Einfügen der Ausgabezeile unten
        getContentPane().add(jTextField2, BorderLayout.SOUTH);
        pack();
    }

    /**
     * Initialierung alle Komponenten
     */
    public DemoFrame1() {
        initComponents();
    }

    /**
     * Hauptprogramm: Erzeuge eine Instanz von DemoFrame1 und zeige sie an
     * @param args
     */
    public static void main(String[] args) {

        DemoFrame1 f1 = new DemoFrame1();
        f1.setVisible(true);
    }

    /**
     * Führe Operation 1 aus (Button 1 wurde gedrückt)
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public String executeOperation1(String s1, String s2, String s3) {
        // Add Application logic here:
        String result = "Button 1:" + s1 + s2 + s3;
        return (result);
    }

    /**
     * Führe Operation 2 aus (Button 2 wurde gedrückt)
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public String executeOperation2(String s1, String s2, String s3) {
        // Add Application logic here:
        String result = "Button 2:" + s1 + s2 + s3;
        return (result);
    }

    /**
     * Führe Operation 3 aus (Button 3 wurde gedrückt)
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public String executeOperation3(String s1, String s2, String s3) {
        // Add Application logic here:
        String result = "Button 3:" + s1 + s2 + s3;
        return (result);
    }
}

Stefan Schneider Sun, 10/10/2010 - 21:28

12.1.4 Math

12.1.4 Math

 Die Math Klasse enthält alle mathematischen Hilfsroutinen wie z.Bsp.

public static double random(): Zufallszahlengenerator

...erzeugt zufällige Fliesskommazahlen im Intervall von 0.0 bis 1.0

Die folgende Methode erzeugt ein beliebig großes Feld von zufälligen Ganzzahlen in einem bestimmten Bereich (range)

public static int[] createRandom(int size, int range) {
   int[] array1 = new int[size];
   for (int i=0; i<size;i++) 
       array1[i] = (int)(Math.random()*range);
   return array1;
}
Stefan Schneider Mon, 10/11/2010 - 16:48

12.1.5 Systemresourcencheck mit der Klasse Runtime

12.1.5 Systemresourcencheck mit der Klasse Runtime

 Die Java Runtime bietet die Möglichkeit die folgenden Systemwerte auszulesen:

  • verfügbare Prozessoren
  • freier Speicher
  • maximal verfügbarer Speicher
  • gesamter allokierter Speicher der VM

Die Klasse bietet ebenfalls die Möglichkeit eine Reihe von Operationen zu starten:

  • expliziter Aufruf eines "Garbage Collectors"
  • expliziter Aufruf des Finalizers
  • externer Aufruf eines Betriebssystemkommandos
  • beenden des Prozesses
  • laden von dynamischen Bibliotheken

Warnung: Alle aufgeführten Operationen haben erheblichen Einfluss auf die gesamte VM. Im normalen Entwicklungsumfeld größerer Anwendungen führen die oben genannten Operationen in der Regel zu erheblichen negativen Seiteneffekten für Sicherheit, Stabilität und Performanz von Anwendungen.

Die folgende Methode nutzt die Klasse Runtime um die wichtigsten Werte des Prozesses auszulesen:

public static void systemStatus(){
        Runtime r = Runtime.getRuntime();
        System.out.println("*** System Status ***");
        System.out.println("Prozessoren :       " + r.availableProcessors());
        System.out.println("Freier Speicher:    " + r.freeMemory());
        System.out.println("Maximaler Speicher: " + r.maxMemory());
        System.out.println("Gesamter Speicher:  " + r.totalMemory());
        System.out.println("***  ***");
    }
Stefan Schneider Mon, 10/11/2010 - 12:47

12.1.6 Collator (Vergleichen von Zeichenketten)

12.1.6 Collator (Vergleichen von Zeichenketten)

Der Vergleich von Zeichenketten hängt oft von der lexikographischen Ordnung ab. Die lexikographische Ordnung selbst hängt wieder von der Region ab. Java bietet hierfür die Klasse Collator (Collation engl. : Der Textvergleich) an, die Zeichenketten nach bestimmten Kriterien sortieren kann. Die Methode compare() erlaubt das Vergleichen zweier Zeichenketten.

Zur Bestimmung der Sortierreihenfolge wird die Klasse java.util.Locale benötigt, die die entsprechende Region und deren Sprache bestimmt.

Das Vorgehen zum Konfigurieren und Vergleichen von Zeichenketten ist das folgende:

  • Auswahl der gewünschten Region und Sprache (Locale). Z.Bsp. Locale.GERMANY
  • Bestimmung der gewünschten Sortierstärke für den Collator ( setStrength() )
    • Collator.PRIMARY : nur die grundlegende Abfolge  wie z.Bsp 'a' und 'b' werden berücksichtigt
    • Collator.SECONDARY: Unterschiede wie z.Bsp. 'a' und 'ä' werden berücksichtigt falls nach den Regeln der Kategorie "Primary" kein Unterschied existiert.
    • Collator.TERTIARY: Unterschiede wie z. Bsp. 'a' und 'A' werden berücksichtigt falls nach den Regeln der Kategorie "Secondary" kein Unterschied existiert
  • Vergleichen der Zeichenketten mit compare() oder equals()

Beispiel

Vergleichen von Vor- und Nachnamen einer Person nach deutschen Sortierregeln inklusive besonderer deutscher Zeichen mit der Methode compare() der Klasse Collator.

package s2.sort;


import java.text.Collator;

import java.util.Locale;


public class Person{

   private String nachname;

   private String vorname;

private static Locale myLocale = Locale.GERMANY;


public boolean istKleinerAls(Person p) {

boolean kleiner = false;

   Collator myCollator = Collator.getInstance(myLocale);
// Beim Vergleich auch Gross- und Kleinschreibung unterscheiden

   myCollator.setStrength(Collator.TERTIARY);

   // Konfiguriere die Sortierordnung

   if (myCollator.compare(nachname, p.nachname) < 0) {

      kleiner = true;

   } else if (myCollator.compare(nachname, p.nachname) == 0) {

      kleiner = myCollator.compare(vorname, p.vorname) < 0;

}

   return kleiner;
}
}

Lauffähiges Programm zum Testen von Locales und Sortierordnungen

Das Programm Lexikographisch akzeptiert die folgende Kommandozeilensyntax:

java s2.sort.Lexikographisch String1 String2 [[German|French|UK|US] [PRIMARY|SECONDARY|TERTIARY]]

Beispiele


 
$ java s2.sort.Lexikographisch SPULE Spüle German PRIMARY
SPULE ist gleich Spüle
$ java s2.sort.Lexikographisch SPULE Spüle German SECONDARY
SPULE vor Spüle
$ java s2.sort.Lexikographisch Schmidt SCHMIDT German PRIMARY
Schmidt ist gleich SCHMIDT
$ java s2.sort.Lexikographisch Schmidt SCHMIDT German SECONDARY
Schmidt ist gleich SCHMIDT
$ java s2.sort.Lexikographisch Schmidt SCHMIDT German TERTIARY
Schmidt vor SCHMIDT

Quellcode

package Kurs2.Sort;
import java.text.Collator;
import java.util.Locale;
/**
 *
 * @author sschneid
 */
public class Lexikographisch {
    public static void main(String[] args) {
        String s1 = "Test1";
        String s2 = "Test2";
        Locale myLocale = Locale.GERMANY;
        int strength = Collator.TERTIARY;
        if (args.length < 2) {
            System.out.println("Erforderliche Mindestparameter: String1 String2");
            System.out.println("Syntax: java Kurs2.Sort.Lexikographisch "
                    + "String1 String2 "
                    + "[[German|French|UK|US] [PRIMARY|SECONDARY|TERTIARY]]");

} else { s1 = args[0]; s2 = args[1]; } if (args.length >= 3) { String loc = args[2]; if (loc.equalsIgnoreCase("German") || loc.equalsIgnoreCase("Germany")) { myLocale = Locale.GERMAN; } if (loc.equalsIgnoreCase("France") || loc.equalsIgnoreCase("French")) { myLocale = Locale.FRENCH; } if (loc.equalsIgnoreCase("US")) { myLocale = Locale.US; } if (loc.equalsIgnoreCase("UK") || loc.equalsIgnoreCase("English")) { myLocale = Locale.UK; } // Add more locales here... } if (args.length >= 4) { String s = args[3]; if (s.equalsIgnoreCase("PRIMARY")) { strength = Collator.PRIMARY; } if (s.equalsIgnoreCase("SECONDARY")) { strength = Collator.SECONDARY; } if (s.equalsIgnoreCase("TERTIARY")) { strength = Collator.TERTIARY; } } vergleich(s1, s2, myLocale, strength); } private static void vergleich(String s1, String s2, Locale myLocale, int strength) { Collator myCollator = Collator.getInstance(myLocale); // Beim Vergleich auch Gross- und Kleinschreibung unterscheiden // Konfiguriere die Sortierordnung myCollator.setStrength(strength); if (myCollator.compare(s1, s2) == 0) { System.out.println(s1 + " ist gleich " + s2); } if (myCollator.compare(s1, s2) < 0) { System.out.println(s1 + " vor " + s2); } if (myCollator.compare(s1, s2) > 0) { System.out.println(s2 + " vor " + s1); } } }

Stefan Schneider Tue, 03/29/2011 - 20:32

12.2 Kodierstil

12.2 Kodierstil

Duke auf Motorrad

Es gibt ein paar wichtige Regeln um Code auch in Zukunft noch verstehen zu können. In der Javawelt gelten die folgenden Konventionen:

  • Camelcase verwenden
  • Klassennamen groß schreiben
  • Methodennnamen klein schreiben
  • Variablen klein schreiben
  • Konstanten werden vollständig in Großbuchstaben geschrieben
  • An schwierigen Stellen Kommentare schreiben
  • Code einrücken bei jedem neuen Block
    • Geschweifte Blockklammern {} übereinander scheiben wenn möglich

Siehe auch Wikibooks: Standard für Variablen und Bezeichner

Stefan Schneider Thu, 08/26/2010 - 16:34

12.3 Entwicklungsumgebungen

12.3 Entwicklungsumgebungen

Hier werden nur kostenlose Entwicklungsumgebungen vorgestellt.

Das Ziel ist es den Studenten eine Orientierung für den Programmierkurs zu geben. Die Leistung kommerziell verfügbarer Werkzeuge soll hiermit nicht geschmälert werden. 

wikipedia.org verfügt über eine gute Sammlung von Java Entwicklungsumgebungen.

gedit: Ein intelligenter Texteditor

  • Text Editor des Gnome Projekt
  • kostenlos
  • Eigenschaften
    • Syntax Highlighting
  • Der Editor ist keine eigentliche Javaentwicklungsumgebung da er kein Übersetzen, debuggen etc. unterstützt
  • Für den Kurs sehr gut geeignet

 gedit Screen Shot

bluej.org

Eclipse

Stefan Schneider Thu, 08/26/2010 - 19:53

12.3.1 Intellij

12.3.1 Intellij

Meine persönlichen Preferenz ist aktuell IntelliJ IDEA Community version für Windows und Mac.

Anbei zwei Youtube Videos zur Installation und Konfiguration

Es gibt den Quellcode zur Vorlesung bei Github. Das zweite Video zeigt wie man sich diesen Quellcode in einem eigenen Projekt verfügbar macht. Der Quellcode in diesem Archiv wird immer mal wieder angepasst und erneuert. Die html Seiten dieses Webservers sind eher hintendran. Sie müssen händisch gepflegt werden...

Der Code in Ihrem Intellij wird aber nicht automatisch erneuert. Sie müssen sich die neuen Codeänderungen mit einem "Pull Request" nachträglich herunterladen.

Dies geschieht in IntelliJ durch die folgenden Schritte:

Projektliste rechts klick Führen sie einen Maus-Rechts-Klick auf dem Namen Ihres Projekts aus. Hier "dhbwjava". Ein Menü erscheint.
Wählen sie git -> Repository->Pull aus, um einen "Pull Request" einzuleiten. Auswahl git Pull
Wählen Sie den "master" Zweig aus. Es kann bei Github noch andere Codezweige (Englisch: branches) geben. Das ist hier nicht der Fall. Klicken Sie auf den "Pull" Knopf. Auswahl von master

Jetzt gibt es zwei Szenarios...

  • Das einfache Szenario: Sie haben in diesem Projekt nie etwas geändert!
    • Willigen Sie in alles ein, ihr Code wird eneuert und aktualisiert.
    • Fertig!
  • Das komplizierte Szenario: Sie haben den Code früher einmal modifiziert
    • IntelliJ erkennt Ihre Änderungen und will Sie nicht so einfach überschreiben. IntelliJ will den Code abmischen (auf Englisch: Mergen) damit Ihre Änderungen nicht verloren gehen
    • Sie müssen jetzt eine Entscheidung treffen:
      • Ihr geänderter Code darf überschrieben werden!
        • Erlauben Sie IntelliJ das Überschreiben.
        • Weinen Sie Ihrem Code eine Träne nach.
        • Fertig
      • Sie möchten Ihren geänderten Code behalten
        • Kochen Sie eine Kanne eines legalen Suchtgetränks, streichen Sie alle anderen Termine des Tages.
        • Besorgen Sie sich einen dunkelbraunen oder schwarzen Gürtel von git...
        • IntelliJ wird Ihnen jetzt alle Änderungen der neuen Version und Ihre Änderungen vorlegen. Sie müssen für jede Änderung entscheiden, welche Sie behalten möchten.
        • Das ganze wird sich für jede neue Version auf Github wiederholen.
          • Sie können aber auch Ihrem Referenten Ihre Änderungen mit einem "Merge Request" empfehlen. Vielleicht akzeptiert er ihn...
          • Hierfür benötigen Sie ein Konto bei github und ein eigenes github-Projekt.
          • Sie müssen dann Ihren Code bei zukünftigen Versionen nicht mehr abmischen
        • Fertig!

 

Stefan Schneider Mon, 01/25/2021 - 16:58

12.3.2 Entscheidungshilfe: IntelliJ oder Eclipse?

12.3.2 Entscheidungshilfe: IntelliJ oder Eclipse?

 Anbei eine Entscheidungshilfe für die Teilnehmer der Vorlesung der dualen Hochschule.

Grundsätzliches:

  1. Man benötigt für den Kurs nicht unbedingt eine hochentwicklete Enwicklungsumgebung. Man benötigt streng genommen nur die Installation des Java JDK, ein Texteditor und Kommandozeilenzugriff
  2. Jede Entwicklungsumgebung die zumindestens Pakete unterstützt ist ausreichend für den Kurs
  3. Es ist durchaus ein gute Idee sich mehrere Entwicklungsumgebungen anszuschauen um die zu wählen die einem am besten gefällt.
  4. Die Benutzung der graphischen Oberflächen von Eclipse und Netbeans im Rahmen des Kurses ist fast identisch.

Typischerweise stellt sich für fast jeden Javaentwickler irgendwann die Frage:

IntelliJ oder Eclipse?

Diese Frage können sie recht gut nach den folgenden Kriterien beantworten:

Ich verwende schon Entwicklungsumgebung XY

Bleiben Sie bei Ihrer Entwicklungsumgebung XY.

Mein Unternehmen verwendet bevorzugt die Entwicklungsumgebung XY

Benutzen Sie die Umgebung XY und fragen Sie einen Kollegen nach der firmenspezifischen Installation (Erweiterungen!). Sie werden wahrscheinlich später in diesem Kontext arbeiten.

Ich habe keine Präferenzen und ich bin Windowsbenutzer

Erwägen Sie IntelliJ. IntelliJ ist sehr gut an Windows angepasst.

Eclipse ist der Marktführer.

Ich habe keine Präferenzen und ich bin MacOS Benutzer

Erwägen Sie IntelliJ. IntelliJ bettet sich natürlicher in MacOS ein. Der Referent benutzt ebenfalls IntelliJ auf MacOS.

Softwareentwicklung ist ein völlig neues Thema für mich

Erwägen Sie IntelliJ

  • Sie sind "click" kompatibel zum Referenten
  • Der Referent kann Ihnen leichter helfen
  • Der syntaxsensitive Editor scheint etwas besser zu sein. Schreibfehler werden etwas zuverlässiger und schneller angezeigt.

Zusammenfassung

Beide Produkte sind kostenlos und für den Kurs gleichwertig. Sie installieren sich am besten in der zweiten Kurshälfte das andere Produkt und entscheiden dann selbst.

Stefan Schneider Wed, 09/04/2013 - 10:56

12.3.3 Shortcuts (Befehlsabkürzungen)

12.3.3 Shortcuts (Befehlsabkürzungen)

Anbei einige Befehlsabkürzungen in Eclipse und Netbeans

Abkürzung IntelliJ Eclipse
Referenzen   Menü:preferences ->Java->Editor->Templates
System.out.println("") sout<tab> sysout<ctrl><Leertaste>
public static void main(String[] args) {} psvm<tab>  
String    
switch   switch<ctrl><Leertaste>
main   main<ctrl><Leertaste>

 

Stefan Schneider Wed, 11/07/2012 - 17:43

12.4 Java unter Windows

12.4 Java unter Windows

Konfigurieren des Suchpfads für Kommandozeileneingaben

Im Kurs ist es notwendig Javakommandos auf der Kommandozeile aufzurufen. Auf Windows muss man entweder immer den vollen Pfad (z.Bsp. C:\Program Files\Java\jdk1.8.0_60\bin\java ) eingeben. Oder man konfiguriert Windows so, dass es im entsprechenden Verzeichnis nach diesen Befehlen sucht. Nach erfolgreicher Konfiguration kann man die Befehle java, javac, jar etc. wie folgt verwenden:

Kommanozeilenfenster

Für MacOs Anwender gibt es nichts zu tun!

Als erstes muss man das das bin Verzeichnis des JDK finden. In ihm stehen alle Programme des JDK. Man kann es an den Dateien javac.exe und javadoc.exe erkennen Ein typischer Ort kann zum Beispiel sein:

C:\Program Files\Java\jdk1.8.0_60\bin\

Dieses Verzeichnis muss zum Standardsuchpfad des Benutzers hinzugefügt werden. Bei Windows geschieht das wie folgt:

Öffnen des Control Panels

Bei Windows 2012R2 finden Sie einen Eintrag bei den "Apps" den Anwendungen

Ikone Control Panel

 

Öffnen der Systemsteuerung

Klicken Sie dann auf "System and Security"

Systemsteuerung

Klicken Sie auf "System"

Windows Systemsauswahl

 

Klicken Sie auf "Advanced system settings"

Advanced System settings Windows

Ein Dialog mit dem Titel "System Properties" erscheint.

System Properties 

 Wählen Sie hier den Button "Environment Variables"

Environment Windows

Suchen Sie hier den Eintrag "Path" in "System variables" und klicken Sie dann den "Edit" Button

Pfad variable

 

Beim Einpflegen des zusätzlichen Suchpfades ist das Folgende zu beachten

  • Die verschiedenen Verzeichnisse im Suchpfad werden mit Semikolons abgetrennt
  • Der Pfad zu den Java JDK-kommandos wird hinter den existierenden Suchverzeichnissen eingetragen. So werden Javakommandos nur dann ausgeführt wenn sie in keinem anderen Verzeichnis gefunden wurden.

Vorsicht:

  • Dies ist eine systemweite Einstellung. Eine Fehlkonfiguration wird alle Anwendungen auf dem System betreffen!
  • Ist im Pfad schon ein anderes JDK konfiguriert, können Konflikte auftreten.

Editieren PATH

 Kontrolle

Bei einem erlfogreich gepflegten Pfad kann man in einem neuen Fenster zum Beispiel die Javaversion mit dem Befehl "java -version" kontrollieren.

Kontrolle 

 Funktioiert dieser Befehl ist sichergestellt, dass ein Java JRE oder JDK installiert ist. Zum Sicherstellen, dass das JDK garantiert installiert und konfiguriert ist, muss man "javac -version" aufrufen. Der Javaübersetzer ist nur Teil des JDK.

Stefan Schneider Sun, 08/07/2011 - 16:40

12.5 Typische Fehler

12.5 Typische Fehler

System.out.print() und System.out.println()

Beide Befehle erzeugen einer Konsolenausgabe von Texten.

  • Die Methode print() lässt den Schreibzeiger an der aktuellen Position stehen. Die nächste Konsolenausgabe erfolgt in der gleichen Zeile
  • Die Methode println() (ln= Line) erzeugt am Ende des ausgegebenen Texts einen Zeilenumbruch. Die nächste Konsolenausgabe erfolgt in der nächsten Zeile.

Beispiele

Quellcode Ausgabe
System.out.print("Person: ");
System.out.println("John Doe");
System.out.println("****************");
Person: John Doe
****************

aber:

Quellcode Ausgabe
System.out.println("Person: ");
System.out.println("John Doe");
System.out.println("****************");
Person: 
John Doe
****************

String ist eine Klasse und kein Basistyp

Java kann Zeichenketten nicht als Basistypen verwalten. Hierzu verwendet Java eine Klasse mit dem Namen String. Zeichenketten werden wie Objekte behandelt

Die hat eine Reihe von Konsequenzen:

  • String ist kein Schlüsselwort
  • Variablen vom Typ String sind nur Zeiger auf Zeichenketten
    • Es gibt Situationen in denen zwei Variablen auf zwei Zeichenketten mit dem gleichen Inhalt zeigen. Dies können eventuell verschiedene Objekte sein.

Verwechslung von Zuweisungsoperator (=) und Vergleichsoperator (==)

Mit

i=j;

wird der Wert von j auf i zugewiesen. Mit

if(i==j)

werden zwei Variablen verglichen.

Zuweisungen tauchen nicht in boolschen Termen auf!

Die folgende Syntax ist korrekt:

int i=0;
int j=1;
boolean b = (i==j);

Die Boolsche Variable b wird mit false belegt da i ungleich j ist.

Stefan Schneider Sun, 12/04/2011 - 14:55

12.6 IntelliJ Installation (Windows)

12.6 IntelliJ Installation (Windows)

Installieren Sie sich die Community Edition von IntelliJ. Versionen und GUIs werden sich ändern. Die beiden Youtube Videos stammen vom September 2020

Ein paar Tipps

  • Halten Sie das Video an. Sie werden nicht so schnell tippen können...
  • Hilf ich kann die Schrift nicht lesen!
    • Stellen Sie mit dem "Zahnrad" die Auflösung hoch
    • Benutzen Sie mit dem unterbrochenen Rechteck den Gesamtschirmmodus
  • Sie verwenden einen Mac oder Linux?
    • Die Installation ist hier sinngemäß sehr, sehr ähnlich.
Stefan Schneider Tue, 09/01/2020 - 11:34

12.7 Feedback

12.7 Feedback

Feedback der Vorlesung

  Datum 2020 Teiln. 2020 Bewertung 2021 Teiln. 2021 Bewertung Kommentar
Block 1 5.10.2021     9/25 4,3

 

Block 2 14.10.2021 19 3,8 4/25 4,4

 

Block 3 21.10.2020 10/10 4,2/4,4 3/25 4,7

Mir hat gefallen:

  • Das eigenständige arbeiten mit ihrer Unterstützung falls benötigt 

  • individuelle hilfe 

  • Praxisbezug 

Ich würde das folgende anders machen:

  • .
Block 4 29.10.2020 8 3,8      
Block 5 5-6.11.2020 14/2 3,6/3,5      
Block 6 12-13.11.2020 11/11 3,7/4,4      
Block 7 20.11.2020 10 3,6      
Block 8 26-27.11.2020 9 3,7    

 

Block 9 3-4.12 2/5 4,5/4,2    

 

Block 10 10.12.2020 5 3,6    

 

Block 11            
Stefan Schneider Mon, 11/30/2020 - 11:40