Reihenfolge im Konstruktor der Objekte

[REC]

Hallo zusammen,habe hier bei mir was gesehen was ein bisschen komisch ist.
Wollte daher mal fragen was richtig ist.

Bis jetzt habe ich die Arrays gleich am Anfang vom Konstruktorrumpf gemacht.
Da ich gleich ein Objekt erstellte und dies dann in den Array "reinmachte"

Ohne zu überlegen habe ich das auch mit einem JTextField Array gemacht. Also

        //Array 
        felder = new MyJTextField[13];
        felder[0] = einerFeld;
        felder[1] = zweierFeld;

Doch diese Felder erstelle ich erst nach dem Array.Die Folge ist, das ich keine Objekte in der Array habe.Ok damit es funktioniert habe ich diese Array zu unterst gemacht,nun klappt es.
Meine Frage nun,sollte man die Arrays immer am Schluss anfügen?Oder anders gesagt das erste was man im, Konstruktor macht ist Objekte zu erstellen?Damit man genau solche nullpoint fehler umgeht?

 

[Haave]

Ich bin noch nicht so erfahren im Programmieren, aber meine bisherige Feststellung (insbesondere bei GUI-Programmierung) ist, dass man am besten vom Kleinen ins Große und vom Inneren zum Äußeren geht.
Beispielsweise erst den JButton, den ich haben will, initialisieren, dann das JPanel, danach den JFrame. Anschließend den Button dem Panel und das Panel dem Frame hinzufügen. In deinem Beispiel wäre ja das Array die übergeordnete Instanz, darum würde ich es auch erst nach Initialisierung der benötigten Felder erstellen.

 

[JavaKnight]

Bitte einmal Quelltext posten

Auf dem Array werden ja nicht wirklich die Objekte gespeichert sondern nur Referenzen auf die eigentlichen Objekte!

Das heißt wenn diese nicht initialisiert wurden also null sind, dann hast du halt null Objekte

Aber wie gesagt bitte einmal gesamten Quelltext!

 

[Tomate_Salat]

[...] (insbesondere bei GUI-Programmierung) [...] Beispielsweise erst den JButton, den ich haben will, initialisieren, dann das JPanel, danach den JFrame. Anschließend den Button dem Panel und das Panel dem Frame hinzufügen. .

Da wirst du z.B. mit SWT Probleme haben das umzusetzen. Denn da läuft es genau anderstherum:

Composite c = new MyComposite(shell, SWT.NONE);
Button b = new Button(c, SWT.NONE);

Auch in Swing würde ich von "außen nach innen" gehen. Erst den JFrame, dann JPanel, dann JButton

 

[The_S]

Variablen, die in der kompletten Methode (oder Konstruktor) gebraucht werden, immer am Anfang deklarieren und nach Möglichkeit initialisieren. Geht in deinem Fall nicht, deshalb nur deklarieren.

Also bspw.

DeinKonstruktor() {
Object [] f = new Object [13]; // Deklarieren
Object a = new Object();
Object b = new Object();
// ...
f[0] = a; // Initialisieren
f[1] = b; 
// ...

oder

DeinKonstruktor() {
Object a = new Object();  // Deklarieren
Object b = new Object();
// ... Hier stehen nur weitere Deklarationen + ggf. Initialisierungen in der selben Zeile
Object [] f = new Object [13];
f[0] = a; // Initialisieren
f[1] = b; 
// ...

oder

DeinKonstruktor() {
Object [] f = new Object [13];
f[0] = new Object(); // Initialisieren
f[1] = new Object(); 
// ...

oder

...

Solang du nicht irgendwo Deklarationen gefolgt von Logik gefolgt von weiteren Deklarationen hast, ist das alles ok. Auch würde ich nicht unbedingt so etwas machen:

DeinKonstruktor() {
Object a = new Object();  // Deklarieren
Object [] f = new Object [13];
Object b = new Object();
// ...
f[0] = a; // Initialisieren
f[1] = b; 
// ...

 

[Haave]

[...] (insbesondere bei GUI-Programmierung) [...] Beispielsweise erst den JButton, den ich haben will, initialisieren, dann das JPanel, danach den JFrame. Anschließend den Button dem Panel und das Panel dem Frame hinzufügen.

Da wirst du z.B. mit SWT Probleme haben das umzusetzen. Denn da läuft es genau anderstherum:

Composite c = new MyComposite(shell, SWT.NONE);
Button b = new Button(c, SWT.NONE);

Mit SWT habe ich noch nie gearbeitet, aber soweit ich das von deinem Codebeispiel beurteilen kann, muss beim Konstruktoraufruf vom Button der Container (hier Composite) bereits bekannt sein. Wenn das so ist, hat man natürlich keine Wahl und muss erst das übergeordnete Ding erstellen.
Mein Beispiel bezog sich jedoch auf einen Code wie diesen:

JButton button = new JButton("Hallo!");
//noch mehr Buttons und Kram, der ins Panel soll
JPanel panel = new JPanel();
panel.add(button);
//panel.add(noch mehr Kram);
JFrame frame = new JFrame("Dolles Fenster");
frame.add(panel);

Hab's mir halt übersichtlicher vorgestellt, wenn ich die einzelnen Teile erst dann erstelle, wenn ich sie auch wirklich brauche, und nicht am Anfang des GUI-Codes erst mal einen JFrame und mehrere Panels hinhaue, mich dann mit dem Erstellen von Buttons und ganz anderen Sachen beschäftige und erst am Schluss auf die Panels und den Frame zurückkomme. Ist vielleicht einfach auch Geschmackssache.

 

[The_S]

JButton button = new JButton("Hallo!");
//noch mehr Buttons und Kram, der ins Panel soll
JPanel panel = new JPanel();
panel.add(button);
//panel.add(noch mehr Kram);
JFrame frame = new JFrame("Dolles Fenster");
frame.add(panel);

Das ist bäh. Alle in einem Gültigkeitsbereich benötigte Variablen sollten direkt am Anfang dieses Gültigkeitsbereichs deklariert und asap initialisiert werden. Alles andere ist unübersichtlich und erschwert die Suche nach dem "Ursprung" einer Variablen.

 

[Tomate_Salat]

@Haave: Jup bei SWT muss das parent-objekt bereits initalisiert sein. Ich würde auch von deiner Arbeitsweise abraten. Wenn du eine GUI baust, solltest du ungefähr wissen, wie diese später aussehen soll, insofern sollte es auch kein Problem sein, mit dem JFrame anzufangen und darauf alles zu setzen. Zudem würde ich auch, wie The_S geschrieben hat, meine Variablen früh definieren.

 

[Haave]

Okay, ich behalte im Hinterkopf, was ihr geschrieben habt, und mach einfach mal meine eigenen Erfahrungen ^^ (Hab bislang nie besonders umfangreichen GUI-Code geschrieben, deshalb war es nie wirklich unübersichtlich.)

Jetzt will ich aber nicht den Thread an mich reißen, sondern lieber den Fragesteller zu Wort kommen lassen.

 

[The_S]

Okay, ich behalte im Hinterkopf, was ihr geschrieben habt, und mach einfach mal meine eigenen Erfahrungen ^^ (Hab bislang nie besonders umfangreichen GUI-Code geschrieben, deshalb war es nie wirklich unübersichtlich.)

Geht nicht um GUI-Code sondern allgemein. Und dass du dich darin später wieder zurecht findest, stellt auch niemand in Frage, wenn du alle Projekte so aufbaust. Auch ist es bei dem konkreten Beispiel hier nicht sooooooooo dramatisch. Aber ein Außenstehender, der deinen Code (bspw. einen etwas komplexeren Algorithmus) lesen muss, wo kreuz und quer neue Variablen deklariert werden, wird sich wohl schwerer tun.

Jetzt will ich aber nicht den Thread an mich reißen, sondern lieber den Fragesteller zu Wort kommen lassen.

Darf doch jeder Fragen und gehört ja zum Thema

@Tomate_Salat

Als Klassenvariablen???

 

[Tomate_Salat]

@The_S:
Ouh, ja jz seh ich was ich da gestern geschrieben habe. Ich editier das mal besser wieder raus

 

[REC]

He danke für eure zahlreiche und gute Antworten
Meine Frage ist mehr als beantwortet :toll:

Aber ich kann mich diese GUI Fragen auch anschliessen sind gerade auch interessant.
Auch wegen der Reihenfolge.Klar all jene Elemente welche ich brauche deklariere ich im Datenfeld

//Datenfeld
private JFrame a;
private JPanel b;
private JButton knopf;

Dann erzeuge ich Objekte davon im Konstruktor

//Konstruktor
a = new JFrame();
b = new JPanel();
knopf = new knopf();

Dann in der Methode paint,ist eben jetzt die Frage der Reihenfolge.
In der Schule wurde uns gesagt man soll von oben nach unten machen.Also
knopf ,b,a.
Aber ich finde es besser wenn ich von hinten beginne.Zuerst das a dann b dann der Knopf.

Noch eine 2Frage.
Die meisten Komponeten kann man ja einstellen.Ist diese Reihenfolge richtig?
Also wenn ich mit einer Komponente anfange stelle ich gleich alles ein bevor ich zur nächste gehe?

public void paint() {

        mainFrame.setSize(550, 500);
        mainFrame.setResizable(false);
        mainFrame.setLocationRelativeTo(null);
        mainFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        mainFrame.setBackground(Color.black);

        // Der Würfel Panel
        würfelPanel.setLayout(new FlowLayout());
        würfelPanel.setBackground(Color.BLACK);

        // knopfPanel
        knopfPanel.setLayout(new FlowLayout());
	knopfPanel.setBackground(Color.black);
	knopfPanel.add(knopf);

 

[The_S]

Ist letztendlich Geschmackssache. Ich finde deine Aufteilung in der paint Methode angemessen .

 

[REC]

Ok, dann kann ich mir das ja nun so angewöhnen