Programmieren, Java & NetBeans

• Free Design (GroupLayout)

• FlowLayout

• GridLayout

• GridBagLayout

• GridBagLayout (cont.)

• BoxLayout

• NullLayout

• AbsoluteLayout

• CardLayout

• BorderLayout

• Menu

• Toolbar

• Panels (für strukturierte UIs)

• Für Mensch verständlich (für Computer vorerst nicht)
• Sehr strenge "Grammatik" ("Syntax")
• Genau definierte Befehle
• Genau definierte Liste von weiteren "reservierten Wörtern" (dürfen nicht für eigene Namen benutzt werden)
• Muss vor Ausführung auf die eine oder andere Weise in die Maschinensprache des verwendeten Computers (genauer: der CPU) übersetzt werden
• Geht aufgrund der strengen Grammatik verhältnismäßig einfach
• Wird nicht vom Programmierer selbst gemacht, sondern von einem Programm ("Compiler", "Interpreter")

• Allgemein: eine definierte Abfolge von Arbeitsschritten, die zu einem gewünschten Effekt führen soll. ("Trainingsprogramm", "Beschäftigungsprogramm", "Impfprogramm", "Ernährungsprogramm")
• Beim Programmieren: Abfolge von Befehlen, die grundsätzlich der Reihe nach abgearbeitet werden und in ihrer Gesamtheit ein bestimmtes Verhalten des Computers erwirken
• Ganze Befehlsfolgen können gewöhnlich zusammengefasst als "Prozedur", "Routine", "Methode" unter einem Namen abgespeichert und aufgerufen werden
• Inhalte (Zahlen, Texte, (Kalender-)Daten etc.) werden in "Variablen" gespeichert
• "Control-of-flow" Elemente beeinflussen den grundsätzlichen Ablauf: z.B. kann von zwei (oder mehreren) Codeblöcken nur einer (oder auch gar keiner) ausgeführt werden.
• Codeblöcke können mehrmals wiederholt werden (Schleife)
• Die Steuerung bei Auswahl (welcher Block?) oder Wiederholung (wie oft?) erfolgt letztendlich durch Variableninhalte

• Der gesamte Quellcode eines Programms wird vom "Compiler" (einem Programm) gelesen, auf Gültigkeit überprüft und in Maschinencode übersetzt. (Windows typisch: ".COM"- bzw. ".EXE-Datei")
• Das fertig übersetzte Programm liegt in einer Datei vor und wird erst nach Aufruf ausgeführt.
• Zur "Laufzeit" (=während der Programmausführung) muss nichts mehr übersetzt werden, wodurch compilierte Programme auf dem Bildschirm schneller wirken als "interpretierte" (siehe nächste Lektion)
• Vorteil: hohe Abarbeitungsgeschwindigkeit
• Nachteile:
  • Programm muss für verwendete CPU compiliert werden
    (das kann auch auf einer anderen erfolgen  "Cross Compiler")
  • Inflexibilität: Programmänderungen können zu erheblichem Zeitaufwand für das neuerliche Übersetzen führen
• Vertreter: z.B. Fortran, C

Befehlsausführung in der CPU

• Addition zweier Bits mit normalen Schaltern
• Addition von 2x4 bits mit einem Halbaddierwerk
• ALU: Andere Befehle + Steuerschaltung
• Jeder Maschinenbefehl hat einen Binärcode, unter dem er aktiviert werden kann
• 4 bits zusammenfassen => Hexcodes
• Moderne CPU: 1000e Befehle

• Der Quellcode eines Programms wird Zeile für Zeile gelesen, auf Gültigkeit überprüft und jede Zeile wird sofort ausgeführt.
• Während der Laufzeit muss jede Zeile übersetzt werden. Das verbraucht Zeit und so wirken interpretierte Programme langsamer als compilierte.
• Vorteile:
  • Flexibilität (Quellcode kann im Prinzip zur Laufzeit verändert werden)
  • Dasselbe Programm kann auf unterschiedlichen Betriebssystemen bzw. Architekturen laufen, wenn es einen Interpreter gibt
• Nachteil: langsame Abarbeitung
• Vertreter: PHP, Basic, SQL, Lisp

• Quellcode wird in ›Bytecode‹ übersetzt: die Maschinensprache einer CPU, die gar nicht im eigenen Computer eingebaut ist (aber denkbar wäre, und von Sun (dem damaligen Hersteller von Java) entwickelt wurde. Diese CPU hat jedoch nie Verbreitung erlangt).
• Eine VM musste es für die im Computer verbaute CPU geben, sonst konnte man Java schlicht nicht laufen lassen.
• Früher:
• Der Bytecode wurde dann von einem Interpreter namens "JVM" für die eigene CPU interpretiert (bzw. "jit-compiliert, s.u.").
• Vorteil: den Maschinencode einer anderen CPU zu interpretieren ist viel einfacher als Quellcode zu interpretieren, daher Laufzeitvorteil gegenüber anderen interpretierten Sprachen.
• Nachteil: im Vergleich zu compilierten Sprachen immer noch viel zu langsam.
• Heute:
  • Java-Compiler erzeugt nach wie vor Bytecode.
  • Die VM kompiliert zur Laufzeit ganze Bytecode-Blöcke, die zur späteren Verwendung (z.B. neuerlicher Aufruf, Schleifen) aufgehoben werden und führt den nun in echter Maschinensprache vorliegenden Block gleich aus.
  • Das nennt man "Just-in-time Kompilierung" (JIT)
• Vorteile:
  • Hohe Flexibilität: das compilierte Java-Programm kann von einer Computer-Architektur auf eine andere übertragen werden (und muss dort nicht neu compiliert werden)
  • Kein merkbarer Geschwindigkeitsnachteil mehr ggü. compilierten Sprachen
• Nachteile: "hardwarenahe" Programmierung ist kaum bis gar nicht möglich (z.B. Treiber)
• Andere Vertreter: 
  • .NET (mit seinen Sprachen, allen voran C#), die "Maschinensprache" dort heißt "CL" (Common Language), die Laufzeitumgebung "CLR" (Common Language Runtime)
  • Aber schon Pascal (1970er) von Niklas Wirth (ETH Zürich) mit "p-Code"

Umgebung:

• JDK und NetBeans wurden installiert

Maschinensprache

Befehlsausführung in der CPU

• Addition zweier Bits mit normalen Schaltern
• Andere Befehle
• Binärcodes
• Hexcodes
• Mnemonics

Programmiersprache

• Für Mensch verständlich (für Computer vorerst nicht)
• Sehr strenge "Grammatik" ("Syntax")
• Genau definierte Befehle
• Genau definierte Liste von weiteren "reservierten Wörtern" (dürfen nicht für eigene Namen benutzt werden)
• Muss vor Ausführung auf die eine oder andere Weise in die Maschinensprache des verwendeten Computers (genauer: der CPU) übersetzt werden
• Geht aufgrund der strengen Grammatik verhältnismäßig einfach
• Wird nicht vom Programmierer selbst gemacht, sondern von einem Programm ("Compiler", "Interpreter")

Programm

• Allgemein: eine definierte Abfolge von Arbeitsschritten, die zu einem gewünschten Effekt führen soll. ("Trainingsprogramm", "Beschäftigungsprogramm", "Impfprogramm", "Ernährungsprogramm")
• Beim Programmieren: Abfolge von Befehlen,die grundsätzlich der Reihe nach abgearbeitet werden und in ihrer Gesamtheit ein bestimmtes Verhalten des Computers erwirken
• Ganze Befehlsfolgen können gewöhnlich zusammengefasst als "Prozedur", "Routine", "Methode" unter einem Namen abgespeichert und aufgerufen werden
• Inhalte (Zahlen, Texte, (Kalender-)Daten etc.) werden in "Variablen" gespeichert
• "Control-of-flow" Elemente beeinflussen den grundsätzlichen Ablauf: z.B. kann von zwei (oder mehreren) Codeblöcken nur einer (oder auch gar keiner) ausgeführt werden.
• Codeblöcke können mehrmals wiederholt werden (Schleife)
• Die Steuerung bei Auswahl (welcher Block?) oder Wiederholung (wie oft?) erfolgt durch Variableninhalte

Compilieren

• Der gesamte Quellcode eines Programms wird vom "Compiler" (einem Programm) gelesen, auf Gültigkeit überprüft und in Maschinencode übersetzt. (Windows typisch: "EXE-Datei")
• Das fertig übersetzte Programm liegt in einer Datei vor und wird erst nach Aufruf ausgeführt.
• Zur "Laufzeit" (=während der Programmausführung) muss nichts mehr übersetzt werden, wodurch compilierte Programme auf dem Bildschirm schneller wirken als "interpretierte" (siehe nächste Lektion)
• Vorteil: hohe Abarbeitungsgeschwindigkeit
• Nachteile:
  • Programm muss für verwendete CPU compiliert werden (das kann auch auf einer anderen erfolgen  "Cross Compiler")
  • Inflexibilität: Programmänderungen können zu erheblichem Zeitaufwand für das neuerliche Übersetzen führen
• Vertreter: z.B. Fortran, C

Interpretieren

• Der Quellcode eines Programms wird Zeile für Zeile gelesen, auf Gültigkeit überprüft und jede Zeile wird sofort ausgeführt.
• Während der Laufzeit muss jede Zeile übersetzt werden. Das verbraucht Zeit und so wirken interpretierte Programme langsamer als compilierte.
• Vorteile:
  • Flexibilität (Quellcode kann im Prinzip zur Laufzeit verändert werden)
  • Dasselbe Programm kann auf unterschiedlichen Betriebssystemen bzw. Architekturen laufen, wenn es einen Interpreter gibt
• Nachteil: langsame Abarbeitung
• Vertreter: PHP, Basic, SQL, Lisp

Java (und andere)

• Quellcode wird in "Bytecode" übersetzt: die Maschinensprache einer CPU, die gar nicht im eigenen Computer eingebaut ist (aber denkbar wäre, und von Sun (dem damaligen Hersteller von Java) entwickelt wurde. Diese CPU hat jedoch nie Verbreitung erlangt).
• Früher: 
• Eine VM musste es für die im Computer verbaute CPU geben, sonst konnte man Java schlicht nicht laufen lassen.
• Der Bytecode wurde dann von einem Interpreter namens "VM" für die eigene CPU interpretiert.
• Vorteil: den Maschinencode einer anderen CPU zu interpretieren ist viel einfacher als Quellcode zu interpretieren, daher Laufzeitvorteil gegenüber anderen interpretierten Sprachen.
• Nachteil: im Vergleich zu compilierten Sprachen immer noch viel zu langsam.
• Heute:
  • Java-Compiler erzeugt nach wie vor Bytecode.
  • Die VM kompiliert ganze Bytecode-Blöcke, die zur späteren Verwendung (z.B. neuerlicher Aufruf, Schleifen) aufgehoben werden und führt den nun in echter Maschinensprache vorliegenden Block gleich aus.
  • Das nennt man "Just-in-time Kompilierung" (JIT)
• Vorteile:
  • Hohe Flexibilität: das compilierte Java-Programm kann von einer Computer-Architektur auf eine andere übertragen werden (und muss dort nicht neu compiliert werden)
  • Kein merkbarer Geschwindigkeitsnachteil mehr ggü. compilierten Sprachen
• Nachteile: "hardwarenahe" Programmierung ist kaum bis gar nicht möglich (z.B. Treiber)
• Andere Vertreter: 
  • .NET (mit seinen Sprachen, allen voran C#), die "Maschinensprache" dort heißt "CL" (Common Language), die Laufzeitumgebung "CLR" (Common Language Runtime)
  • Aber schon Pascal (1970er) von Niklas Wirth (ETH Zürich) mit "p-Code"

• Höhere Programmiersprache (mit etlichen Elementen der Sprache C)
• Bietet plattformübergreifende Executables (im Gegensatz zu plattformübergreifendem Quellcode)
• Ursprünglich von Sun Microsystems (Stanford University); heute bei Oracle
• Lt. Oracle auf über 3 Mrd. Geräten.
• "Starke Typisierung"
• "Strenge Objektorientierung"
• Keine expliziten Pointer

• "Virtual Machine" - eine Software, die einen Computer "emuliert" (simuliert), dessen Maschinensprache Bytecode wäre.
• Muss für jede Plattform (CPU-Art + Betriebssystem) implementiert werden, damit Java läuft
• Interpretierte früher Bytecode, was zu langsam war (und die Verbreitung behinderte)
• Heute: JIT-Compilierung, praktisch kein Unterschied mehr zu nativ (also zum jeweiligen Maschinencode) compilierten Programmen

• "Just-in-time"-Compilierung
• Übersetzung erfolgt wie beim Interpreter zur Laufzeit
• Es wird aber anders als bei diesem nicht Zeile für Zeile übersetzt, sondern jeweils Codeblöcke
• Der übersetzte Code wird nicht verworfen, sondern aufgehoben, sodass er später nicht neu compiliert werden muss

• "Integrated Development Environment"
• Alles was man braucht, um Programme zu entwickeln und laufen zu lassen
• Editor (mit Sprachunterstützung)
• Compiler
• Laufzeitumgebung (VM)
• Debugger
• u.v.a.: Code Beautifier, Versionskontrolle, GUI-Editor, Sourcecodeüberprüfung etc.

• Eclipse (IBM)

• NetBeans (Oracle)

• IDEA (IntelliJ)

• BlueJ

• und viele weitere "Exoten"

• Ursprünglich Studentenprojekt "Xelfi", nur Java
• => NetBeans
• => Von Sun übernommen
• Heute direkt Java, JavaScript, Python, PHP, Groovy, C++, C & Fortran,…
• Viele weitere Sprachen via Plugin
• Komplett in Java geschrieben, daher plattformübergreifend

• NetBeans verwaltet "Projekte"
• Könnte man alles händisch machen, wäre aber sehr mühsam
• Ist aber alles "nur Java".

• Höhere Programmiersprache (mit etlichen Elementen der Sprache C)
• Bietet plattformübergreifende Executables (im Gegensatz zu plattformübergreifendem Quellcode)
• Ursprünglich von Sun Microsystems (Stanford University); heute bei Oracle
• Lt. Oracle auf über 3 Mrd. Geräten.
• "Starke Typisierung"
• "Strenge Objektorientierung"
• Keine expliziten Pointer

• "Virtual Machine" - eine Software, die einen Computer simuliert, dessen Maschinensprache Bytecode ist.
• Muss für jede Plattform (CPU-At + Betriebssystem) implementiert werden, damit Java läuft
• Interpretierte früher Bytecode, was zu langsam war (und die Verbreitung behinderte)
• Heute: JIT-Compilierung, praktisch kein Unterschied mehr zu nativ compilierten Programmen

• "Just-in-time"-Compilierung
• Übersetzung erfolgt wie beim Interpreter zur Laufzeit
• Es wird aber anders als bei diesem nicht Zeile für Zeile übersetzt, sondern jeweils Codeblöcke
• Der übersetzte Code wird nicht verworfen, sondern aufgehoben, sodass er später nicht neu compiliert werden muss

class HelloWorld {
    public static void main ( String[ ] args ) {
        System.out.println ( "Hello, world!" );
    }
}

• Mit javac HelloWorld.java compilieren.
• Mit java HelloWorld ausführen

IDE

• "Integrated Development Environment"
• Alles was man braucht, um Programme zu entwickeln und laufen zu lassen
• Editor (mit Sprachunterstützung)
• Compiler
• Laufzeitumgebung (VM)
• Debugger
• u.v.a.: Code Beautifier, Versionskontrolle, GUI-Editor, Sourcecodeüberprüfung etc.

• Eclipse
• NetBeans
• IntelliJ
• BlueJ
• und weitere "Exoten"

• Ursprünglich Studentenprojekt "Xelfi", nur Java
• => NetBeans
• => Von Sun übernommen
• Heute direkt Java, JavaScript, PHP, Groovy, C++, C & Fortran
• Viele weitere Sprachen via Plugin
• Komplett in Java geschrieben, daher plattformübergreifend

• NetBeans verwaltet "Projekte"
• Könnte man alles händisch machen, wäre aber sehr mühsam
• Ist aber alles "nur Java".

• Allgemein: Abfolge von Arbeitsschritten, um ein gewünschtes Ergebnis / einen gewünschten Zustand zu erreichen (Impfprogramm, Beschäftigungsprogramm, Ernährungsprogramm etc.)
• Computer: Abfolge von Befehlen, um den Computer zu einem bestimmten, genau definierten Verhalten zu bringen.
• Geschrieben in einer "Programmiersprache", für den Menschen verständlich, für den Computer nicht.
• Wird vor/während Ausführung in eine für den Computer umsetzbare Form gebracht ("übersetzt")
• Siehe "was ist Maschinensprache"
• Siehe "was ist ein Compilier"
• Siehe "was ist ein Interpreter"

• Ein meistens kleiner, genau definierter Arbeitsschritt, repräsentiert durch ein genau bestimmtes Wort einer Programmiersprache
• Kann direkter Sprachbestandteil sein ( if, do ... while, ... ? ... : ... ) oder einer "Bibliothek" entstammen (System.out.println() )
• Die Abfolge der Statements bildet das Programm

• Ein beim Übersetzen des Quellcodes (gewollt) ignorierter Teil des Programmtexts.
• Kommentare verwendet man, um den Code für den Leser klar(er) zu machen
• Sollten auf warum-Ebene passieren, nicht auf was-Ebene (die ist durch den Programmtext selbst abgedeckt)
• Java kennt drei Arten:
• Zeilenendkommentare ( ab // wird der Rest der Zeile ignoriert)
• Blockkommentare (alles zwischen /* und */ wird ignoriert, auch über mehrere Zeilen hinweg. BK können nicht geschachtelt werden)
• Javadoc-Kommentare (wie Blockkommentar, beginnen aber mit /** und können vom javadoc-Tool zu einer HTML-Seite gemacht werden, die dann die Dokumentation ist

• Alles zwischen { und }
• Benötigt keinen ; am Ende
• Können geschachtelt werden (Codeblöcke können Codeblöcke enthalten)
• werden meistens verwendet bei: 
  if, while, do...while, switch, Klassen, Interfaces, Methoden
• Fassen die enthaltenen Statements zu einem logischen Statement zusammen ("Compund statement")

• Ein Speicherort für Werte
• Braucht die Adresse nicht zu kennen, nur den Namen
• => "Vereinbarung" zwischen Programmierer und Compiler
• Muss einen Datentyp haben (int, double, String, JFrame, MeineKlasse,…)
• Datentyp kann nicht verändert werden
• Muss "initialisiert" werden
• "Gilt" von der Zeile der Deklaration bis zum Ende des Blocks, in dem deklariert ("Scope")
• Ausnahme: Membervariablen gelten in der gesamten Klasse

• ist eine Ansammlung von Statements (Block {…})

• hat einen Namen, unter dem sie aufgerufen werden kann

• hat Übergabeparameter, mit denen sie gesteuert werden kann

• Übergabeparameter sind wie lokale Variable, werden aber vom Aufrufer festgelegt

• Können in der Methode verändert werden (wie lokale Variable!)

• Aufrufer erfährt aber nichts davon ("Wertparameter" - Achtung bei Objekten)

• In anderen Sprachen "Routine" bzw "Prozedur"

• Bei oop-Sprachen "Methode", weil sie über das Objekt aufgerufen werden, an dem sie ›hängen‹ und für das sie dann arbeiten.

Primitive Datentypen sind die, die keine Objekte im Speicher bilden, also keinen Code, der direkt mit dem Objekt verknüpft wäre, haben oder ausführen können. Sie bestehen lediglich aus einem Datenteil. Java kennt folgende primtivie Datentypen:

• boolean (nur false oder true)

• byte (8 bit; ganzzahlige Werte von -128…127)

• short (16 bit; ganze Zahlen von -32768…32767)

• int (32 bit; ganze Zahlen von -2 147 483 648…2 147 483 647)

• long (64 bit; ganze Zahlen von -2⁶³… 2⁶³-1, ab Java 8 auch unsigned: 0…2⁶⁴)

• float (32 bit; Fließkommazahl ±-1,4×10⁻⁴⁵ ... ±3,4×10³⁸)

• double (64 bit; Fließkommazahl ±-4,9×10⁻³²⁴ ... ±1,7×10³⁰⁸)

• char (16 bit; 1 Unicode-Zeichen UTF-16; kompatibel mit Ganzzahltypen)

• Datentyp ist Klasse

• Alles, was mit einem Großbuchstaben beginnt

• z.B

  • String

  • JFrame

  • JButton

  • javax.mail.Message

  • usw.

• selbstprogrammierte Klassen

• Alles, was einen Datentyp hat und "eingebaut" werden kann, wo etwas von diesem Datentyp gebraucht wird

• 3 ( weil a=3...)

• 5+2

• a*7

• ++a

• aber auch

  • getAlter()

  • b=5 ( => a=b=c=d=0 )

  • a!=b

  • usw.

• Je nach Datentyp hanelt es sich um "Integer-Ausdrücke", "String-Ausdruck", "Boolesche Ausdrücke" etc.

• Variable erhält Wert.

• a=3

• b=c

• d=einePerson.getAlter()

• boolean darfHerein = ( einePerson.getAlter() >= 16 || einePerson.begleitung != null )

• Zuweisung ist selbst Ausdruck!

  • => a=b=c=d=0;

• += -= *= /= und div. shift und rot-Operatoren
• aber nicht != (für boolean)!
• a+=3; ... a = a+3;
• Aber a wird nur einmal referenziert!
• a+=4*5 ... a = a + (4*5)   (ergäbe sich auch ohne Klammerung)
• a*=b+c ... a = a * ( b+c ) (ergäbe sich nicht ohne die Klammerung!)

• "Unveränderbare Variable" (›Immutable‹)

• ›Versteckte‹ Änderungen sind im gesamten Programm unmöglich

• Direkt in den Code geschriebene Werte oder Strings
• VERMEIDEN!
• Alles in Variablen &| Konstanten packen
• Begründen

• Alle Namen haben einen expliziten Typ
• Typen werden bei allen Operationen geprüft und müssen kompatibel sein
• Automatische Konvertierungen nur, wo kein Genauigkeitsverlust möglich

• Programmfluss grundsätzlich von oben nach unten

• Statment für Statement

• Control-of-flow ändert das

  • Entscheidungen ( if, switch )

  • Schleifen ( for, while, do...while )

  • Aufrufe?

• ==
• !=
• <=
• <
• >=
• >
• Achtung bei Vergleich von Objekten! Adressen werden verglichen! Nur == und != möglich!
• Strings sind Objekte!
• Daher: einString.equals ( "Vergleichsstring" );

• String ist in Java eine Klasse, Strings sind also Objekte dieser Klasse

• new() kann entfallen, Literal erzeugt Objekt

• Kein Vergleich mit == !

  • Das vergleicht Adressen der Objekte im Speicher!

  • ⇒ Nur == und != möclich!

• Stringvergleiche:

  • string.equals( string )

  • string.toLowerCase().equals( string.toLowerCase() )  für groß-/klein-INsensitiven Vergleich

• andere Operatoren: siehe Methoden in der Auto-Completion von NetBeans

  • Auch regular expressions!

• objekt.name() … nichtstatisch oder statisch

• Klasse.name() … statisch

• name() … lokal

• Java verwendet Wertparameter / keine Referenzparameter

• Objekte: Übergeben wird die Adresse des Objekts als Wertparameter. Das ist wie eine Referenz.

• \'       Einfaches Anführungszeichen '

• \"       Anführungszeichen "

• \\       Backslash \

• \t       Tabulator

• \n      Neue Zeile

• \r       Wagenrücklauf

• \b      Backspace

• \f       Formularvorschub

• \u#### Unicode-Zeichen gemäß #### (hex)

• Mehrere Variablen desselben Typs in einer Variablen zusammengefasst.

• Zugriff auf die Elemente über einen »Index‹, der in [ ] angegeben wird.

• Indizes beginnen immer bei 0.

• Deklaration:

  datentyp[] variable;
  oder
  datentyp variable[];

• Arrays sind selbst Objekte und müssen erzeugt werden
  datentyp[] variable = new datentyp[3];

• Jedes Array kann man fragen, wie viele Elemente es enthält:  arrayvariable.length

• Für Objekt-Arrays muss das Array erzeugt werden UND die Objekte

• Mehrdimensionale Arrays gibt es in Java nicht

• Aber es gibt Objekt-Arrays => Ein Array aus Arrays ist ok

• Ist wie 2D-Array, kann aber ›ausgefranst‹ sein.

• (Auch höherdimensional)

• Ein String ist kein Character-Array (inkompatibel, nicht direkt vergleichbar)

• Länge:

  • Strings: string.length() (Methode)

  • Char-Array:: char[].length (Attribut)

• Umwandlung

  • String ⇒ char[] mit string.toCharArray();

  • char[] ⇒ String mit char[].toString();

• Zeichen an Stelle n:

  • String: string.charAt(n);

  • Char-Array: char[n]

• Einen Computer (o.Ä.) zu einem bestimmten, genau definierten Verhalten zu bringen.

• Allgemein: Abfolge von Arbeitsschritten, um ein gewünschtes Ergebnis / einen gewünschten Zustand zu erreichen (Impfprogramm, Beschäftigungsprogramm, Ernährungsprogramm etc.)
• Computer: Abfolge von Befehlen, um den Computer zu einem bestimmten, genau definierten Verhalten zu bringen.
• Geschrieben in einer "Programmiersprache", für den Menschen verständlich, für den Computer nicht.
• Wird vor/während Ausführung in eine für den Computer umsetzbare Form gebracht ("übersetzt")
• Siehe "was ist Maschinensprache"
• Siehe "was ist ein Compilier"
• Siehe "was ist ein Interpreter"

• Ein meistens kleiner, genau definierter Arbeitsschritt, repräsentiert durch ein genau bestimmtes Wort einer Programmiersprache
• Kann direkter Sprachbestandteil sein ( if, do ... while, ... ? ... : ... ) oder einer "Bibliothek" entstammen (System.out.println() )
• Die Abfolge der Statements bildet das Programm

• Ein beim Übersetzen des Quellcodes (gewollt) ignorierter Teil des Programmtexts.
• Kommentare verwendet man, um den Code für den Leser klar(er) zu machen
• Sollten auf warum-Ebene passieren, nicht auf was-Ebene (die ist durch den Programmtext selbst abgedeckt)
• Java kennt drei Arten:
• Zeilenendkommentare ( ab // wird der Rest der Zeile ignoriert)
• Blockkommentare (alles zwischen /* und */ wird ignoriert, auch über mehrere Zeilen hinweg. BK können nicht geschachtelt werden)
• Javadoc-Kommentare (wie Blockkommentar, beginnen aber mit /** und können vom javadoc-Tool zu einer HTML-Seite gemacht werden, die dann die Dokumentation ist

• Alles zwischen { und }
• Benötigt keinen ; am Ende
• Können geschachtelt werden ( Codeblöcke können Codeblöcke enthalten)
• werden meistens verwendet bei
• if, while, do...while, switch, Klassen, Interfaces, Methoden, Array
• Fassen die enthaltenen Statements zu einem logischen Statement zusammen ( "Compund statement")

• Ein Speicherort für Werte
• Braucht die Adresse nicht zu kennen, nur den Namen
• => "Vereinbarung" zwischen Programmierer und Compiler
• Muss einen Datentyp haben (int, double, String, MeineKlasse)
• Datentyp kann nicht verändert werden
• Muss "initialisiert" werden
• "Gilt" von der Zeile der Deklaration bis zum Ende des Blocks, in dem deklariert ("Scope")
• Ausnahme: Membervariablen gelten in der gesamten Klasse

• Eine Ansammlung von Statements
• In anderen Sprachen "Routine" bzw "Prozedur"
• Bei oop-Sprachen "Methode", weil an Objekt hängt
• hat einen Namen, unter dem sie aufgerufen werden kann
• hat Übergabeparameter, mit denen sie gesteuert werden kann
• Übergabeparameter sind wie lokale Variable, werden aber vom Aufrufer festgelegt
• Können verändert werden
• Aufrufer erfährt nichts davon ("Wertparameter" - Achtung bei Objekten)

• int
• long
• float
• double
• char
• boolean

• Datentyp ist Klasse
• Alles, was mit einem Großbuchstaben beginnt
• String
• JFrame
• JButton
• javax.mail.Message
• usw.
• selbstprogrammierte Klassen

• Alles, was einen Datentyp hat und "eingebaut" werden kann, wo etwas von diesem Datentyp gebraucht wird
• 3 ( weil a=3...)
• 5+2
• a*7
• ++a
• aber auch
• getAlter()
• b=5 ( => a=b=c=d=0 )
• a!=b
• Je nach Datentyp hanelt es sich um "Integer-Ausdrücke", "String-Ausdruck", "Boolesche Ausdrücke" etc.

• Variable erhält Wert.
• a=3
• b=c
• d=einePerson.getAlter()
• boolean darfHerein = ( einePerson.getAlter() >= 16 || einePerson.begleitung != null )
• Zuweisung ist selbst Ausdruck
• => a=b=c=d=0;

• += -= *= /= und div. shift und rot-Operatoren
• aber nicht != (für boolean)!
• a+=3; ... a = a+3;
• Aber a wird nur einmal referenziert!
• a+=4*5 ... a = a + (4*5)   (ergäbe sich auch ohne Klammerung)
• a*=b+c ... a = a * ( b+c ) (ergäbe sich *nicht* ohne die Klammerung!)

• "Unveränderbare Variable"
• Versteckte Änderung

• Direkt in den Code geschriebene Werte oder Strings
• VERMEIDEN!
• Alles in Variablen &| Konstanten packen
• Begründen

• Alle Namen haben einen expliziten Typ
• Typen werden bei allen Operationen geprüft und müssen kompatibel sein
• Automatische Konvertierungen nur, wo kein Genauigkeitsverlust möglich

• Programmfluss grundsätzlich von oben nach unten
• Statment für Statement
• Control-of-flow ändert das
• Entscheidungen ( if, switch )
• Schleifen ( for, while, do...while )
• Aufrufe?

• ==
• !=
• <=
• <
• >=
• >
• Achtung bei Vergleich von Objekten! Adressen werden verglichen!
• Strings sind Objekte!
• Daher: einString.equals ( "Vergleichsstring" );

• begründen
• .equals()
• toLower()
• andere Operatoren
• regular expressions

• objekt.name()
• Klasse.name()
• name()
• Wertparameter / keine Referenzparameter in Java
• Was macht das mit Objekten?

• \t
• \n
• \u####
• und noch ein paar

• Was ein Array ist
• Deklaration
• Arrays sind selbst Objekte
• => array.length
• Für Objekt-Arrays muss das Array erzeugt werden UND die Objekte
• Mehrdimensionale Arrays gibt es in Java nicht
• Aber es gibt Objet-Arrays => Ein Array aus Arrays ist ok
• Ist wie 2D-Array, aber ausgefranst
• (Auch höherdimensional)

• Ein String ist kein Character-Array

• In der Literatur gibt es keine einheiltich Definition von OOP

• Allgemein anerkannt: OOP, wenn folgende 3 Eigenschaften erfüllt

  • Kapselung

  • Vererbung

  • Polymorphie

• ›Objektorientierte Programmiersprache‹ ist eigentlihc nicht nötig, es muss nur ›Pointer‹ (›Zeiger‹) geben, sprich: die implizite oder explizite Möglichkeit, mit Speicheradressen umzugehen, die auch auf Code zeigen können müssen.

• Objektorientierte Programmiersprachen setzen das meist mithilfe von ›Klassen‹ um.

• Im Grunde eine ›Programmierdisziplin‹ (man kann sogar Assember objektorientiert programmieren)

• Objektorientierte Sprachen erleichtern es aber wesentlich, indem sie es erzwingen

• Eine Art ›Bauplan‹ für Objekte, die durch den Befehl new Klassenname()  entstehen

• Enthält Variablen und Methoden (genannt: ›Member‹)

• Jede Klasse ist auch selbst gleichzeitig ein Objekt:

• Auf static Member (Variablen und Methoden) kann direkt zugegriffen werden

  • Beispiele: Math.PI , System.out (und dadurch: System.out.println() )

• Nichtstatische Member existieren nur für das jeweilige Objekt, mit dem sie erzeugt werden. Sie müssen über dieses Objekt angesprochen werden: o.eineMethode();

• Statische Member einer Klasse können über den Klassennamen angesprochen werden (empfohlen), aber auch über jedes Objekt dieser Klasse (nicht empfehlenswert):

  • Klasse.eineStatischeMethode();

  • o.eineStatischeMethode();

• Alle Zeilen, die auf einen lokalen Namen (Variable oder Methode) zugreifen, befinden sich in der selben Datei wie die Deklaration des Namens

• ⇒ private Membervariablen, öffentliche(re) Getter und Setter = Kapselung

• Sicherheit kann viel leichter implementiert werden

• Read-only, write-only, Überprüfungen vor Änderungen

• Klassen können durch Ableitung anderer Klassen erzeugt werden.

  class Subclass extends Superclass {…

• Die so entsehende Klasse ist die ›Subklasse‹, die Klasse, die sie beerbt, ist ihre ›Superklasse‹.

• Es kann nur eine Klasse abgeleitet werden (›Single Inheritance‹)

• ›Beerben‹ bedeutet: Sämtliche Methoden und Variablen, die in der Superklasse nicht private  sind, stehen in der Subklasse zur Verfügung, obwohl sie dorthin nicht kopiert werden.

• Sichtbarkeit geerbter Identifier kann verändert werden, aber nicht privater werden als in Superklasse

• (Bezeichnung ›Abgeleitete Klasse‹ sollte man vermeiden, weil das beide sein können.)

• Objekte der Subklasse sind gleichzeitig auch Objekte der Superklasse.
• Folgender Code ist gültig:

class Lebewesen { … }
class Tier extends Lebewesen { … }
class Säugetier extends Tier { … }
class Main {
    public static void main ( String[ ] args ) {
        Lebewesen lw = new Säugetier( );
    }
}

• Starke Typisierung würde das ohne Polymorphie verhindern.
• In der Variable lw können nur die Namen (Variablen und Methoden) angesprochen werden, die es in der Klasse Lebewesen gibt.
• Die JVM weiß allerdings, welchen Typ das Objekt eigentlich hat: wenn eine Methode aufgerufen wird, die geerbt und überschrieben wurde, so wird beim Aufruf lw.geerbteMethode() die Methode aus Säugetier aufgeruen, nicht die aus Lebewesen!
  Dieses Verhalten nennt man ›Polymorphie‹ (Vielgestaltigkeit).

• ›Exemplar‹ oder ›Instanz‹ einer Klasse.

• Entsteht durch den Befehl new Klassenname(…); 

• Wenn ›Mensch‹ eine Klasse wäre, wären Sie und ich ›Instanzen‹ dieser Klasse.

• Wird zumeist in einer Variable, deren Datentyp die entsprechende Klasse ist, gespeichert:
  o = new Klasse(…);

• Solche Variablen sind ›Objektvariablen‹ (oder kurz: ›Objekte‹, obwohl ›Objekt‹ auch ein anonymes bezeichnen kann.

• Können aber auch ›anonym‹, also völlig namenlos, auftreten

  draw( new Kreis( 100, 120, 75 ) );
  return new Klasse(…);

• Kein anderer Code als in Klassen erlaubt. Jede Codezeile (=mit Statements) gehört zu einer Klasse.

• Scheinbare Ausnahme: ›Interfaces‹ – aber auch nur scheinbar, denn technisch sind das wieder Klassen

• ›Geographische‹ Gültigkeit: an welchen Codestellen ist ein Name gültig?

• Generell: ab der Deklaration bis zum Ende des Blocks, in dem sie erfolgt.

• Member: in der ganzen Klasse (und nicht erst ab der Stelle der Deklaration)

• Achtung: eine lokale Variable (Deklaration in einem Block) kann eine globalere Variable mit demselben Namen ›verdecken‹.

  • Beispiel: Übergabeparameter mit demselben Namen wie Membervariable
    Ausweg in diesem Fall: ›this‹

• Von wo aus ein Name angesprochen werden kann (ebenfalls ›geographisch‹)

• private: nur innerhalb der Klasse selbst

• –: von allen Klassen im selben Package

• protected: von allen Subklassen (ungeachtet des Packages)

• public: von überall (und damit ist auch wirklich überall gemeint)

• Eine Codezeile kann zwar grundsätzlich im Scope einer Variable liegen, diese aber trotzdem invisible sein, weil sie von einer lokalen Variable ›vereckt‹ wird.

• ›Kalendarische‹ Größe: von wann bis wann ist eine Variable gültig?
• Objekte entstehen durch den new-Befehl und vergehen, wenn ihre Objektvariable null gesetzt wird.
• Der Zeitraum dazwischen ist die Lifetime.

• Kapselung
• Vererbung
• Polymorphie
• Keine ›objektorientierte Programmiersprache‹ nötig, nur Pointer und die Möglichkeit, auch auf Code zu zeigen.
• Im Grunde eine ›Programmierdisziplin‹
• Objektorientierte Sprachen erleichtern es aber wesentlich und erzwingen es teilweise

• Alle Zeilen, die auf einen lokalen Namen (Variable oder Methode) zugreifen, befinden sich in der selben Datei wie die Deklaration des Namens
• => private Membervariablen, öffentliche(re) Getter und Setter = Kapselung
• Sicherheit kann viel leichter implementiert werden
• Read-only, write-only, Überprüfungen vor Änderungen

• Klassen könne andere Klassen durch ›Ableitung‹ ›beerben‹: sämtliche Methoden und Variablen, die dort nicht private  sind, stehen zur Verfügung, obwohl sie dorthin nicht kopiert werden.
• Die so entsehende Klasse ist die ›Subklasse‹, die Klasse, die sie beerbt heißt ›Superklasse‹.
• (›Abgeleitete Klasse‹ vermeiden, weil das im Deutschen beide sein können.)
• Sichtbarkeit kann verändert werden, aber nicht privater werden als Superklasse

• Objekte der Subklasse sind gleichzeitig auch Objekte der Superklasse.
• Folgender Code ist gültig:

class Lebewesen { … }
class Tier extends Lebewesen { … }
class Säugetier extends Tier { … }
class Main {
    public static void main ( String[ ] args ) {
        Lebewesen lw = new Säugetier( );
    }
}

• Starke Typisierung würde das ohne Polymorphie verhindern.

• ›Bauplan‹ für Objekte, die durch den Befehl new  entstehen
• Selbst ein Objekt. Auf static Variablen und Methoden kann direkt zugegriffen werden
• Beispie: Math.PI

• ›Bauplan‹ für Objekte, die durch den Befehl new  entstehen
• Selbst ein Objekt. Auf static Variablen und Methoden kann direkt zugegriffen werden
• Beispie: Math.PI

• ›Exemplar‹ oder ›Instanz‹ einer Klasse.
• Entsteht durch den Befehl new Klassenname(…); 
• Wenn Mensch eine Klasse wäre, wären Sie und ich Instanzen dieser Klasse.

• ›Exemplar‹ oder ›Instanz‹ einer Klasse.
• Entsteht durch den Befehl new Klassenname(…); 
• Wenn Mensch eine Klasse wäre, wären Sie und ich Instanzen dieser Klasse.

• Kein anderer Code als in Klassen erlaubt.
• (Ausnahme: Interfaces – aber auch nur scheinbar, denn technisch sind das wieder Klassen)

• Generell: ab der Deklaration bis zum Ende des Blocks, in dem sie erfolgt.
• Member: in der ganzen Klasse (und nicht erst ab der Stelle der Deklaration)

• Von wo aus ein Name angesprochen werden kann (›geographische‹ Größe):
• private: nur in der Klasse selbst
• –: von allen Klassen im selben Package
• protected: von allen Subklassen (ungeachtet des Package)
• public: von überall (und damit ist auch wirklich überall gemeint)

• Wann ein Name angesprochen werden kann (›kalendarische‹ Größe)
• Ab dem new -Befehl
• bis ein Objekt untergeht (d.h., die letzte Objektvariable, die einen Verweis darauf enthält, wird null  gesetzt)

• Alle Genannten sind ›Klassenbibliotheken‹ für GUIs

• AWT: ›advanced windowing toolkit‹, Package java.awt

• Völlig veraltet, aber immer noch vorhanden, weil Swing darauf zugreift

• Swing: eigentlich ein Arbeitsname (dem Musikgeschmack seines Entwicklers geschuldet), greift immer noch auf AWT zu. Package javax.swing.

• eigentlich ›JFC‹ (›Java Foundation Classes‹) - hat sich nicht durchgesetzt

• Für Swing (& AWT) ein sehr schöner graphischer Editor in Netbeans (›Matisse‹)

• Beides kann auch ›händisch‹ programmiert werden

• Mühsam, aber manchmal nötig (z.B.: keine Element-Arrays im graphischen Editor)

• JavaFX (›Java Effects‹) Framework für plattformübergreifene Userinterfaces. Diverse Klassen, verteilt in Packages in Package javafx.

• Ist im Begriff, Swing über kurz oder lang zu ersetzen.

• Von JDK getrennte Installation

• SWT (›Standard Widget Toolkit‹) ist eine Klassenbibliothek von IBM, die ebenfalls graphische Userinterfaces bietet.

• AWT, Swing und JavaFX gehören zum definierten Sprachumfang von Java

• Container

  • Können selbst Swing-Objekte enthalten. Mit Containern kann man User-Interfaces somit ›strukturieren‹, bspw. weil man einen Container mitsamt seinem Inhalt auf dem JFrame verschieben kann.

• Controls

  • Die einzelnen Elemente, mit denen man letztendlich die Funktionalität der Bedienbarkeit seiner Bildschirmmaske aufbaut. Buttons, Labels (Beschriftungen), Drop-Down-Boxen, Progressbars usw.

• Menus

  • Werden von Swing gesondert behandelt, indem sie über die Inhalt kommen, nicht zu diesen.

  • Der ›Menu bar‹ (das Programmenü) erhält ›Menus‹ (File, Edit, View,…,Help), die Menus erhalten ›Menu Items‹ (normal oder mit Checkbox bzw. Radio Button) und ›Separator‹ (Trenner).

  • Popup- bzw. Kontextmenüs werden mit einem Popup Menu realisiert

• Windows

  • Fix fertig vordefinierte, ganze Fenster für oft benötigte Abläufe (bzw. Teilen davon)

  • Dialog (JDialog): flexibel parametrierbares Dialgofenster

  • Frame (JFrame): ein ganzes Fenster für beliebige Inhalte mit ›Dekorationen‹ (Titelbar, Systemmenü, Bedienbuttons u.dgl.). Das Hauptfenster einer Applikation wird meistens ein JFrame sein.

  • Color Chooser: Macht, was der Name sagt.

  • File Chooset: liefert nach Benutzerauswahl (Tippen oder Filesystem Browsen) den Pfad eines Ordners oder einer Datei

  • Option Pane (praktisch für Meldungen mit ok oder Entscheidungen wie ja/nein/abbrechen u.dgl.)

• Fillers

  • Trennlinien oder unsichtbare Trenner mit Eigenschaften wie bspw., dass der User sie auf der Maske verschieben kann.

• AWT

  • Elemente des awt-Frameworks. Grunsätzlich ähnlich, aber mit weniger Funktionalität und grundsätzlich ›lightweight‹.

• Beans

  • Im Grunde eine ›normale‹ Java-Klasse, die das Interface java.io.Serializable implementiert und get- und set-Methoden für seiner Attribute zur Verfügung stellt.

Label – javax.swing.JLabel
        Jegliche Beschriftung

Text Field – javax.swing.JTextField
        Einzeiliges textfeld

Text Area – javax.swing.JTextArea
        Mehrzeiliges Textfeld
         benützt javax.swing.JScrollPane
         (ebenso JList, JTextArea, JTextPane, JEditorPane, JTree, JTable)
        Anchors
        Horizontal & Vertical resize

Password Field – javax.swing.JPasswordField

(   Formatted Field – javax.swing.JFormattedTextField 

    Text Pane – javax.swing.JTextPane

    Editor Pane – javax.swing.JEditorPane )    

Button – javax.swing.JButton
        Button

Reaktion über Methode xxxactionPerformed(), dazu in Matisse den Button doppelklicken! NICHT einfach eine Methode programmieren; das funktioniert nicht. (›xxx‹ wird durch den Namen des Buttons ersetzt.)

Toggle Button – javax.swing.JToggleButton
        Bleibt picken
        xxxactionPerformed() bei jedem Klick

Check Box — javax.swing.JCheckBox

Radio Button – javax.swing.JRadioButton

Button Group – javax.swing.ButtonGroup
    Radio Buttons gegeneinander verriegeln. Dazu den Namen der Button Group den betreffenden Buttons im Atribut buttonGoup mitteilen.

Auswahl aus einer Liste vorgegebener Texte:

Combo Box (Drop-Down) – javax.swing.JComboBox<String>

List (immer sichtbar) – javax.swing.JList<String>

Die Texte für die Auswahl werden beide in der Property ›Model‹ des Controls (in einem eigenen Editor) eingestellt.

NUR die texte werden vom Control ausgewählt. weitere Daten zu den gewählten Elementen (z.B. eine ID für einen Datenbankrecord) muss man in eigenen Variablen (Arrays o.Ä.) parallel selbst verwalten und mit dem im Control ausgewählten ›Index‹ dort aufsuchen.

Tree – javax.swing.JTree

Table – javax.swing.JTable

Progress Bar – javax.swing.JProgressBar

Slider – javax.swing.JSlider

Spinner – javax.swing.JSpinner

Separator – javax.swing.JSeparator

Das Applikationsmenü (Menu Bar) kann aus den u.a. Elementen aufgebaut werden. Man zieht ein Menu Bar in die Maske (JFrame) und dann die entsprechenden Elemente in das Menü hinein.

Die angegebenen Klassen befinden sich alle im Package javax.swing:

Menu Bar (JMenuBar)
    Menu (JMenu)
        Menu Item (JMenuItem)
        Menu Item/CheckBox (JCheckBoxMenuItem)
        Menu Item/RadioButton (JRadioButtonMenuItem)
        Separator (JPopupMenu.Separator)
        Menu (JMenu)
    Menu (JMenu)
        usw.

Um einen Menüpunkt zu implementieren, wählt man es im Design-Modus aus, doppelklickt den Eintrag und schreibt den Code für die Methode, die von NetBeans bereitgestellt wird.

Achtung: Wie beim JButton (und allen anderen Swing-Controls) genügt es auch hier nicht, eine Methode mit ›passendem‹ Namen selbst zu schreiben, weil sie nicht mit dem Menüpunkt verknüpft würde!

Popup Menu

Shape Menu in Navigator

Select the frame from the Navigator and right-click it and select Events -> Mouse -> and you will need to implement both mousePressed and mouseReleased, as different platforms have different popup triggers, Windows being mouseReleased and I think Mac is mousePressed (don't quote me).

Create a method to show the popup menu.

         private void showPopupMenu(MouseEvent e) {
           jPopupMenu1.show(this, e.getX(), e.getY());
        }

Implement your mousePressed method

         private void formMousePressed(MouseEvent evt) {
            if (evt.isPopupTrigger()) { showPopupMenu(evt); }
        }

Container können selbst Swing-Elemente (auch weitere Container) enthalten.

Alle genannten Klassen liegen im Package javax.swing.

Panel (JPanel):
    kann selbst Layout Manager zugewiesen bekommen
    => hierarchischer Aufbau

TabbedPane (JTabbedPane):
    Mehrere Panels drauflegen, jedes wird ein Tab

SplitPane (JSplitPane):
    Zeigt vorerst Buttons als Platzhalter (die nicht vorhanden sind)
    Durch Panels ersetzen
    Trenner kann verschoben werden

ToolBar (JToolbar) 

ScrollPane (JScrollPane):
   Zeigt Lifte, wenn enthaltenes Element größer ist

DesktopPane (JDesktopPane):
    Ein Subfenster (mit Titelzeile etc.), das das JFrame verlassen kann

InternalFrame (JInternalFrame)
    Wie DesktopPane, kann aber den eigenen Container nicht verlassen.

LayeredPane (JLayeredPane)
    Kann seine Elemente in ›Layers‹ anordnen (wie bspw. in einem Graphikprogramm).

Fix fertig vordefinierte, ganze Fenster für oft benötigte Abläufe (bzw. Teilen davon)

Angegebene Klassen liegen im Package javax.swing.

Dialog (JDialog): flexibel parametrierbares Dialgofenster

Frame (JFrame): ein ganzes Fenster für beliebige Inhalte mit ›Dekorationen‹ (Titelbar, Systemmenü, Bedienbuttons u.dgl.). Das Hauptfenster einer Applikation wird meistens ein JFrame sein.

Color Chooser (JColorChooser): Macht, was der Name sagt.

File Chooser (JFileChooser): liefert nach Benutzerauswahl (Tippen oder Filesystem Browsen) den Pfad eines Ordners oder einer Datei

Option Pane (JOptionPane): praktisch für Meldungen mit ok oder Entscheidungen wie ja/nein/abbrechen u.dgl.

Glue

Horizontal Glue

Horizontal Strut

Rigid Area

Vertical Glue

Vertical Strut

• Event Listener (eine Klasse) wird benötigt
• Event erklären
• Listener erklären
• Zeigen, wie Matisse alles einrichtet

• Elemente werden auf das Fenster gezogen, Eigenschaften festgelegt

• Containern kann man einen ›Layout Manager‹ zuweisen, der sich um die Anordnung der Elemente kümmert

• Dazu im Navigator den jeweiligen Container rechtsklicken und bei ›Set Layout‹ auswählen.

• Jeweilige Details siehe nachfolgende Cheat sheets

Free Design (Group Layout)

• Positionen und Maße werden explizit angegeben und skalieren nicht mit dem Fenster.
• Matisse gibt Hilfestellungenbei Positionierungen!
• NetBeans-Erweiterung.
  

Absolute Layout

• Positionen und Maße werden explizit angegeben und skalieren nicht mit dem Fenster.
• Keine Hilfestellungen
• Bestenfalls für Boxen fixer Größe (und die sollte es am besten gar nicht geben), wie z.B. Messageboxen.
• Soll das ›Null Layout‹ ersetzen, d.h., man sollte nicht ohne Layout Manager programmieren.

Null Layout

• Gar kein Layout Manager.
• Alle Positionen und Maße müssen angegeben werden
• (Sehr unpraktisch)

• Elemente werden von links nach rechts nebeneinander angeordnet, bis kein Platz mehr im Fenster ist, dann beginn neue Zeile (wie Textverarbeitung mit Wörtern)

• Z.B. für Menüs (macht man aber anders) oder Toolbars geeignet

• Ein fester Raster von m×n Zeilen und Spalten mit Elementen.
• Jede ›Zelle‹ kann ein Element aufnehmen.
• Das Element kann allerdings ein JPanel sein, das selbst ein Container für Elemente ist
• Z.B. geeignet für einen Thumbnail-Viewer.

• Basiert auf einem Raster, ist aber wesentlich flexibler als Grid
• Wenn man damit umgehen kann, sehr leistungsfähig!
• Ähnelt einer HTML-Tabelle (keine ganz starre Zeilen-/Spalten-Einteilung, sondern Elemente können mehrere Zeilen und Spalten überdecken)

• Ein sehr universelles Design:

• Oben und unten ein horizontaler ›Streifen‹ über die gesamte Fensterbreite, der so schmal gemacht wird, wie der jeweilige Inhalt es erlaubt.

• Drei vertikale Streifen dazwischen

• Die Streifen am Rand werden – gemäß ihrem Inhalt – so schmal wie möglich gemacht

• Dadurch wird der mittlere Bereich so groß wie möglich

• Jeder Bereich kann wieder Container aufnehmen (die wieder eigene Layout Manager erhalten können).

• Ähnlich wie Flow Layout, aber horizontal oder vertikal.

• Mehrere ›Karten‹, die wie Spielkarten in einem Stapel übereinander liegen, sodass nur eine sichtbar ist.
• In Verbindung mit Reitern zum Umschalten bspw. für so ein Userinterface geeignet.

• Anordnung richtet sich nach Angaben über die gewünschten Zwischenräume zwischen Elementen

• Elemente können einander überlappen

• Persönliche Anmerkung: Ich kann damit gar nix anfangen. Vielleicht haben Sie eine Idee.

• Kein Layout Manager, sondern dasselbe, wie wenn null als Manager zugewiesen wird.

• Alle Angaben über Positionierung und Ausdehnung müssen selbst gemacht werden

• Nicht empfehlenswert (=> Absolute Layout)

• In Matisse praktisch kein Unterschied merkbar (weil der Automat alle Angaben macht), beim händischen Ausprogrammieren sehr wohl.

awt & Swing

• Beides sind ›Klassenbibliotheken‹ für GUIs
• awt: ›advanced windowing toolkit‹
• Völlig veraltet, aber immer noch vorhanden, weil swing darauf zugreift
• swing: ein Arbeitsname (dem Musikgeschmack seines Entwicklers geschuldet), greift immer nioch auf awt zu
• eigentlich JFC (Java Foundation Classes) - hat sich nicht durchgesetzt
• Für swing (&awt) ein sehr schöner graphischer Editor in Netbeans (Matisse)
• Beides kann auch programmiert werden
• Mühsam, aber manchmal nötig (z.B.: keine Element-Arrays im graphischen Editor)

Layout Manager & Matisse

• Layout Manager kümmern sich um die Anordnung von Elementen auf dem UI
• Werden Container-Elementen zugewiesen
• Der graphische Editor für Swing-Bildschirmmasken
• Elemente werden auf das Fenster gezogen, Eigenschaften festgelegt
• Demo

Flow-Layout

• Elemente werden von links nach rechts nebeneinander angeordnet, bis kein Platz mehr im Fenster ist, dann beginn neue Zeile (wie Textverarbeitung mit Wörtern)

• Z.B. für Menüs (macht man aber anders) oder Toolbars geeignet

Grid-Layout

• Ein fester Raster von m×n Zeilen und Spalten mit Elementen.
• Jede ›Zelle‹ kann ein Element aufnehmen.
• Das Element kann allerdings ein JPanel sein, das selbst ein Container für Elemente ist
• Z.B. geeignet für einen Thumbnail-Viewer.

Gridbag-Layout

• Basiert auf einem Raster, ist aber wesentlich flexibler als Grid
• Wenn man damit umgehen kann, sehr leistungsfähig!
• Ähnelt einer HTML-Tabelle (keine ganz starre Zeilen-/Spalten-Einteilung, sondern Elemente können mehrere Zeilen und Spalten überdecken)

Border-Layout

• universelles Design:
• Ein horizontaler Streifen über die gesamte Fensterbreite oben und unten
• Drei vertikale Streifen dazwischen
• Die Streifen am Rand werden – gemäß ihrem Inhalt – so schmal wie möglich gemacht
• Dadurch wird der mittlere Bereich so groß wie möglich

Box-Layout

• Ich glaube, ähnlich wie Flow, aber horizontal oder vertikal.
• TODO: recherchieren

Card-Layout

• Mehrere ›Karten‹, die wie Spielkarten in einem Stapel übereinander liegen, sodass nur eine sichtbar ist.
• In Verbindung mit Reitern zum Umschalten bspw. für so ein Userinterface geeignet.

Group-Layout

• Weiß nicht genau: zu internen Verwendung von NetBeans, glaube ich.
• TODO: recherchieren

Spring-Layout

• Anordnung richtet sich nach Angaben über die gewünschten Zwischenräume zwischen Elementen

Absolute Layout

• Positionen und Maße werden explizit angegeben und skalieren nicht mit dem Fenster.
• Bestenfalls für Boxen fixer Größe (und die sollte es am besten gar nicht geben), wie z.B. Messageboxen.

Free Design

• Ähnelt Absolute Layout, NetBeans-Erweiterung. Weiß nciht genau, wann welches.
• TODO: recherchieren

• Modifier verändern die Bedeutung einer Deklaration.

• Können angewandt werden auf Variablen, Methoden, Klassen und Interfaces (aber nicht jeder auf alle)

• Sichtbarkeitsmodifier: public, protected, -, private

  • Anwendbar auf Variablen, Methoden, "innere Klasse" (Klasse in der Klasse, z.B. EventListener) und Interfaces

• Klassenvariablen und -methoden: static

• Unveränderbarkeit: final

  • Anwendbar auf Variablen, Methoden, Klassen und Interfaces – heißt aber jeweils etwas anderes

• Instanzierbarkeit: abstract

  • Anwendbar auf Methoden und Klassen

• Sichtbarkeitsmodifier

• Zugriff von überall aus

• Gilt für Klassen und Member (Variablen und Methoden)

• public Klassen müssen in einer eigenen Datei liegen, die denselben Namen wie Klasse und die Erweiterung .java trägt.

• Sichtbarkeitsmodifier

• Zugriff von allen ›Nachkommen‹ aus (ungeachtet des Packages), also Subklassen, deren Subklassen und so weiter

• Gilt für Klassen und Member (Variablen und Methoden)

• Sichtbarkeitsmodifier

• Zugriff vom eigenen Package aus

• Gilt für Klassen und Member (Variablen und Methoden)

• Sichtbarkeitsmodifier

• Zugriff nur noch innerhalb der Klasse

• Anwendbar auf Variablen, Methoden, "innere Klassen" (Klasse in der Klasse, z.B. EventListener)

• ›Variable‹: ist dann keine mehr, sondern eine Konstante, deren Wert nicht verändert werden kann (auch nicht auf ›versteckte‹ Weise, weil bspw. eine Referenz in eine Methode übergeben wird, wo sie verändert werden soll)

• Methode: kann bei Ableitung nicht überschrieben werden

• Klasse: kann nicht abgeleitet werden

Variable & Konstante

• Werden ›statisch‹, existieren also nur einmal für die ganze Klasse, sprich eine einzige Variable für alle Objekte (Exemplare, Instanzen) dieser Klasse. Alle Objekte ›sehen‹ immer denselben Wert.

• Kann (und sollte) über den Klassennamen angesprochen werden (Klasse.statischeVariable), auch wenn kein Objekt dieser Klasse existiert.

• Kann auch über Objekte der Klasse angesprochen werden (o.statischeVariable) – sollte man eher vermeiden.

• Ist sowohl von nicht statischen als auch von statischen Methoden aus ansprechbar

Methode

• wird ›statisch‹; kann (und sollte) über den Klassennamen angesprochen werden, auch wenn kein Objekt dieser Klasse existiert. (Methoden existieren anders als Instanzvariablen immer nur 1× im Speicher!)

• Kann (und sollte) über den Klassennamen angesprochen werden ( Klasse.statischeMethode(…) ), auch wenn kein Objekt dieser Klasse existiert.

• Kann auch über Objekte der Klasse angesprochen werden ( Klasse.statischeMethode(…) ) – sollte man eher vermeiden.

Methode

• Bedeutung: hat keinen Rumpf (Code), nur ›Signatur‹.

• Kann nur in einer abstrakten Klasse vorkommen.

• Muss von einer Subklasse überschrieben werden (erzwingt so die Implementierung in einer Subklasse)

• Damit modelliert man ein gewünschtes Verhaltensschema.

Klasse:

• Bedeutung: kann nicht instanziert werden (= der Befehl new AbstrakteKlasse(…  führt zu einem Compilerfehler)

• Kann nur abgeleitet werden

• Kann durchaus auch nicht abstrakte Methoden enthalten!

Modifier für Member und Code

• Modifier verändern die Bedeutung einer Deklaration.
• Können angewandt werden auf Variablen, Methoden, Klassen und Interfaces (aber nicht jeder auf alle)
• Sichtbarkeitsmodifier: private, –, protected, public
• Anwendbar auf Variablen, Methoden, "innere Klasse" (Klasse in der Klasse, z.B. EventListener) und Interfaces
• Klassenvariablen und -methoden: static
• Unveränderbarkeit: final
• Anwendbar auf Variablen, Methoden, Klassen und Interfaces – heißt aber jeweils etwas anderes
• Instanzierbarkeit: abstract
• Anwendbar auf Methoden und Klassen

private

• Sichtbarkeitsmodifier
• Zugriff nur noch innerhalb der Klasse

– (kein Modifier)

• Sichtbarkeitsmodifier
• Zugriff vom eigenen Package aus

protected

• Sichtbarkeitsmodifier
• Zugriff von allen ›Nachkommen‹ aus (ungeachtet des Packages), also Subklassen, deren Subklassen und so weiter

public

• Sichtbarkeitsmodifier
• Zugriff von üerall aus

final

• ›Variable‹: ist dann keine mehr, sondern eine Konstante, deren Wert nicht verändert werden kann
• Methode: kann nicht überschrieben werden
• Klasse: kann nicht abgeleitet werden

static

• Variable & Konstante: werden ›statisch‹, existieren also nur einmal für die ganze Klasse, sprich eine einzige Variable für alle Objekte (Exemplare, Instanzen) dieser Klasse. Alle Objekte ›sehen‹ immer denselben Wert.
• Kann (und sollte) über den Klassennamen angesprochen werden, auch wenn kein Objekt dieser Klasse existiert.
• Ist sowohl von nicht statischen als auch von statischen Methoden aus ansprechbar
• Methode: wird ›statisch‹; kann (und sollte) über den Klassennamen angesprochen werden, auch wenn kein Objekt dieser Klasse existiert. (Methoden existieren anders als Instanzvariablen immer nur 1× im Speicher!)

abstract

• Methode: hat keinen Rumpf (Code).

• Kann nur in einer abstrakten Klasse vorkommen.

• Muss von einer Subklasse überschrieben ewrden (erzwingt so die Implementierung in einer Subklasse)

• Damit modelliert man ein gewünschtes Verhaltensschema.

• Klasse: kann nicht instanziert werden (= der Befehl new AbstrakteKlasse(…  führt zu einem Compilerfehler)
• Kann nur abgeleitet werden
• Kann durchaus auch nicht abstrakte Methoden enthalten!