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

 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.

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);
    }
}

 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;
}

 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("***  ***");
    }

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

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");

} 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); } } }

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

Anbei zwei Youtube Videos zur Installation und Konfiguration

• Youtube-video zum Installieren
• Youtube-video zum Konfigurieren von Github (Modifizieren Sie diesen Code besser nicht. Kopieren Sie sich Ihn bei Bedarf in Ihr Arbeitsprojekt)

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:

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.

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.

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!

 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.

Anbei einige Befehlsabkürzungen in Eclipse und Netbeans