[Java] Gui Layout (in externer Klasse) erstellen

Dieses Thema im Forum "Programmierung & Entwicklung" wurde erstellt von AfG-RnB, 11. Dezember 2009 .

  1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen
  1. #1 11. Dezember 2009
    Zuletzt von einem Moderator bearbeitet: 14. April 2017
    Gui Layout (in externer Klasse) erstellen

    Hi Leute,

    wie der Titel schon sagt möchte ich einen GUI Layout in Java (Eclipse) erstellen.

    Einleitend:
    - Für meine Studienarbeit soll ich ein Flugbuchungssystem erstellen
    - ich möchte ein Design für mehrere Screens verwenden
    - ich bitte euch mal die JPG Datei im Anhang zu öffnen

    [​IMG]

    Bild:
    - auf dem Bild sieht man mein Layout (mit Qualitätsverlust dank Paint :)) so wie ich es mir
    ungefähr vorstelle
    - Die Grün umkreisten Felder sind JLabels, die ich individuell übergeben möchte
    - Die türkisen Rechtecke stellen Panels dar, die ich auch individuell übergeben möchte

    Problem:
    - da ich in Java, was Klassen betrifft nicht so fit bin benötige ich Eure Hilfe bei der Umsetzung.

    Frage:
    - Ist es möglich, dass ich eine Klasse erstelle mit dem Layout. Dieses Layout beinhaltet den Container im Hintegrund, das darauf liegende Panel mit Design und die Positionen (Größe) der übergebenen Labels, Panels.
    - Kann ich viele verschiedene Klassen erstellen und dafür dieses Design verwenden? Ich möchte nur die Textfelder für jedes einzelne Screen Übergeben und den Transparenten Panel mit Inhalt, sowie den durchsichtigen Panel mit den Buttons.

    Wie mache ich das am besten?
     

  2. Anzeige
    Heute: Deals & Sale mit stark reduzierten Angeboten finden.
  3. #2 11. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Ich hoffe, ich hab dich jetzt richtig verstanden.

    Versuch's doch einfach so:

    Du baust dir folgende Klassen:
    Code:
    [I]MainFrame.java[/I]: repräsentiert deinen JFrame und fungiert als Container für alles Weitere.
     |
     +--- [I]TitleBar.java[/I]: ist einfach deine Leiste oben.
     | |
     | +---[I]WelcomeLabel.java[/I]: Dein Label mit dem "Willkommen"
     | |
     | +--- [I]OtherLabel.java[/I]: Kann leider gerade nicht lesen, was da stehen soll ;)
     |
     |
     +---[I] AirlineLabel.java[/I]: Dein Label mit dem Text "IndividualAirline2009"
     |
     +--- [I]ContentPanel.java[/I]: Dein Panel mit dem halbtransparenten Hintergrund
     | |
     | +-- Hier so Sachen wie JTextField oder was auch immer du da haben möchtest
     |
     +--- [I]ButtonPanel.java[/I]: Dein Panel, in dem sich die Buttons befinden
     |
     +-- Hier deine beiden JButtons und alles, was sonst so rein soll
    
    Das wäre eine Möglichkeit, das in verschiedene Klassen aufzuteilen. Wenn es dir aber nur darum geht, den Text der Labels dynamisch verändern zu können, dann kannst du auch einfach entsprechende set-Methoden implementieren:

    Code:
    public void setAirlineLabel(String labelText) {
     this.airlineLabel.setText(labelText);
    }
    
    Und die Methode packst du dann halt in die Klassen rein, in denen die jeweiligen Labels deklariert werden.

    Vielleicht konnt ich dir ja n bisschen helfen, weiß aber wie gesagt nicht, ob ich deine Frage überhaupt richtig verstanden habe ;)
     
  4. #3 11. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Hi danke für Deine Antwort.
    Also ich verwende ein Null Layout. Und setze die größen + Positionen.
    Ich möchte eine Klasse erstellen die auf mein Layout zugreift. Als übergabe soll er die 3 individuellen texte geben, den transparenten panel, und den ButtonPanel.
    So dass ich immer dieses Layout verwende, aber individuell für mein persönliches Screen anpasse.

    Hier mein Code:
    (Ich weiß die Struktur etc. ist nicht fein, an manchen Stellen muss ich noch einiges verbessern)

    Code:
     
    public class Hauptmenü extends JFrame{
     // Individuelle Übergabe der Texte für diesen Screen
     
     String Text1 = ("Hauptmenü");
     String Text2 = ("Hilfe");
     String Text3 = ("Individual Airlines");
     
     /** BEGINN DES LAYOUTS 
     * --------------------------------------------------------------*/
     
     //Komponenten die benötigt werden (Variablen deffinieren)
     Container backContainer;
     JPanel LayoutPanel;
     JPanel IndividualPanel;
     JPanel ButtonPanel;
     
     JLabel LayoutText, LayoutStrich, LayoutHelp, LayoutHeadline, LayoutBackground, LayoutBackground2;
     
     public Hauptmenü() {
     //Container bestimmen, Layout und Hintergrundfarbe setzen
     backContainer = getContentPane(); 
     backContainer.setLayout(null); 
     
     //LayoutPanel bestimmen, Layout setzen, Rahmen und Hintergrundfarbe setzen, dem Container hinzufügen
     LayoutPanel = new JPanel();
     LayoutPanel.setLayout(null); 
     LayoutPanel.setBackground(new Color(230,230,200)); 
     LayoutPanel.setBorder(new SoftBevelBorder(SoftBevelBorder.RAISED, Color.red.darker(), Color.red));
     backContainer.add(LayoutPanel); 
     LayoutPanel.setBounds(5,5,784,585);
    
     //Komponenten erstellen
     LayoutText = new JLabel(Text1);
     LayoutHelp = new JLabel(Text2);
     LayoutStrich = new JLabel("___________________________________________________________________" +
     "___________________________________________");
     LayoutHeadline = new JLabel(Text3);
     
     //Schriftarten setzen
     LayoutText.setFont(new Font("SansSerif", Font.PLAIN,18));
     LayoutHelp.setFont(new Font("SansSerif", Font.ITALIC, 12));
     LayoutHeadline.setFont(new Font("Calligraphic", Font.BOLD, 40));
     LayoutHeadline.setHorizontalAlignment(SwingConstants.LEFT);
     LayoutHeadline.setForeground(Color.white);
     
     //Farben setzen
     LayoutText.setForeground(Color.white);
     LayoutHelp.setForeground(Color.blue);
     LayoutStrich.setForeground(Color.red.darker());
     
     //Positionen bestimmen und dem LayoutPanel hinzufügen
     LayoutText.setBounds(7,5,500,35);
     LayoutPanel.add(LayoutText);
     
     LayoutHelp.setBounds(750,17, 50, 15);
     LayoutPanel.add(LayoutHelp);
     
     LayoutStrich.setBounds(7, 15, 800, 20);
     LayoutPanel.add(LayoutStrich);
     
     LayoutHeadline.setBounds(18,85,784,200);
     LayoutPanel.add(LayoutHeadline); 
     
     
     // Individuellen Panel erstellen und transparent machen:
     IndividualPanel = new Transparent(0.5f);
     IndividualPanel.setBounds(20,210,745,315); //Position, größe
     IndividualPanel.setBorder(BorderFactory.createLineBorder(Color.red.darker())); //Rahmen
     LayoutPanel.add(IndividualPanel); //dem Panel hinzufügen
     
     //Button Panel erstellen
     ButtonPanel = new JPanel();
     ButtonPanel.setLayout(null);
     ButtonPanel.setBounds(20,530, 745,50);
     ButtonPanel.setBackground(Color.white);
     ButtonPanel.setOpaque(false);
     LayoutPanel.add(ButtonPanel);
     
     
     // Notlösung für Hintergrundbild (im JPanel)
     Icon Background = new ImageIcon("flugzeug11.jpg"); // weitere: flugzeug11.jpg , flugzeug, Background, 
     LayoutBackground = new JLabel(Background);
     LayoutBackground.setBounds(2,2,781,582);
     LayoutPanel.add(LayoutBackground);
     
     
     /** Hier endet das Layout, ab jetzt beginnt die Füllung des individuellen und des Button panels */
     
     //Button für "ButtonPanel" erstellen:
     JButton Next = new JButton("Weiter");
     Next.setFont(new Font("SansSerif", Font.BOLD,14));
     Next.setBounds(590,5,100,30);
     ButtonPanel.add(Next);
    
     
     }
     public static void main(String[] args) {
     Hauptmenü fenster = new Hauptmenü();
     fenster.setTitle("Hauptmenu");
     fenster.setSize(800,625);
     fenster.setLocationRelativeTo(null);
     fenster.setVisible(true);
     fenster.setResizable( false );
     fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
     }
    
    }
     
    Ich hab jetzt ein Layout das ich per Copy und Taste immer neu einfüge. Und dann die beiden Panels nur individuell fülle.
    Aber ich würd das gern über eine externe klasse machen ohne das Layout so zu kopieren.
    
     
  5. #4 11. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Dann erstell dir 2 zusätzliche Klassen:

    Einmal eine Klasse TransparentPanel.java und eine ButtonPanel.java.
    Da dies (neben den Label-Texten) das einzige ist, was du individualisieren möchtest, lagerst du das einfach in diese Klassen aus.

    In deine "Hauptmenü.java" (übrigens ein _SEHR_ ungünstiger Name. Umlaute haben - abgesehen von Strings - nichts in deinem Java-Code verloren!) schreibst du dann folgendes rein:

    Code:
    public class Hauptmenue extends JFrame {
     // Komponenten initialisieren
     // ...
     private TransparentPanel transparentPanel;
     private ButtonPanel buttonPanel;
     
     public Hauptmenue(TransparentPanel tpanel, ButtonPanel bpanel, String text1, String text2, String text3) {
     
     // Hier die ganzen Layout-Anweisungen
     // ...
     LayoutText = new JLabel(text1);
     LayoutHelp = new JLabel(text2);
     LayoutHeadline = new JLabel(text3);
     // ...
    
     transparent Panel = tpanel;
     buttonPanel = bpanel;
     
     // ...
     this.add(tpanel);
     this.add(bpanel);
    
     // ...
     }
     
    }
    
    Und den ganzen Kram, wie dein TransparentPanel aussehen soll, was da rein kommt, wie groß es ist und so weiter packst du einfach in deine TransparentPanel.java - Klasse. Genauso machst du's mit ButtonPanel.java.

    Dann schreibst du dir einfach eine Klasse, die das ganze noch aufruft. Diese Klasse erstellt dann jeweils ein TransparentPanel und ein ButtonPanel sowie drei Strings und ruf dann Hauptmenue.java auf und übergibt im Konstruktor die zuvor erstellten Panels bzw. Labels.

    Und noch was: Gibt es einen besonderen Grund, warum du ein null-Layout verwendest?
     
  6. #5 11. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Hi danke dir, du hilfst mir echt weiter.
    Aber ganz versteh ichs nicht....

    Wenn ich 2 Klassen erstelle mit TransparentPanel und ButtonPanel
    inkl. dem ganzen Kram (Inhalt, größe etc.)
    dann diese über eine dritte Klasse aufrufe - dann sind ja die Panels nicht individuell anwendbar auf alle Klassen?!


    Ich brauche ein Layout
    - dann erstelle ich mehrere Klassen
    - eine Klasse "Hauptmenue" mit Übergabe der individuellen Panels & Strings
    - eine Klasse "Kunde anlegen" mit Übergabe der individuellen Panels & Strings
    - eine Klasse "Kunde ändern " mit Übergabe der individuellen Panels & Strings
    - usw.

    Verstehst du mich?
    Somit muss ich nur einmal das Layout erstellen. Und dieses Layout verwende ich für alle übrigen Klassen. Die übrigen Klassen Übergeben nur den Inhalt der Panels und die Strings an mein Layout.

    Ist das Möglich?


    // Der Grund warum ich es so haben will, ist dass wir zu zweit an der Studienarbeit arbeiten. So
    // können wir zusammen ein Layout erstellen und die Panels uns aufteilen. Dann passen die Guis
    // zueinander.

    Wieso ich ein Null Layout verwende?
    > Hmm als ich anfing mir die Gui Programmierung (vor ca. 3 Wochen) beizubringen - hat mir ein Freund
    > empfohlen das Null Layout zu verwenden. Da ist man flexibler was die Aufteilung betrifft. Naja bin mir
    > aber auch sicher das es mit anderen Layouts (kombiniert) gehen würde.
     
  7. #6 14. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Hmm.. okay, dann hab ich dich anscheinend falsch verstanden.

    Um es noch einmal ganz klar zu haben: Du arbeitest mit einem Kollegen an einem Projekt. Du machst die GUI, er die Programmlogik. Und jetzt möchtest du es so kapseln, dass er wirklich nur Programmlogik und du nur GUI-Code schreibst, richtig?

    Und dabei soll er dann einfach nur den Inhalt in Form von Strings für die Panels übergeben.

    Dann brauchen wir gar nicht so kompliziert denken. Du könntest in diesem Fall auch deine gesamte GUI in eine Klasse packen und dann entsprechende set-Methoden schreiben.

    Mal angenommen, du möchtest, dass in deiner GUI drei Labels geändert werden sollen vom Text her, dann machst du einfach folgendes:

    Code:
    public class GUI extends JFrame {
     private JLabel titleLabel, menuLabel, blaLabel;
    
     // Zugriff auf den Text der Labels machst du einfach über folgende Methoden
     public void setTitleLabelText(String text) {
     titleLabel.setText(text);
     }
    
     public void setMenuLabelText(String text) {
     menuLabel.setText(text);
     }
    
     public void setBlaLabelText(String text) {
     blaLabel.setText(text);
     }
    }
    
    Und weiter unten legst du halt dein Layout und so weiter fest. In diesem Falle bräuchte dein Kollege einfach nur folgendes machen, um eine GUI mit entsprechende Werten zu erstellen:

    Code:
    public class TestProgramm {
     private GUI gui = new GUI();
    
     public void initGui() {
     gui.setTitleLabel("SaudiAirlines");
     gui.setMenuLabel("Kundenmenü");
     gui.setBlaLabel("Bla");
     }
    }
    
    Natürlich müsste beides noch um den entsprechenden Rest angereichert werden, aber das versteht sich ja von selbst.

    Wenn du jetzt nicht nur den Text von Labels sondern meinetwegen auch von JButtons verändern willst oder auch in dein transparentes Panel ne ListView einfügen willst, dann schreibst du dir auch entsprechende Set-Methoden (unbedingt darauf achten, dass diese Public sind!) und übergibst in diesen einfach den entsprechenden Inhalt aus dem Code deines Kollegen. Dieser Inhalt wird dann einfach per setText()-Methoden der entsprechenden Komponenten oder ähnlich eingefügt.

    Hab ich dich jetzt richtig verstanden?

    Edit: Zum Thema Null-Layout:
    Dein Freund hat scheinbar nicht ganz so viel Ahnung von der Materie ;)
    Es ist so: Beim Null-Layout gibst du selber alles an. Größe, Position und so weiter. Das mag auf den ersten Blick einfach erscheinen, weil sich das Layout so verhält, wie man es sich wünscht. Doch sollte man sich eher auf Javas LayoutManager verlassen. Diese bieten den Vorteil, dass sie die Komponenten auch nach aktuellem Bedarf anpassen können und somit mehr Flexibilität bieten. Zwar muss man erst verstehen, wie sie arbeiten, aber das ist nicht wirklich kompliziert. Und sie haben einen enormen Vorteil: Du bist viiieeeel flexibler. Stell dir einfach mal folgendes vor:
    Du entwickelst deine GUI auf einem Fullscreen Monitor mit der Auflösung 1280 * 1024. Bei dir sieht mit deinem NullLayout alles super aus. Jetzt soll dein Programm aber unter einer Auflösung von 1024 * 768 oder auf einem Widescreen-Monitor ausgeführt werden und auf einmal ist die hälfte deiner Applikation gar nicht mehr zu sehen. Ein LayoutManager würde jetzt anpassen und dafür sorgen, dass alles an seinem Platz ist und in der neuen Situation gut aussieht.

    Aber das Ändern auf LayoutManager würde ich erst mal nicht mehr in Angriff nehmen, wenn du schon alles für dein NullLayout angepasst hast. Aber für's nächste Mal weißt du bescheid ;)
     
  8. #7 14. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Hi vielen Dank,

    wenn ichs so bedenke hast du ja Recht mit dem Null Layout. Wenn ich Zeit habe werde ich es ändern.

    Ich könnte doch eine abstrakte Klasse machen, die von JPanel erbt und darauf alles layouten, bzw. alle grundsätzlichen Dinge dort erstellen - oder?.
    Via Getter / Setter / etc. kann ich dann wie du beschrieben hast dann die jeweiligen Texte und Teile setzen.

    SO jetzt habe ich die abstrakte Klasse Layout erstellt:
    Code:
    public abstract class Layout extends JPanel{
     // Komponente, die von anderen Klassen individuell übergeben werden
     protected JLabel lblTitle = null;
     protected JLabel lblWelcome = null;
     protected JLabel lblHelp = null;
     
     protected JPanel pnlMain = null;
     protected JPanel pnlButtons = null; 
     
     
     public void setWelcomeText(String welcomeText)
     {
     lblWelcome.setText(welcomeText);
     lblWelcome.setForeground(Color.red);
     }
     
     public void setHelpText(String helpText)
     {
     lblHelp.setText(helpText);
     lblHelp.setForeground(Color.blue);
     }
     
     public void setTitleText(String titleText)
     {
     lblTitle.setText(titleText);
     lblTitle.setForeground(Color.white);
     }
     
     public void setMainPanel(JPanel mainPanel)
     {
     //altes MainPanel entfernen
     if (pnlMain != null)
     this.remove(pnlMain);
     
     pnlMain = mainPanel;
     this.add(pnlMain); // je nach LayoutMgr
     }
     
     public void setButtonPanel(JPanel buttonPanel)
     {
     //altes ButtonPanel entfernen
     if (pnlButtons != null)
     this.remove(pnlButtons);
     
     pnlButtons = buttonPanel;
     this.add(pnlButtons);
     }
     
     /**---------------------- Beginn des Layouts --------------------*/
     
     protected JPanel pnlBackground; //Hintergrund
     protected JPanel pnlLayout; //Das Layout Panel
     
     public Layout(){
     
     //Background Panel erstellen (in grau)
     pnlBackground = new JPanel();
     pnlBackground.setLayout(null);
     pnlBackground.setBackground(Color.gray.brighter()); 
     pnlBackground.setBounds(0,0,800,600);
     
     //Layout Panel erstellen (auf dem BackgroundPanel)
     pnlLayout = new JPanel();
     pnlLayout.setLayout(null); 
     pnlLayout.setBackground(new Color(230,230,200)); 
     pnlLayout.setBorder(new SoftBevelBorder(SoftBevelBorder.RAISED, Color.red.darker(), Color.red));
     pnlBackground.add(pnlLayout); 
     pnlLayout.setBounds(5,5,784,585);
     
     //Übergebene Panels & Labels ins Layout einbinden
     pnlLayout.add(lblWelcome);
     pnlLayout.add(lblTitle);
     pnlLayout.add(lblHelp);
     lblWelcome.setBounds(20,20,200,100);
     lblTitle.setBounds(100,300, 200,100);
     lblHelp.setBounds(300,300,200,100);
     
     
     }
     
    }
    
    Dann habe ich eine Beispiel Klasse erstellt. Aber ich kann irgendwie nicht auf die Klasse zugreifen
    Bzw. die individuellen Werte übergeben ...
    Code:
     
    public class Beispiel extends JFrame{
     
     
     Layout gui = new Layout(); //Fehlermeldung bei Layout()
    
     public void initLayout() {
     gui.setWelcomeText("SaudiAirlines");
     gui.setTitleText("Kundenmenü");
     gui.setHelpText("Bla");
     }
     
     
     public static void main(String[] args) {
     Beispiel fenster = new Beispiel();
     fenster.setTitle("Hauptmenu");
     fenster.setSize(800,625);
     fenster.setLocationRelativeTo(null);
     fenster.setVisible(true);
     fenster.setResizable( false );
     fenster.add(gui); // Fehlermeldung bei gui
     fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
     }
     
    }
    
     
  9. #8 14. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    hallo AfG-RnB

    Abstrakte Klassen können nicht aufgerufen werden sie bieten nur ein Grundgerüst für Klassen die von diesen abgeleitet sind.
    Ich denke wenn du eine Klasse von der Abstrakten ableitest ,müsstest du die entsprechenden Parameter an die Abgeleitete Klasse (nicht abstract) übergeben können.
    Oder du entfernts einfach das abstract aus der Klasse, dann müsste es eigentlich auch gehen.

    als Layoutmanager kann ich in deinem Fall dass Borderlayout empfehlen.

    hoffe ich konnte helfen

    gruß JacK0
     
  10. #9 14. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    auch wenn ich das abstrakte weg lasse funktioniert es nicht. Aaargh
     
  11. #10 15. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Von abstrakten Klassen können keine Objekte erzeugt werden. Sie sind nur dazu da, damit andere Klassen von ihnen erben können. Lass das abstract einfach weg.
    Wie heißen denn die Fehlermeldungen?

    Und noch was: Du initialisiert die JLabels wie folgt:
    Code:
    protected JLabel welcomeLabel = null;
    
    Damit verweist welcomeLabel auf null, ist aber noch kein JLabel-Object. Wenn du jetzt setText() auf welcomeLabel anwenden willst, muss irgendwo vorher auf jeden Fall mal sehen welcomeLabel = new JLabel();, sonst wird das nichts.
    Kannste ja auch ruhig direkt in die ersten Zeilen mit reinschreiben, also:
    Code:
    protected JLabel welcomeLabel = new JLabel();
    
    Und dann später mit setWelcomeText() einfach nur den Text und alles andere verändern.
     
  12. #11 16. Dezember 2009
    AW: Gui Layout (in externer Klasse) erstellen

    Hi stimmt, da lag mein problem ich hatte kein JLabel erstellt also kann ich die
    setTest methode garnicht anwenden.
    Hab es jetzt hingekriegt.

    Ich habe die Abstrakte Klasse Layout erstellt.
    Und alle folge Screens wie
    Anmeldung,
    Flug anlegen
    Flug ändern
    usw.
    erben jetzt von Layout. Es werden nur die individuellen JLabels übergeben und es funktioniert.
    Muss noch das mit den individuellen Panels machen dann ist alles perfekt.

    Danke dir :)
     

  13. Videos zum Thema
Die Seite wird geladen...
Similar Threads - Java Gui Layout
  1. Antworten:
    4
    Aufrufe:
    911
  2. Antworten:
    0
    Aufrufe:
    808
  3. Antworten:
    17
    Aufrufe:
    1.606
  4. Antworten:
    6
    Aufrufe:
    1.298
  5. Antworten:
    14
    Aufrufe:
    1.309