Methoden pack();

DoppelFabi

Aktives Mitglied
Hey,

Ich habe in meinem Code ein pack(); weil sonnst gar nichts angezeigt wird.
Was ist genau die Funktion von pack? Ich habe nur sowas gelesen wie: "es packt alles zusammen". Aber genau was drunter vorstellen kann ich mir nicht.^^
 

DoppelFabi

Aktives Mitglied
Dort steht, dass pack die Größe des Fenster anpasst, aber ich habe davor schon ein setSize aber das Fenster bekommt nur die ganzen JLabels, wenn pack ungefähr am Ende steht. Also vor setVisible und bissl addstuff.
 

mihe7

Top Contributor
Aber genau was drunter vorstellen kann ich mir nicht.
Einfach gesagt: pack() passt die Größe des Fensters an dessen Inhalt an und validiert das Fenster.

aber das Fenster bekommt nur die ganzen JLabels, wenn pack ungefähr am Ende steht. Also vor setVisible und bissl addstuff.
pack() ist nicht notwendig (meist aber sinnvoll). Man müsste den Code sehen. Daumenregel: so lange das Fenster nicht schon angezeigt wird, sollte es keine Probleme geben, wenn Du Komponenten zum Fenster hinzufügst und am Ende setVisible aufrufst.
 

DoppelFabi

Aktives Mitglied
Man müsste den Code sehen.
Ich habe alles ein wenig umgestellt, damit man überhaupt was sieht. Weil manche Sachen musste nach pack damit die angezeigt werden.

Java:
public class Window extends JFrame
{

    private JFrame Window = new JFrame("Doxingsystem");
    private JPanel Panel;

    public void adding(Component comp)
    {

        Panel.add(comp);

    }

    public Window()
    {

        Panel = new JPanel();

        Window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        Window.add(Panel);
        Window.pack();
        Window.setSize(1800, 861); //Musste ich wegen pack umstellen
        Window.setLocationRelativeTo(null); //Musste ich wegen pack umstellen
        Window.setResizable(false); //Musste ich wegen pack umstellen

        Window.setIconImage(getToolkit().getImage("src/main/java/me/system/doxing/Pictures/Icon.jpg")); //Musste ich wegen pack umstellen
        Window.setVisible(true);
    }
}
 

DoppelFabi

Aktives Mitglied
Angemerkt: Es ist nicht der komplett offizieler Code, dies ist der aus einem anderen Beitrag, der aber nicht viel anders ist als der jetzige. Bin zum jetzigen Zeitpunkt auf der Arbeit, deswegen komme ich gerade schlecht an denn Code.
 

fhoffmann

Top Contributor
Java:
public class Window extends JFrame
{
    private JFrame Window = new JFrame("Doxingsystem");
Das sieht sehr komisch aus: Du erbst von JFrame und hast gleichzeitig ein JFrame?
 

MoxxiManagarm

Top Contributor
Java:
public class Window extends JFrame
{
    private JFrame Window = new JFrame("Doxingsystem");

Was ist das für ein gewurschtel? :eek:

Entweder du hast

Java:
public class Window extends JFrame
{
   // ...
    this.setTitle("Doxingsystem");

Oder

Java:
public class Window
{
    private JFrame window = new JFrame("Doxingsystem");
 

DoppelFabi

Aktives Mitglied
Habe mitlerweile:
Code:
public class Window
{
   private JFrame Window = new JFrame("Doxingsystem");

Habe das schon in meinem neuen Code überarbeitet.
 

MoxxiManagarm

Top Contributor
Java:
Window.pack();
       Window.setSize(1800, 861); //Musste ich wegen pack umstellen

pack gehört eigentlich immer kurz vor setVisible. setSize passt mit pack meistens nicht zusammen. Aber wenn du pack verwendest brauchen die Komponenten selbst eine preferredSize
 

MoxxiManagarm

Top Contributor
Würde gerne pack(); nicht mehr in meinem Code haben, aber sonnst werden keine Objekte angezeigt :/
Ich persönlich mochte pack immer, aber wie gesagt, wenn du pack verwendest brauchen die Komponenten eine preferedSize. Beispielsweise hast du entweder:
- Das Fenster, welchem du eine Größe gibst. Entsprechend dem Fenster hat das Panel eine Größe und daran wieder kann sich das Image orientieren.
- Du gibst dem Image eine Größe (prefered Size), dann rufst du pack auf und das Panel+Fenster richten sich nach der Größe des Image.
 

Robat

Top Contributor
Du rufst erst pack() ohne irgendwelche Komponenten auf. Daher hat dein Fenster auch keine Größe, weil keine Komponenten da sind mit denen die Größe des Fenster bestimmt werden kann.
Erst danach fügst du Komponenten hinzu, das Fenster ist aber zu klein um diese anzuzeigen.
Ich würde fast wetten, dass wenn du das Fenster danach manuell per Hand vergrößerst, die Labels auftauchen ;)
 

DoppelFabi

Aktives Mitglied
Ich würde fast wetten, dass wenn du das Fenster danach manuell per Hand vergrößerst, die Labels auftauchen

Kann das Fenster nicht vergrößern, weil:
Java:
Window.setReziable(false);

Daher hat dein Fenster auch keine Größe
Mein Fenster hat eine Größe sie wurde mit setSize gesetzt. Also es wird ja angezeigt auch ohne pack(); aber die Objekte werden nicht angezeigt.
 

mihe7

Top Contributor
Die Labels sind alle in einer anderen Klasse die über der adding Methode zum Panel hinzugefügt wurden.
Das Problem diesbezüglich habe ich Dir doch im anderen Thread schon erklärt: Du zeigst zuerst das Fenster an und fügst dann Komponenten hinzu. Das funktioniert nicht (so einfach), weil durch das Hinzufügen der Container ungültig und nicht neu validiert wird. Man könnte den Container mit roher Gewalt neu validieren, das ist aber der falsche Weg. Du musst einfach Deinen Code anders strukturieren.

Hier mal ein Beispiel, das mit einem Panel ohne Layout-Manager und ohne pack() arbeitet.

Java:
import javax.swing.*;

public class Test {
    public void run() {
        JPanel panel = new JPanel();
        panel.setLayout(null);

        JButton randomPositionButton = new JButton("Pos");
        randomPositionButton.setBounds(100, 100, 80, 20);
        panel.add(randomPositionButton);

        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(panel);
        frame.setVisible(true);
        frame.setSize(800, 600);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Test().run());
    }
}
 

MoxxiManagarm

Top Contributor
Das klingt alles noch nicht richtig. Dir muss nur bewusst sein, was pack macht und benötigt.

Wenn du dem Frame eine feste Größe gibst mit setSize, dann hast du einen Karton, dem du verschiedene Gegenstände (Labels) hineinlegst. Als Resultat hast du entweder viel Platz übrig oder die Gegenstände laufen über. Aber du hast immer den festen Karton. Falls du die Labels nach setVisible hinzufügst musst du auch sicherstellen, dass der Frame neu gezeichnet wird.

Wenn du die Gegenstände in Paketpapier einwickelst, dann ist dein Paket immer so groß wie dein Inhalt, aber du musst bei jedem neuen Gegenstand das Paket neu verpacken, also pack wieder aufrufen. Wenn du aber versuchst aus Papier gebastelte Würfel zu verpacken, dann wirst du keine Freude haben, denn die sind nicht stabil genug. Sie haben gewisser Maßen keine PreferredSize. Es könnte also sein, dass das eingwickelte Paket aussieht als enthält es keine Würfel, denn die haben der Verpackung nachgegeben und sind ganz schön kleine geworden. Ein Würfel aus Holz hingegen ist stabil und das eingewickelte Paket kann nicht kleiner als dieser Holzwürfel werden.
 
Zuletzt bearbeitet:

DoppelFabi

Aktives Mitglied
@mihe7 ich regel es so:

Java:
public class Methoden
{

private Window window;

public Methoden(Window window)
{
this.window = window;


//main:

public class Main
{

public static main(String[] args)
{
Window window = new Window();
Methoden methoden = new Methoden(window);

@MoxxiManagarm ich verstehe was pack macht, es passt die Größe an denn Objekten an.
Aber wenn ich kein pack benutze und nur setSize dann müsste es doch normalerweise gehen
 

mihe7

Top Contributor
Deswegen funktioniert es ja auch nicht.

Schau, es ist ja nicht so, dass es nicht möglich wäre, Komponenten auch im Nachhinein zu einem Fenster hinzuzufügen. Das Problem ist, dass Du versuchst, Swing auf Biegen und Brechen in Deine Code-Struktur zu prügeln. Das Ergebnis ist Code, der für die Tonne ist und es wäre falsch, Dich dabei zu unterstützen.

Aber wenn ich kein pack benutze und nur setSize dann müsste es doch normalerweise gehen
Habe ich Dir doch oben gezeigt, dass es geht.
 

DoppelFabi

Aktives Mitglied
Was würdest du an meiner Stelle anders machen meine Meinung gerade ist, das dass alles funktioniert und ich eigentlich keine Probleme habe außer das man vielleicht ein Befehl nicht unbedingt im Code haben möchte. Am besten mit Beispielen das ich mir etwas drunter vorstellen kann. Für mich ist die Hauptsache, das es funktioniert.
 

MoxxiManagarm

Top Contributor
Was würdest du an meiner Stelle anders machen meine Meinung gerade ist, das dass alles funktioniert und ich eigentlich keine Probleme habe außer das man vielleicht ein Befehl nicht unbedingt im Code haben möchte. Am besten mit Beispielen das ich mir etwas drunter vorstellen kann. Für mich ist die Hauptsache, das es funktioniert.
Es ist eigentlich schon keine gute Praxis Labels von außen in dein Window zu prügeln um beim Wording von mihe zu bleiben :D Du kannst in deinem Window ja überhaupt keinen Einfluss wie viele Labels hineingeschoben werden oder noch schlimmer, wie sie aussehen. Die Bessere Praxis wäre hier eine JList, eventuell zusätzlich in einer ScrollPane. Die JList kannst du auch custom rendern. (https://www.codejava.net/java-se/swing/jlist-custom-renderer-example). Dieser List gibst du ein ListModel. Von außen ergänzt du nur dieses ListModel mit Elementen. Das Neuzeichnen wird dann durch die Verwendung des Models vorgenommen.
 
Zuletzt bearbeitet:

DoppelFabi

Aktives Mitglied
Aber ich habe verschiedene Kategorien von Labels z.b Persönliches: Name, Alter, Wohnort Dann noch: Socials: YouTube Name, … Dort wäre eine Liste nicht brauchbar
 

MoxxiManagarm

Top Contributor
Dann frag ich mich umso mehr warum du die Sachen von außen zu dem Window hinzufügen willst. Dann wäre es besser die Person an das Window zu übergeben und das Window übernimmt das Rendering komplett anhand der Person.
 

httpdigest

Top Contributor
Statt zu versuchen, Gründe zu finden, warum die dir vorgeschlagenen Lösungen nicht funktionieren, könntest du doch nach Wegen suchen, wie du es mit den vorgeschlagenen Lösungen doch hinbekommst.
Oder anders ausgedrückt: "Wer nicht will, findet Gründe. Wer will, findet Wege."
Du könntest dir z.B. mal JGoodies' FormLayout angucken. Es gab noch kein einziges Layout, was ich damit nicht hinbekommen habe. Das ist auch schon lange Standard-Bestandteil vom WindowBuilder.
 

DoppelFabi

Aktives Mitglied
Ich habe denn Beitrag geschrieben um zu wissen, warum ich pack(); brauch oder nicht brauch. Also mein Ziel ist eigentlich nur ein Programm was mit einem JTextField bestimmte Information anzeigt was auch soweit funktioniert.
Aber würde ich alle Labels in die Window Klasse ballern dann wäre sie überfüllt, weil ich noch 200 Methoden machen muss einmal für jeden Label .setText und noch für jeden Label .setBounds dann wäre ich allein für die Labels bei 1300 Zeilen Code.
 

mihe7

Top Contributor
Es geht nicht darum, dass Du Deinen Code gar nicht strukturieren sollst, Du sollst ihn nur anders strukturieren. Damit man sich eine sinnvolle Struktur überlegen kann, muss man aber erst einmal wissen, was man haben will. Die Antwort nach den Anforderungen bist Du ja seit mehreren Threads schuldig, auch wenn wir uns langsam aber sicher nähern.

Für Deinen Beispielcode gibt es eine einfache Lösung: pack deine zwei Labels und Dein Textfeld in eine Klasse. Wenn Du andere Anforderungen hast, musst Du sie schon sagen.

Dann müsste man sich auch mal über das Modell unterhalten: wie sehen die Daten aus, wie stellst Du sie dem UI zur Verfügung? Usw.
 

MoxxiManagarm

Top Contributor
Warum brauchst du dann 200 Methoden??? Du sollst das ja nicht von außen aufrufen. Ja du musst viel style Code schreiben möglicher Weise. Das ist halt Swing und der Grund warum man davon weggeht. Bitte setze aber nicht für jede component setBounds, nutze LayoutManagers
 

mihe7

Top Contributor
Zum Thema 200 Labels:
Java:
import javax.swing.*;

public class Test {
    public void run() {
        Box labels = Box.createVerticalBox();
        for (int i = 0; i < 200; i++) {
            labels.add(new JLabel(String.format("Label %d", i+1)));
        }

        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(new JScrollPane(labels));
        frame.setVisible(true);
        frame.setSize(800, 600);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Test().run());
    }
}
 

mihe7

Top Contributor
Nein, ich habe eine Box als Container und diesem habe ich 200 JLabels hinzugefügt.

Nachtrag: das Nein muss ein Ja sein: die Box heißt labels.
 
Zuletzt bearbeitet:

DoppelFabi

Aktives Mitglied
Verstehe ich deinen Code richtig?

Java:
import javax.swing.*; //Import

public class Test { //Klasse
    public void run() { //Methode run
        Box labels = Box.createVerticalBox(); //Box namens Labels wird erstellt
        for (int i = 0; i < 200; i++) { //Schleife damit die Labels hinzugefügt werden
            labels.add(new JLabel(String.format("Label %d", i+1))); //Labels adden
        }

        JFrame frame = new JFrame(); //Fenster
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); //Zum schließen
        frame.add(new JScrollPane(labels)); //Scrollen für die Labels
        frame.setVisible(true); //Sichtbarkeit an
        frame.setSize(800, 600); //Größe des Fensters
    }

    public static void main(String[] args) { //main methode
        SwingUtilities.invokeLater(() -> new Test().run()); //In Klasse Test wird die Methode run ausgeführt 
    }
}
 

MoxxiManagarm

Top Contributor
Ja. Wobei ich selbst setVisible immer am Ende setzen würde, also nach setSize. Dir muss nur auch klar sein, dass innerhalb der Schleife die Labels noch nicht echt hinzugefügt werden, sie werden nur der Box hinzugefügt. Die Box wird anschließend gleichzeitig mit der ScrollPane dem Frame zugeordnet. Die Zeile "Scrollen für die Labels" ist damit nicht -nur- ein Scrolling. Und du musst wissen, dass die Box intern mit LayoutManagern arbeitet (genau gesagt BoxLayout), so wie ich zuvor meinte du sollst welche verwenden um auf setBounds zu verzichten.
 

Blender3D

Top Contributor
Ich habe denn Beitrag geschrieben um zu wissen, warum ich pack(); brauch oder nicht brauch. Also mein Ziel ist eigentlich nur ein Programm was mit einem JTextField bestimmte Information anzeigt was auch soweit funktioniert.
pack() positioniert und dimensioniert die benutzen Komponenten. Das ist abhängig von dem jeweilig benutzten Layoutmanager und der gewünschten Größe der jeweiligen Komponente.
Java:
setPreferredSizer()
Alternativ kann man auch das Layout auf null setzen und die Komponenten selbst exakt so positionieren wie man es wünscht.
Java:
…
   myLabel.setBounds();
...
Allerdings sollte man in dem Fall genau wissen was man macht, da die Layoutmanager automatisch die zugrunde liegende Plattform ( Win , Mac, Linux .. ) berücksichtigen.
Deshalb sollte man auch nicht, so wie du es hier versuchst, eine eigene Windowsklasse aus JFrame basteln.
;)
 

mihe7

Top Contributor
Verstehe ich deinen Code richtig?
S. Kommentare von Moxxi. Die Box ist wie JPanel ein Container. Man kann das gleiche Ergebnis mit einem JPanel und BoxLayout erzielen. Durch das gewählte Layout, das hier implizit durch createVerticalBox() gegeben ist, werden die Komponenten (hier: JLabel-Objekte) einfach untereinander gesetzt.

Hier mal ein paar Layout-Varianten zum Spielen:
Java:
import java.awt.*;
import javax.swing.*;

public class Test {
    public void run() {
        JTabbedPane tabs = new JTabbedPane();
        tabs.addTab("FlowLayout", createLabelPane(new FlowLayout()));
        tabs.addTab("left aligned with gaps", createLabelPane(new FlowLayout(FlowLayout.LEFT, 20, 20)));
        tabs.addTab("5-grid", createLabelPane(new GridLayout(0,5)));
        tabs.addTab("10-grid", createLabelPane(new GridLayout(0,10)));
       
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(tabs);
        frame.setSize(800, 600);
        frame.setVisible(true);
    }

    private JComponent createLabelPane(LayoutManager mgr) {
        JPanel labels = new JPanel(mgr);
       
        for (int i = 0; i < 200; i++) {
            labels.add(new JLabel(String.format("Label %d", i+1)));
        }

        return labels;
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Test().run());
    }
}
 

DoppelFabi

Aktives Mitglied
Bei diesem Box Zeugs ist das Problem, dass ich auch noch ein JTextField zum suchen hinzufügen muss und ein Bild von dieser Person. Dann möchte ich ja das die Labels nicht alle untereinander sind sondern, das die manchmal auch nebeneinander sind also z. B.

Code:
Überschrift
stuff
stuff
stuff
stuff
stuff
stuff
stuff
stuff
stuff

So möchte ich etwas adden und dann 250 Pixel weiter kommt die nächste Kategorie und wieder ein paar zur Kategorie (250pixel nach rechts)
 

mihe7

Top Contributor
Es ist ja auch nur ein Beispiel von mihe!
@DoppelFabi So ist es. Auch was das Verschachteln betrifft.

Mir ging es in erster Linie darum, zu zeigen, dass man auch viele Labels in ein Fenster bekommt, ohne die Klasse mit viel Code überladen zu müssen. Hast Du das Beispiel aus Kommentar #39 schon probiert? Da habe ich mal ein paar Layouts "gegenübergestellt". Du kannst auch mal die Fenstergröße verändern und schauen, was im Layout passiert.

Was das Suchfeld betrifft: JFrame (genauer: das Content-Pane von JFrame) verwendet standardmäßig ein BorderLayout. In meinen Beispielen wurden die Inhalte im Zentrum eingefügt. Du kannst ein Panel für die Suche z. B. einfach im Norden hinzufügen.

Für ein "richtiges" Programm ist das alles natürlich noch viel zu wenig. Was Du sonst noch alles brauchst, hängt in erster Linie von den Anforderungen im Detail ab - s. Kommentar #30. Da wir diese nicht kennen, können wir auch nichts dazu sagen.
 

DoppelFabi

Aktives Mitglied
Ich möchte ja das bestimmte Labels eine ganz bestimmte Position haben. Ist es möglich in einer anderen Klasse eine Box zu machen und dort 200 Labels mit genauer Postion und Text etc. zu schreiben und in der Main Klasse dann aufzurufen und zu adden? Die Labels müssen eine bestimmte Position haben, damit meine "Kreativität" bzw mein "willen" erfolgreich umgesetzt wird.
 

mihe7

Top Contributor
Ich möchte ja das bestimmte Labels eine ganz bestimmte Position haben.
Ja, das haben sie bei mir auch. Es ist ja nicht so, dass die Positionen zufällig wären.

Du willst ohne LayoutManager arbeiten und absolute Koordinaten angeben. Das geht natürlich auch (machst Du ja schon). Stell Dich aber schon einmal darauf ein, dass Dein Layout nur auf einigen Rechnern gut aussieht.

Übrigens ist ein LayoutManager ein Beispiel für eine sinnvolle Strukturierung des Codes: der Container kümmert sich um die Verwaltung seiner Komponenten, der LayoutManager um das Layout des Containers. Dadurch wird das Layout z. B. wiederverwendbar.

Ist es möglich in einer anderen Klasse eine Box zu machen und dort 200 Labels mit genauer Postion und Text etc. zu schreiben und in der Main Klasse dann aufzurufen und zu adden?
Klar: Du erstellst Dir eine Klasse, die Dir eine Komponente mit allen Labels zurückgibt und die Komponente verwendest Du bei der Erstellung Deines JFrames.
 

DoppelFabi

Aktives Mitglied
Wie würde das ungefähr aussehen? Kann mir irgendwie nichts ganz soviel drunter vorstellen könntest du ein Beispiel mit 3 Labels machen? Und wenn man die dort erstellt kann man die auch bearbeiten (setSize setFont setBounds)? Adden tut man sie ja in der Main klasse über denn alias der box.
 

mihe7

Top Contributor
Java:
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JPanel;

class PersonView {
    private JPanel panel;

    private JTextField name;
    private JTextField firstName;

    public PersonView() {
        panel = new JPanel(null);

        JLabel nameLabel = addLabel("Name:", 20, 20, 90, 20);
        JLabel firstNameLabel = addLabel("Vorname:", 20, 45, 90, 20);
        name = addTextField(100, 20, 300, 20);
        firstName = addTextField(100, 45, 300, 20);
    }

    private JLabel addLabel(String text, int x, int y, int w, int h) {
        JLabel label = new JLabel(text);
        addComponent(label, x, y, w, h);
        return label;
    }

    private JTextField addTextField(int x, int y, int w, int h) {
        JTextField textField = new JTextField();
        addComponent(textField, x, y, w, h);
        return textField;
    }

    private void addComponent(JComponent comp, int x, int y, int w, int h) {
        comp.setBounds(x, y, w, h);
        panel.add(comp);
    }

    public JComponent getComponent() {
        return panel;
    }
}
Java:
import javax.swing.*;

public class Main {
    private PersonView personView;

    public void start() {
        personView = new PersonView();
      
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(personView.getComponent());
        frame.setSize(800, 600);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Main().start());
    }
}
 
Zuletzt bearbeitet von einem Moderator:

DoppelFabi

Aktives Mitglied
Verstehe ich deinen Code richtig?
Java:
import javax.swing.JComponent; //Import
import javax.swing.JLabel; //Import
import javax.swing.JTextField; //Import
import javax.swing.JPanel; //Import

class PersonView { //Klasse
    private JPanel panel; //Panel erstellen

    private JTextField name; //Textfeld Name
    private JTextField firstName; //Textfeld Vorname

    public PersonView() { //Methode für Klasse
        panel = new JPanel(null); //Panel denn Wert null geben

        JLabel nameLabel = addLabel("Name:", 20, 20, 90, 20); //Label erstellen namens "namelabel" und Werte zuweisen
        JLabel firstNameLabel = addLabel("Vorname:", 20, 45, 90, 20); //Label namens "firstNameLabel" erstellen und Werte zuweisen
        name = addTextField(100, 20, 300, 20); //Textfeld Name Kordinaten geben und adden
        firstName = addTextField(100, 45, 300, 20); //Textfeld Vorname Kordinaten geben und adden
    }

    private JLabel addLabel(String text, int x, int y, int w, int h) { //Methode fürs Label erstellen damit man aus anderen Klassen adden kann
        JLabel label = new JLabel(text);//label Namens "text" erstellen
        addComponent(label, x, y, w, h); //Component erstellen wo man Label hinzufügen kann
        return label; //label wiederholen
    }

    private JTextField addTextField(int x, int y, int w, int h) { //Textfeld Methode zum adden aus anderen Klassen
        JTextField textField = new JTextField(); //Textfeld namens "textField" erstellen
        addComponent(textField, x, y, w, h); //Component wo man textfield einfügen kann
        return textField; //textfield wiederholen
    }

    private void addComponent(JComponent comp, int x, int y, int w, int h) { //Componenten in anderen Klassen hinzufügen
        comp.setBounds(x, y, w, h); //Componente Kordinat geben
        panel.add(comp); //Component zum Panel hinzufügen
    }

    public JComponent getComponent() { //Verstehe ich nicht
        return panel; //Panel wiederholen
    }
}
 

mihe7

Top Contributor
Zuerst einmal habe ich vergessen, die Zuweisung zu nameLabel und firstNameLabel zu entfernen.

Dann zu Deinen Kommentaren:
Java:
    private JPanel panel; //Panel erstellen
Hier wird kein Panel erstellt, sondern lediglich eine Instanzvariable panel vom Typ JPanel deklariert.
Java:
public PersonView() { //Methode für Klasse
Das ist keine Methode, sondern ein Konstruktor ohne Parameter, der bei der Objekt-Erzeugung per "new PersonView()" ausgeführt wird.
Java:
        panel = new JPanel(null); //Panel denn Wert null geben
Richtig(er) wäre: Panel ohne LayoutManager erstellen.

Mit new wird ein neues JPanel-Objekt erzeugt. Dabei habe ich dem Konstruktor eine null-Referenz übergeben. Der einzige JPanel-Konstruktor, bei dem dies möglich ist, ist der, der eine Referenz auf ein Objekt erwartet, das die LayoutManager-Schnittstelle implementiert (https://docs.oracle.com/javase/8/docs/api/javax/swing/JPanel.html#JPanel-java.awt.LayoutManager-)

Java:
        JLabel nameLabel = addLabel("Name:", 20, 20, 90, 20); //Label erstellen namens "namelabel" und Werte zuweisen
Mit der eingangs erwähnten Korrektur würde das so aussehen:
Java:
        addLabel("Name:", 20, 20, 90, 20); //Label mit gegebenem Text und gegebenen Bounds erstellen und (dem Panel) der PersonView hinzufügen
Analog gilt der Kommentar für addTextField.

Dann zu diesen Kommentaren:
damit man aus anderen Klassen adden kann
Nein. Die add-Methoden sind in PersonView alle privat, nach außen also nicht sichtbar. Sie dienen dazu, den Code zu strukturieren, einerseits zur besseren Lesbarkeit, andererseits um Wiederholungen zu vermeiden.

Die Methode addLabel erzeugt ein neues Label mit gegebenem Text und gegebenen Bounds und fügt es (dem Panel) der PersonView hinzu. Die Methode gibt das neu erzeugte Label zurück. Analog gilt dies für addTextField.

addComponent setzt die gegebenen Bounds der gegebenen Komponente und fügt diese dem Panel hinzu.

Öffentlich, also von außen zugreifbar, sind lediglich der Konstruktor und die Methode getComponent. Diese Methode liefert dem Aufrufer die zum PersonView-Objekt gehörende Swing-Komponente (JComponent). In diesem Fall ist das einfach das panel.
 

DoppelFabi

Aktives Mitglied
Die Methode addlabel fügt man einfach zum Panel hinzu und in der Main definiert man die Klasse Personview und addet das Panel zum Frame und fertig?
 

mihe7

Top Contributor
Es geht nicht um die Methode addLabel. Die ist nur dazu da, um Code zu sparen und übersichtlicher zu gestalten. Der Rest: ja. Du baust Deine Komponenten in Klassen zusammen und fügst diese dann einem Frame (oder eben anderen Komponenten) hinzu.
 

Ähnliche Java Themen

Neue Themen


Oben