Hallo Zusammen
Aufgabenstellung:
Erstellen Sie eine Anwendung, in der Sie die Position des Fensters der Anwendung über vier Schaltflächen verändern können. Eine Schaltfläche soll das Fenster um 20 Pixel nach oben verschieben, eine um 20 Pixel nach unten und die beiden anderen um je 20 Pixel nach links beziehungsweise rechts.
Beachten Sie bei der Umsetzung bitte die folgenden Vorgaben:
Erstellen Sie für den Listener eine innere Klasse in der Klasse mit dem Fenster der Anwendung. Der Listener soll die Ereignisse aller vier Schaltflächen verarbeiten können.
Setzen Sie das Fenster der Anwendung fest auf die Größe 400 × 400 und positionieren Sie es zunächst an einer beliebigen Stelle auf dem Desktop.
Ordnen Sie die Schaltflächen in einem BorderLayout mit einem Abstand von 10 Pixeln an.
Stellen Sie sicher, dass das Fenster nicht aus dem Desktop herausgeschoben werden kann. Ermitteln Sie dazu die aktuelle Größe des Desktops und berechnen Sie dann die maximal möglichen Koordinaten für die Verschiebung nach rechts und nach unten. Für die Verschiebung nach links beziehungsweise oben können Sie den Wert 0 als Grenze verwenden.
Das Finden der aktuellen Größe des Desktops kann über "das Zentrieren eines Fensters auf dem Desktop" ermittelt werden.
Lösungsansatz:
äussere Klasse, die über die innere Klasse muss:
Erstellen Sie eine Anwendung, in der Sie die Position des Fensters der Anwendung über vier Schaltflächen verändern können. Eine Schaltfläche soll das Fenster um 20 Pixel nach oben verschieben, eine um 20 Pixel nach unten und die beiden anderen um je 20 Pixel nach links beziehungsweise rechts.
Frage hierzu: muss das in einen Konstruktor? Ich habe es nicht ganz begriffen, gibt es bei den grapfischen Oberflächen keine Main Class mehr sondern eine Konstruktor Class als Testklasse? Bitte um Erläuterungen, wer was Genaueres dazu weiss. Danke im Voraus.
===
Ordnen Sie die Schaltflächen in einem BorderLayout mit einem Abstand von 25 Pixeln an.
===
Innere Klasse für Listener verarbeitet Ereignisse aller 4 Schaltflächen.
das ist die innere Klasse die wir in die äussere einfügen müssen
===
Aufgabenstellung:
Stellen Sie sicher, dass das Fenster nicht aus dem Desktop herausgeschoben werden kann. Ermitteln Sie dazu die aktuelle Größe des Desktops und berechnen Sie dann die maximal möglichen Koordinaten für die Verschiebung nach rechts und nach unten. Für die Verschiebung nach links beziehungsweise oben können Sie den Wert 0 als Grenze verwenden.
=
Anhaltspunkte zum Lösen:
über die Methode Toolkit.getDefaultToolKit().getScreenSize() die aktuelle Bildschirmauflösung ermitteln. Die Methode liefert die Werte als einen Typ Dimension zurück. Dimension.width enthält dabei die Breite und Dimension.height die Höhe.
Von diesen Werten ziehen Sie jeweils die aktuelle Größe des Fensters ab und teilen das Ergebnis durch 2. Die Breite des Fensters erhalten Sie durch getSize().width und die Höhe durch getSize().height.
Ausprogrammiert könnte das Zentrieren eines Fensters auf dem Desktop so aussehen:
//die Bildschirmauflösung beschaffen und in einer
//Variablen vom Typ Dimension speichern
//bitte jeweils als eine Zeile eingeben
Dimension bGroesse= Toolkit.getDefaultToolkit(). getScreenSize();
//das Fenster positionieren
setLocation((bGroesse.width – getSize().width) / 2,
(bGroesse.height – getSize().height) / 2);
Ein wenig einfacher geht das Zentrieren mit der Anweisung
setLocationRelativeTo(null);
Die Methode setLocationRelativeTo() setzt eigentlich die Position eines Fensters relativ zu einer anderen Komponente. Durch das Argument null wird das Fenster aber zentriert auf dem Desktop dargestellt.
=========================================
Das bis jetzt waren alles Code-Entwürfe (ungegliedert).
=========================================
jetzt kommt der Code-Strukturvorschlag (in welcher Reihenfolge alles programmiert werden muss):
Fachfrage: Konstruktor (Instanzen anlegen) beim GUI, müssen wir immer eine zusätzliche Klasse haben beim GUI, ist es anders als auf der Grundlagenebene ( Klasse/n & eine Main-Klasse, das wars). Ist es beim GUi anders? Ist die Konstruktor Klasse als Main Klasse anzusehen? Weil wir dort Instanzen der Variablen aus der public class erzeugen und Werte zuweisen, die Methoden und Komponenten (Instanzvariabeln) also bearbeiten, ihnen Werte zuwesien, sie manipulieren, gestalten, etc.
Wo bleibt die Main Klasse = Test-Klasse?
bitte um eure Unterstützung bei der Lösung dieser komplexen Aufgabe. Danke im Voraus.
Aufgabenstellung:
Erstellen Sie eine Anwendung, in der Sie die Position des Fensters der Anwendung über vier Schaltflächen verändern können. Eine Schaltfläche soll das Fenster um 20 Pixel nach oben verschieben, eine um 20 Pixel nach unten und die beiden anderen um je 20 Pixel nach links beziehungsweise rechts.
Beachten Sie bei der Umsetzung bitte die folgenden Vorgaben:
Erstellen Sie für den Listener eine innere Klasse in der Klasse mit dem Fenster der Anwendung. Der Listener soll die Ereignisse aller vier Schaltflächen verarbeiten können.
Setzen Sie das Fenster der Anwendung fest auf die Größe 400 × 400 und positionieren Sie es zunächst an einer beliebigen Stelle auf dem Desktop.
Ordnen Sie die Schaltflächen in einem BorderLayout mit einem Abstand von 10 Pixeln an.
Stellen Sie sicher, dass das Fenster nicht aus dem Desktop herausgeschoben werden kann. Ermitteln Sie dazu die aktuelle Größe des Desktops und berechnen Sie dann die maximal möglichen Koordinaten für die Verschiebung nach rechts und nach unten. Für die Verschiebung nach links beziehungsweise oben können Sie den Wert 0 als Grenze verwenden.
Das Finden der aktuellen Größe des Desktops kann über "das Zentrieren eines Fensters auf dem Desktop" ermittelt werden.
Lösungsansatz:
äussere Klasse, die über die innere Klasse muss:
Java:
public class FensterPositionVerschiebungGUI extends JFrame{
//vier Schaltflächen als Instanzvariablen
private JButton schaltflaecheO, schaltflaecheU, schaltflaecheR, schaltflaecheL; //für die Verschiebung
Erstellen Sie eine Anwendung, in der Sie die Position des Fensters der Anwendung über vier Schaltflächen verändern können. Eine Schaltfläche soll das Fenster um 20 Pixel nach oben verschieben, eine um 20 Pixel nach unten und die beiden anderen um je 20 Pixel nach links beziehungsweise rechts.
Java:
//4 Schaltflächen erzeugen:
JButton schaltflaecheO = new JButton (Fenster nach oben);
JButton schaltflaecheU = new JButton (Fenster nach unten);
JButton schaltflaecheL = new JButton (Fenster nach links);
JButton schaltflaecheR = new JButton (Fenster nach rechts);
//adden von Schaltflächen
add(schaltflaecheO);
add(schaltflaecheU);
add(schaltflaecheL);
add(schaltflaecheR);
==
//Fenstergrösse der Anwendung setzen
fenster.setSize(400, 400); //Breite 400 & Höhe 400
Frage hierzu: muss das in einen Konstruktor? Ich habe es nicht ganz begriffen, gibt es bei den grapfischen Oberflächen keine Main Class mehr sondern eine Konstruktor Class als Testklasse? Bitte um Erläuterungen, wer was Genaueres dazu weiss. Danke im Voraus.
===
Ordnen Sie die Schaltflächen in einem BorderLayout mit einem Abstand von 25 Pixeln an.
Java:
setLayout(new BorderLayout());
//beim BorderLayout: Argument des gewünschten Bereichs angeben
BorderLayout.NORTH
BorderLayout.SOUTH
BorderLayout.EAST
BorderLayout.WEST
BorderLayout.CENTER
==
// Abstand über setVgap(25) setHgap(25) //Abstand 25 pixel vertikal & horizontal
==
===
Innere Klasse für Listener verarbeitet Ereignisse aller 4 Schaltflächen.
das ist die innere Klasse die wir in die äussere einfügen müssen
Java:
class SchaltflaechenListenerInner implements ActionListener{
//Instanzvariablen für horizontale & vertikale Verschiebung
private int x, y;
/Methode actionPerformed wird beim Klicken auf Schaltflächen aufgerufen
public void actionPerformed(ActionEvent e) {
// Methode actionComman liefert Text, der auf Schaltfläche steht
//wenn schaltflaecheL geklickt, dann
if (e.getActionCommand().equals("Fenster nach links")){
// um 20 nach links verschieben
setLocation(x-20, y);
}
if (e.getActionCommand().equals("Fenster nach rechts")){
setLocation(x+20, y);
}
if (e.getActionCommand().equals("Fenster nach oben")){
setLocation(x, y-20);
}
if (e.getActionCommand().equals("Fenster nach unten")){
setLocation(x, y+20);
}
}
}
===
Aufgabenstellung:
Stellen Sie sicher, dass das Fenster nicht aus dem Desktop herausgeschoben werden kann. Ermitteln Sie dazu die aktuelle Größe des Desktops und berechnen Sie dann die maximal möglichen Koordinaten für die Verschiebung nach rechts und nach unten. Für die Verschiebung nach links beziehungsweise oben können Sie den Wert 0 als Grenze verwenden.
=
Anhaltspunkte zum Lösen:
über die Methode Toolkit.getDefaultToolKit().getScreenSize() die aktuelle Bildschirmauflösung ermitteln. Die Methode liefert die Werte als einen Typ Dimension zurück. Dimension.width enthält dabei die Breite und Dimension.height die Höhe.
Von diesen Werten ziehen Sie jeweils die aktuelle Größe des Fensters ab und teilen das Ergebnis durch 2. Die Breite des Fensters erhalten Sie durch getSize().width und die Höhe durch getSize().height.
Ausprogrammiert könnte das Zentrieren eines Fensters auf dem Desktop so aussehen:
//die Bildschirmauflösung beschaffen und in einer
//Variablen vom Typ Dimension speichern
//bitte jeweils als eine Zeile eingeben
Dimension bGroesse= Toolkit.getDefaultToolkit(). getScreenSize();
//das Fenster positionieren
setLocation((bGroesse.width – getSize().width) / 2,
(bGroesse.height – getSize().height) / 2);
Ein wenig einfacher geht das Zentrieren mit der Anweisung
setLocationRelativeTo(null);
Die Methode setLocationRelativeTo() setzt eigentlich die Position eines Fensters relativ zu einer anderen Komponente. Durch das Argument null wird das Fenster aber zentriert auf dem Desktop dargestellt.
=========================================
Das bis jetzt waren alles Code-Entwürfe (ungegliedert).
=========================================
jetzt kommt der Code-Strukturvorschlag (in welcher Reihenfolge alles programmiert werden muss):
Fachfrage: Konstruktor (Instanzen anlegen) beim GUI, müssen wir immer eine zusätzliche Klasse haben beim GUI, ist es anders als auf der Grundlagenebene ( Klasse/n & eine Main-Klasse, das wars). Ist es beim GUi anders? Ist die Konstruktor Klasse als Main Klasse anzusehen? Weil wir dort Instanzen der Variablen aus der public class erzeugen und Werte zuweisen, die Methoden und Komponenten (Instanzvariabeln) also bearbeiten, ihnen Werte zuwesien, sie manipulieren, gestalten, etc.
Wo bleibt die Main Klasse = Test-Klasse?
Java:
// verschiedene importe
public class FensterPositionVerschiebungGUI extends JFrame{
//vier Schaltflächen als Instanzvariablen
private JButton schaltflaecheO, schaltflaecheU, schaltflaecheR, schaltflaecheL; //für die Verschiebung
// nach Instanzvariablen die innere Klasse
//das ist die innere Klasse die wir in die äussere einfügen müssen
class SchaltflaechenListenerInner implements ActionListener{
//Instanzvariablen für horizontale & vertikale Verschiebung
private int x, y;
/Methode actionPerformed wird beim Klicken auf Schaltflächen aufgerufen
public void actionPerformed(ActionEvent e) {
// Methode actionComman liefert Text, der auf Schaltfläche steht
//wenn schaltflaecheL geklickt, dann
if (e.getActionCommand().equals("Fenster nach links")){
// um 20 nach links verschieben
setLocation(x-20, y);
}
if (e.getActionCommand().equals("Fenster nach rechts")){
setLocation(x+20, y);
}
if (e.getActionCommand().equals("Fenster nach oben")){
setLocation(x, y-20);
}
if (e.getActionCommand().equals("Fenster nach unten")){
setLocation(x, y+20);
}
}
}
// Ende der inneren Klasse
Java:
//der Konstruktor
//er erzeugt die Komponenten und setzt die
//Fenstereinstellungen
public FensterPositionVerschiebungGUI(String titel) {
//den Konstruktor der Basisklasse aufrufen und den
//Fenstertitel übergeben (wo sollen wir den Titel hernehmen?)
super(titel);
JButton schaltflaecheO = new JButton (Fenster nach oben);
JButton schaltflaecheU = new JButton (Fenster nach unten);
JButton schaltflaecheL = new JButton (Fenster nach links);
JButton schaltflaecheR = new JButton (Fenster nach rechts);
setLayout(new BorderLayout());
//beim BorderLayout: Argument des gewünschten Bereichs angeben
BorderLayout.NORTH
BorderLayout.SOUTH
BorderLayout.EAST
BorderLayout.WEST
BorderLayout.CENTER
fenster.setSize(300, 300); //Breite 300 & Höhe 300 S.42
add(schaltflaecheO);
add(schaltflaecheU);
add(schaltflaecheL);
add(schaltflaecheR);
//den Listener verbinden
MeinKompakterListener listener = new MeinKompakterListener();
addActionlistener(listener);
schaltflaecheO.addActionListener(listener);
schaltflaecheU.addActionListener(listener);
schaltflaecheR.addActionListener(listener);
schaltflaecheL.addActionListener(listener);
//das Fenster packen
pack();
//die Standardaktion beim Schließen festlegen
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//das Fenster anzeigen setVisible(true);
bitte um eure Unterstützung bei der Lösung dieser komplexen Aufgabe. Danke im Voraus.