# Blutiger Anfänger sucht nette Leute die gern helfen



## Zaphi67 (29. Mrz 2009)

Ich bin blutiger Anfänger in der Javaprogrammierung. Ein Wenig Grundkenntnisse im Programmieren hab ich allerdings. Jetzt hab ich ich mir in den Kopf gesetzt Java zu lernen. Ich verwende als IDE Eclipse und habe das Buch "Java ist auch eine Insel". Einige kleine Wunder (z.B. "Hallo Welt") habe ich bereits vollbracht(vieleicht kann mir jemand an dieser Stelle direkt eraten wie ich Eclipse deutsch bekomme. Plugins sind wohl all da denke ich.)
Nun finde ich das Buch allerdings etwas steif und wenig aufeinander Aufbauend. Außedem bevorzuge ich die Methode "learning by doing". Deshalb habe ich mir mal ein kleines Projekt ausgedacht das ich Schritt für Schritt erweitern möchte.
Ziel 1:
Ein Fenster mit 2 Buttons

soweit bin ich bereits, allerdings nur mit nem Trick. Ich mußte 3 Buttens machen und einen auf unsichtbar setzen, sonst war der immer über das ganze Fenster und hat die anderen verdeckt. Komischerweise kann ic nur bei 2 Buttons Größe und Position ändern. Vieleicht hat jemand eine Lösung (aber bite möglichst verständlich für Anfänger). Ich würde übrigens gern bei "swing" bleiben und weniger gern mit AWT was machen.
Und hier der Quelltext

[HIGHLIGHT="Java"]import javax.swing.JFrame;
import javax.swing.JButton;

public class Frame {

  /**
   * @param args
   */
  public static void main(String[] args) {
    JFrame f = new JFrame("Fenster zur Welt");
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setBounds(300, 100, 300, 400);
    f.setVisible(true);
    // f.setLocationRelativeTo(null);

    JButton a = new JButton("Start");
    a.setBounds(50, 10, 70, 30);
    a.setVisible(true);

    JButton b = new JButton("End");
    b.setBounds(150, 10, 70, 30);
    b.setVisible(true);

    JButton c = new JButton("Dummi");// invisible
    c.setBounds(300, 200, 50, 30);
    c.setVisible(false);

    f.add(a);
    f.add(b);
    f.add(c);// invisible
  }
}[/HIGHLIGHT]

Ziel2:
Jetzt werd ich mal versuchen das wenn man den Button "Start" drückt in der Konsole(System.out.println() ausgegeben wird "Sie haben "Start" gedrückt.Das selbe dann mit dem "End" Button.Malsehen wie weit ic komme


----------



## Marco13 (29. Mrz 2009)

Buttons sind standardmäßig "visible" - das braucht man nicht extra hinzuschreiben. Dafür aber das setVisible(true) vom Frame, und das immer als LETZTES, also nachdem alle Components hinzugefügt wurden. 

Die setBounds-Sachen sind ein bißchen problematisch: Das funktioniert nur, wenn man 'null' als LayoutManager setzt (was man aber i.a. nicht tun sollte). Stattdessen, in diesem Fall, sowas wie
f.getContentPane().setLayout(new GridLayout(1,2));


----------



## 0x7F800000 (29. Mrz 2009)

Zaphi67 hat gesagt.:


> Ich verwende als IDE Eclipse und habe das Buch "Java ist auch eine Insel". Einige kleine Wunder (z.B. "Hallo Welt") habe ich bereits vollbracht


 hört sich bisher ganz vernünftig an.:toll:


> (vieleicht kann mir jemand an dieser Stelle direkt eraten wie ich Eclipse deutsch bekomme. Plugins sind wohl all da denke ich.)


keine Ahnung, ich will's gar nicht wissen. Wozu auch? Die ganze (interessante) Literatur, alle tutorials usw. sind eh größtenteils auf Englisch. Und bei IDE ist das eh gefährlich, da hat man dauernd text in einer unüblichen Sprache vor den Augen, vielleicht kriegt man davon irgendwann ein kurzschluss, und fängt versehentlich an auch noch code auf irgendeinem gruseligen denglisch zu fabrizieren...:noe:

Dann zum Äußeren:
1) woher kommen die ganzen zeilenumbrüche? => Strg+Shift+F 
2) wie hast du den merkwürdigen bunten text hier reingekriegt? ???:L 
Nächstes mal bitte [noparse][highlight=Java][/noparse][noparse][/highlight][/noparse] benutzen.

Und nun zum Inhalt:
*

		Code:In die Zwischenablage kopieren


public class Frame{


Klassen genauso wie in der Standard Api zu benennen ist keine besonders gute Idee.

​*


```
f.setVisible(true);
```

Das wird zuallerletzt aufgerufen, wenn alle anderen Components schon aufgebaut und hinzugefügt sind. Dann gibt es normalerweise auch keine Probleme damit, dass irgendwas nicht dort ist wo es sein soll etc.




```
a.setBounds(50,10,70,30);
```

Dieses Befehl ist nicht für den menschen gedacht, damit beschäftigen sich LayoutMagager. Niemals setBounds() selbst aufrufen, es sei denn man ist sich ganz sicher was man da tut, bzw. eigenen LayoutManager schreibt. Siehe zB. das  entsprechende Kapitel in der Insel zu dem Thema, dort ist es imho ganz ok beschrieben.



```
a.setVisible(true);
```

das ist unnötig. Fenster sichtbar => alle Kinder auch sichtbar, es sei denn man fummelt da noch irgendwas dran rum... Mach das weg.

​

> Ziel2:
> Jetzt werd ich mal versuchen das wenn man den Button "Start" drückt in der Konsole(System.out.println() ausgegeben wird "Sie haben "Start" gedrückt.Das selbe dann mit dem "End" Button.Malsehen wie weit ic komme


Da reicht ein gaanz billiger ActionListener, einzeiler.


----------



## Zaphi67 (29. Mrz 2009)

Ok, hab mal soweit wie möglich alle Ratschläge befolgt.Aber wirklich weiter bin ich leider nicht. 


> f.getContentPane().setLayout(new GridLayout(1,2));


Damitkann ich irgendwie nicht umgehen. Wenn ich das aktiviere dann wird mein Fenster winzig.


> 1) woher kommen die ganzen zeilenumbrüche? => Strg+Shift+F ;-)


Die mach ich weil ich so besser klar komme. 


> Code:
> a.setBounds(50,10,70,30);
> 
> Dieses Befehl ist nicht für den menschen gedacht, damit beschäftigen sich LayoutMagager. Niemals setBounds() selbst aufrufen, es sei denn man ist sich ganz sicher was man da tut, bzw. eigenen LayoutManager schreibt. Siehe zB. das entsprechende Kapitel in der Insel zu dem Thema, dort ist es imho ganz ok beschrieben.


leider habe ich dazu keine Alternative. mit a.setSize(); kann ich zwar die Größe der Buttons festlegen, aber für die Position find ich nix (setPosition()) geht wohl nicht bei Buttons.
Außerden hab ich ja immernoch das Problem das ich eben diesen Dummi Button als unsichtbar haben muß damit das läuft. Mach ich den sichtbar nimmt der den gesammten Fensterinhalt ein.


> Da reicht ein gaanz billiger ActionListener, einzeiler.


Naja  hört sich einfach an. Für mich erstmal unlösbar.
Hier der vebesserte aber immernoch schlechte Quellcode
[highlight=Java]
import java.awt.GridLayout;
import javax.swing.JFrame;
import javax.swing.JButton;

public class Fenster{
  public static void main(String[] args){
    JFrame f = new JFrame("Fenster zur Welt");
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    // f.getContentPane().setLayout(new GridLayout(1,2));
    f.setSize(300, 400);
    f.setLocationRelativeTo(null);

    JButton a = new JButton("Start");
    a.setBounds(50, 10, 70, 30);

    JButton b = new JButton("End");
    b.setBounds(150, 10, 70, 30);

    JButton c = new JButton("Dummi");// invisible
    c.setBounds(200, 200, 70, 30);
    c.setVisible(false);

    f.add(a);
    f.add(b);
    f.add(c);// invisible
    f.setVisible(true);
  }
}
[/highlight]

lol, so kannman ja garnix mehr lesen. Also nochmal die normale Variante...

_[Edit by Beni: K.A. wieso der Browser meint, er müsse den Quelltext selbst formatieren (schalte vielleicht mal den Editor des Forums um, Kontrollzentrum > Einstellungen ändern > Beitrags/-Nachrichten Editor > Standart Editor).
Oder kopiere den Quellcode zuerst in einen einfachen Texteditor (Notepad) um die Formatierung die Eclipse einbaut zu löschen.
Ich habe den vorhandenen Quellcode mal umkopiert.]_


----------



## 0x7F800000 (29. Mrz 2009)

Zaphi67 hat gesagt.:


> Damitkann ich irgendwie nicht umgehen. Wenn ich das aktiviere dann wird mein Fenster winzig.


Öhm? das sollte eigentlich keinerlei Auswirkungen aus das fenster haben. Funktionieren dürfte es aber auch nicht, weil mir grad auffällt:

```
[SIZE=2]f.add( a );[/SIZE]
```
Das darf man bei Swing fenstern so nicht machen. Swing Fenster bestehen aus meheren verschiedenen Bereichen. Der Inhalt muss auf das content pane, also:

```
[SIZE=2]f.getContentPane().add( a );[/SIZE]
```



> Die mach ich weil ich so besser klar komme.


was solls... je später du dir das abgewöhnen musst, desto schwieriger wird's, naja, deine Entscheidung... :bahnhof:



> leider habe ich dazu keine Alternative. mit a.setSize(); kann ich zwar die Größe der Buttons festlegen, aber für die Position find ich nix (setPosition()) geht wohl nicht bei Buttons.


Hallo? Ist es schon so spät? Meinen Beitrag hast du irgendwie nur überflogen oder wie? Man setzt keine Größe und positionen mit setBounds() oder ähnlichen Hacks. Man wählt lediglich den passenden LayoutManager aus, und konfiguriert alles entsprechend. Alles andere ist nicht für manuelle benutzung gedacht.


> Außerden hab ich ja immernoch das Problem das ich eben diesen Dummi Button als unsichtbar haben muß damit das läuft. Mach ich den sichtbar nimmt der den gesammten Fensterinhalt ein.


Hacks durch andere Hacks verschleiern ist auf dauer keine gute taktik, ehrlich.:noe:



> lol, so kannman ja garnix mehr lesen


 kA was da los ist... Muss wohl irgendwie an deinem Browser liegen oder sonst was... Bei mirr lässt sich aus eclipse alls wunderbar rauskopieren. Hoffentlich biegt das ein mod am Morgen alles wieder gerade... :autsch:

[highlight=Java]
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class _{

    public static void main(String[] args) {
        JFrame f = new JFrame("Fenster zur Welt");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300, 90);
        f.getContentPane().setLayout(new GridLayout(1,2));

        JButton startButton = new JButton("Start");
        startButton.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.out.println("irgendwas geklickt oder so...");
            }
        });
        JButton endButton = new JButton("End");    
        endButton.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.out.println("mal die farbe wechseln...");
                ((JButton)e.getSource()).setBackground((new Color[]{Color.RED,Color.BLUE,Color.YELLOW})[(new java.util.Random()).nextInt(3)]);
            }
        });

        f.getContentPane().add(startButton);
        f.getContentPane().add(endButton);
        f.setVisible(true);
    }
}
[/highlight]


----------



## FatFire (29. Mrz 2009)

> Das darf man bei Swing fenstern so nicht machen. Swing Fenster bestehen aus meheren verschiedenen Bereichen. Der Inhalt muss auf das content pane, also:
> [HIGHLIGHT="Java"]f.getContentPane().add( a );[/HIGHLIGHT]


Hallo? Irgendwie bei 1.4.2 hängen geblieben? Du kannst seit 1.5 auch swingend einfach adden und Layout setten ohne das ContentPane-Gebammel. Also: Keine Fehlerquelle.

Gruß FatFire


----------



## hdi (29. Mrz 2009)

> Also: Keine Fehlerquelle.


Richtig, wenn man sich die add() Methode ansieht, sieht man dass es nur ein Wrapper ist
für getContentPane().add().

*An den Threadersteller:*
Natürlich helfen wir dir sehr gerne und heissen dich hier willkommen. Aber bitte wähle
für deinen nächsten Beitrag einen passenderen Tiltel, der beinhaltet worin denn
dein Problem besteht.


----------



## Schandro (29. Mrz 2009)

> ((JButton)e.getSource()).setBackground((new Color[]{Color.RED,Color.BLUE,Color.YELLOW})[(new java.util.Random()).nextInt(3)]);


Machs dir leicht und versuch gar nicht erst diese Zeile zu verstehen. Irgendwann später kannst du sie dir dann wieder angucken...

Ein paar allgemeinen, nicht auf deinen Code bezogene Tipps:

- Die API ist dein Freund, bevor man fragt erstmal darin gucken was eine Methode genau macht bzw. welche Methoden es überhaupt gibt.
- Fehlermeldungen sind dein Freund. Viele Anfänger sehen nur einen haufen Exceptions mit langen Stack Trace und denken "ach komm, das verstehste eh nicht, mach ich einfach mal en neuen Thread im Forum". Ist auf Dauer ein bischen umständlich, deswegen von Anfang an lernen mit Exceptions umzugehen.
(Am besten geht das, wenn man sich die Zeile in seinem Code anguckt in dem die Exception geworfen wurde und gegebenfalls nach den Namen der Exception googelt, um zu sehen für was für einen Fehler sie steht)
- Strings vergleicht man mit s1.equals(s2)   nicht mit s1 == s2
- Pauschalregel: Benutzung von static (außer für Konstanten) ist antiproportional zur Sauberkeit des Codes. (gibt natürlich ein paar Ausnahmen)
- Die Coding Convention einhalten, z.b. die Schreibweisen:
*m*y*V*ariable
*M*y*C*lass
*m*y*p*ackage


----------



## André Uhres (29. Mrz 2009)

hdi hat gesagt.:


> bitte wähle für deinen nächsten Beitrag einen passenderen Titel


Ja, leider verfasst ein Großteil der Forumbenutzer sinnlose Titel. 
Wir empfehlen daher dringen, diese kleine Anleitung zu befolgen: http://www.java-forum.org/sitecheck/39209-aussagekraeftige-titel-verwenden.html#post244586


----------



## 0x7F800000 (29. Mrz 2009)

FatFire hat gesagt.:


> Hallo? Irgendwie bei 1.4.2 hängen geblieben? Du kannst seit 1.5 auch swingend einfach adden und Layout setten ohne das ContentPane-Gebammel.


Öhm... Ja, danke für den Hinweis^^ :autsch: 
Da haben die von sun aber eine wirklich die unsinnigste stelle ausgesucht, um 10 buchstaben einzusparen . Aber um ein Set mit einem element zu erstellen scheint es nach wie vor nichts kürzeres zu geben als:
[highlight=Java]
new HashSet<String>(Arrays.asList(new String[]{"wtf"}))
[/highlight]
Naja, egal, wen juckt's... :noe:


----------



## Mofi (29. Mrz 2009)

ich muss zugeben, dass ich das fenster was bei dem code (den verbesserten mein ich) hier rauskommt als hässlich empfinde - was daran liegt, dass die buttons auf die fenstergröße gezogen werden.

find ich nicht schön. hier ist zu empfehlen, die buttons erst in Panels einzufügen (würd ich so machen zumindestens) und die Panels in den Frame, dann sollten die ihre ursprüngliche größe nämlich behalten.

und ich weiß nicht ob ihm der code vom 0x7F800000 so wirklich hilft. mich persönlich verwirrt er schon (bin auch noch recht am anfang). ich weiß dass es zwei arten von innerenklassen gibt. und 0x7F800000 hat wohl die gewählt die ich selbst nicht so beherrsche  find ich auch nicht sooo übersichtlich *grins*
ich hab meine inneren klassen lieber alle am ende  verwirrt mich dann auch nicht so.

(ich poste mal den code mit panels wie ich das meine)
[HIGHLIGHT="Java"]
import java.awt.GridLayout;
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.*;

public class Fenster{
  public static void main(String[] args){
    JFrame f = new JFrame("Fenster zur Welt");
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setSize(300, 400);
    JPanel panel = new JPanel();
    JButton a = new JButton("Start");
    JButton b = new JButton("End");
     panel.add(a);
     panel.add(b);
     f.getContentPane().add(panel);
    f.setVisible(true);
  }
}[/HIGHLIGHT]

im übrigen passt die fenstergröße nicht wirklich, weil so viel freier platz unter den buttons ist aber was solls


----------



## hdi (29. Mrz 2009)

0x7F800000 hat gesagt.:


> Aber um ein Set mit einem element zu erstellen scheint es nach wie vor nichts kürzeres zu geben als:
> [highlight=Java]
> new HashSet<String>(Arrays.asList(new String[]{"wtf"}))
> [/highlight]



Doch:
[highlight=Java]
new HashSet<String>(Arrays.asList(new String[]{""}))
[/highlight]


----------



## Lexi (29. Mrz 2009)

Mofi hat gesagt.:


> ich weiß dass es zwei arten von innerenklassen gibt. und 0x7F800000 hat wohl die gewählt die ich selbst nicht so beherrsche  find ich auch nicht sooo übersichtlich *grins*
> ich hab meine inneren klassen lieber alle am ende  verwirrt mich dann auch nicht so.



Das ist eine anonyme Klasse. Wird oft benutzt, wenn man die Funktion der actionPerformed Methode ( im Falle eines ActionListeners ) nur für ein einziges Element benutzt und nicht für mehrere.


----------



## 0x7F800000 (29. Mrz 2009)

Mofi hat gesagt.:


> find ich nicht schön. hier ist zu empfehlen, die buttons erst in Panels einzufügen (würd ich so machen zumindestens) und die Panels in den Frame, dann sollten die ihre ursprüngliche größe nämlich behalten.



*Jetzt Neu!* "effectless JPanels"!
Gefällt ihnen der Standard-BorderLayout von Swing-Fenstern nicht?
Sie wollen einfach nur einen Flowlayout haben?
Aber sie haben es satt, kurzen und übersichtlichen java-code, der direkt zum Ziel führt, zu schreiben?

Dann haben wir was für Sie!
Die Lösung lautet: *effectless JPanels*!

Sehen sie sich nur diesen öden kurzen code an:
[highlight=Java]
import java.awt.*;
import javax.swing.*;

public class _{
  public static void main(String[] args){
    JFrame f = new JFrame("Fenster zur Welt");
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setSize(300, 100);
    f.setLayout(new FlowLayout());
    JButton a = new JButton("Start");
    JButton b = new JButton("End");
    f.add(a);
    f.add(b);
    f.setVisible(true);
  }
}
[/highlight]
Wie zu erwarten wäre, erzeugt es ein total ödes Fenster:




Aber jetzt sehen sie sich diesen prächtigen aufgeblähten code an, wo "effectless JPanels" angewandt wurden:
[highlight=Java]
import java.awt.*;
import javax.swing.*;

public class _ {
    public static void main(String[] args) {
        JFrame f = new JFrame("Fenster zur Welt");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300, 100);
        JPanel panel = new JPanel();
        JButton a = new JButton("Start");
        JButton b = new JButton("End");
        panel.add(a);
        panel.add(b);
        f.getContentPane().add(panel);
        f.setVisible(true);
    }
}
[/highlight]
Das Resultat:



Und? Sehen Sie den Unterschied? Genau das ist es! Es gibt keinen Unterschied. Aber dafür können Sie jetzt mit der hohen Zeilenanzahl ihres Codes angeben! 
Ist das nicht kolossal? 
Sind sie auch begeistert?! 
Dann Rufen Sie jetzt an!
"effectless JPanels" für nur 89.99€!
Bestellen Sie jetzt! Wenn Sie innerhalb der nächsten 45 Minuten anrufen, kriegen Sie eine von JPanel abgeleitete Klasse mit dem standardmäßig eingestellten CardLayout gratis dazu!
"effectless JPanels" für nur 89.99€! Rufen Sie jetzt an!...

:toll:

Ne, jetzt mal Back to topic: es ging nicht darum wie das Fenster aussieht, sondern nur darum dass der OP normale Layouts verwendet, statt an setBounds rumzufummeln.
Und von den ganzen "inneren Klassen" gibt es noch ein paar mehr: 
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 9.2 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen


----------



## FatFire (29. Mrz 2009)

> Und? Sehen Sie den Unterschied? Genau das ist es! Es gibt keinen Unterschied. Aber dafür können Sie jetzt mit der hohen Zeilenanzahl ihres Codes angeben!


Naja, ob die eine Zeile Unterschied jetzt den Code soviel mehr aufbläht...da trickse ich doch lieber mit Klammern...
Sonderbar finde ich nur, was an dem bißchen Unterschied jetzt Mofi verwirrt hat?!?

Gruß FatFire


----------



## Mofi (29. Mrz 2009)

0x7F800000 hat gesagt.:


> Ne, jetzt mal Back to topic: es ging nicht darum wie das Fenster aussieht, sondern nur darum dass der OP normale Layouts verwendet, statt an setBounds rumzufummeln.



entschuldigung, dass ich nicht so allwissend bin wie du und mich mit den ganzen layouts etc noch nicht so auskenne. weiterhin entschuldige ich mich hier eingemischt zuhaben. tut mir sehr leid, wenn ich eure kostbare zeit mit meinem schrecklichen code geraubt habe.


mein gott, sowas kann man aber echt auch netter schreiben.

(und OHO ich habe EINE ganze dämliche zeile mehr....RICHTIG aufgebläht...)

(und ja ich mag überreagieren und zu empfindlich sein, aber ich finde immernoch, dass dies zu weit ging)


edit:
@fatfire
mich verwirrt es einfach, wenn irgendwo einfach 'mittendrin' eine extra klasse steht

```
JButton startButton = new JButton("Start");
        startButton.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.out.println("irgendwas geklickt oder so...");
            }
        });
```
rein theoretisch ist die zeile ja 'nur' "startButton.addActionListener(new ActionListener());"
aber durch die anonyme klasse geht diese zeile über mehrere zeilen und ist für mich persönlich unübersichtlicher.
zu viele klammern fand ich schon in der schule verwirrend.

und nur weil ich das verwirrend finde, heißt es ja nicht das es schlecht ist oder man es nicht verwenden soll 

allerdings glaub ich auch, dass es für anfänger generell verwirrender ist anonyme klassen zubenutzen als innere


----------



## 0x7F800000 (29. Mrz 2009)

Mofi hat gesagt.:


> entschuldigung, dass ich nicht so allwissend bin wie du und mich mit den ganzen layouts etc noch nicht so auskenne. weiterhin entschuldige ich mich hier eingemischt zuhaben. tut mir sehr leid, wenn ich eure kostbare zeit mit meinem schrecklichen code geraubt habe.
> 
> 
> mein gott, sowas kann man aber echt auch netter schreiben.
> ...


naja die zeit habe ich mir selbst geraubt, der witz war auf rein freiwilliger Basis. 
War ja auch nicht böse gemeint, habe ich denn da nicht genug lächelnde Smileys eingefügt? :bae: Sorry, wenn's wieder anders rübergekommen ist^^ 
=> nich zu ernst nehmen, ich joke hier wieder nur ein bisschen herum, weil in anderen Threads grad nix los ist...

peace :smoke:

[edit1]:
etwas "nettere" beschreibung des Denkfehlers: Statt den Layout des content panes auf FlowLayout umzustellen, hast du da ein neues Jpanel eingefügt, das genauso groß ist, genauso aussieht, genau dasselbe tut, aber eben ein Flow-Layout als Standard-einstellung hat. Das ist verwirrend, besonders für den OP, der das nicht einschätzen kann.

[edit2]:


> aber durch die anonyme klasse geht diese zeile über mehrere zeilen und ist für mich persönlich unübersichtlicher.
> zu viele klammern fand ich schon in der schule verwirrend.


Naja, was soll man da machen? Wenn man für jeden Listener eine eigene Klasse anlegt, dann hat man da irgendwann 798 zusätzliche Klassen da stehen, und muss isch für die irgendwelche halbwegs sinnvolle Namen einfallen lassen... Das wird noch unübersichtlicher, weil da nicht mal durch den Kontext klar wird, was diese Listener tun sollen, so steht es zumindest direkt nebendran.


----------



## Mofi (29. Mrz 2009)

0x7F800000 hat gesagt.:


> naja die zeit habe ich mir selbst geraubt, der witz war auf rein freiwilliger Basis.
> War ja auch nicht böse gemeint, habe ich denn da nicht genug lächelnde Smileys eingefügt? :bae: Sorry, wenn's wieder anders rübergekommen ist^^
> => nich zu ernst nehmen, ich joke hier wieder nur ein bisschen herum, weil in anderen Threads grad nix los ist...
> 
> peace :smoke:



solang ich nix rauchen muss 
und man sollte jokes eher mit menschen machen, von denen man weiß, dass die die nicht falsch verstehen(besser für alle beteiligten)


----------



## 0x7F800000 (29. Mrz 2009)

Mofi hat gesagt.:


> und man sollte jokes eher mit menschen machen, von denen man weiß, dass die die nicht falsch verstehen(besser für alle beteiligten)


oohm... Ich bin bisher stillschweigend davon ausgegangen, das alle Menschen scherze verstehen :bahnhof:


> solang ich nix rauchen muss


<quatsch> versteh ich nich ???:L </quatsch> 


Okay, sorry, war ein vielleicht ein ganz kleines bisschen gemein


----------



## Schandro (29. Mrz 2009)

Nur um das mal klarzustellen:
Normalerweise sollte man tatsächlich immer seine GUI Komponenten (in deinem fall die 2 Buttons) auf ein panel tun und dieses dann dem JFrame adden.
Warum?
Weil man imho
1. Zum malen die paintCompinent Methode von einem JPanel überschreiben sollte, nicht eine paint Methode des Fensters. Falls man also mal einen Hintergrund für die gesamte GUI malen will, braucht man nix mehr umstellen sondern einfach das bereits eh genutze JPanel auch noch zum malen benutzen.
2. Man kann dadurch die GUI auf irgendein "Anzeigemechanismus" klatschen, z.b. auf ein JApplet statt auf ein JFrame.

Deswegen fand ich *0x7F800000 *Joke tatsächlich ein bisschen unnangebracht^^

Ach übrigens, wegen den Anonymen Klassen:
Sind für Klassen, die man nur ein einziges mal brauchen wird (bestes Beispiel sind dafür Sachen wie ActionListener die nur zu einem einzigen Button gehören) toll geeignet, da der Code, den der Button ausführt, direkt bei der initialisierung des Buttons dabeisteht und nicht ganz unten irgendwo, wo er als innerhalb eines "class" Blocks rumgamelt.
Außerdem ist es verwirrend, wenn man irgendwo plötzlich eine Klasse in freier Wildbahn sieht, man aber nicht weiß das die eh nur 1 einzigiges mal instanziert wird.


----------



## hdi (29. Mrz 2009)

> allerdings glaub ich auch, dass es für anfänger generell verwirrender ist anonyme klassen zubenutzen als innere


Vorallem muss man erstmal wissen, dass anonyme Klassen innere Klassen _sind_,
nur abgekürzt geschrieben. Wollte ich nur mal festgehalten haben fürs Spiesser-Definitions-Buch.


----------



## 0x7F800000 (29. Mrz 2009)

Schandro hat gesagt.:


> 1. Zum malen die paintCompinent Methode von einem JPanel überschreiben sollte, nicht eine paint Methode des Fensters. Falls man also mal einen Hintergrund für die gesamte GUI malen will, braucht man nix mehr umstellen sondern einfach das bereits eh genutze JPanel auch noch zum malen benutzen.


Wenn man _nur_ malen möchte, sollte man eher Jcomponent nehmen, dann kommt keiner in Versuchung darauf irgendwelche weitere JComponents einzufügen. Wenn man einen Hintergrund für die gesammte GUI malen will, dann stimmt natürlich das was du geschrieben hast zu 100%. 

Aber darum ging's auch nicht. Wenn man ein JPanel hinzufügt, um dann die GUI schnell auf ein JApplet übertragen zu können, ist das eine Sache. Wenn man ein extra JPanel hinzufügt, nur weil dort ein anderer layout standardmäßig eingestellt ist, dann ist es nun mal ein Hack, der den Sinn des Codes total verschleiert, das einem Anfänger (oder sonst jemandem) zu empfehlen halte ich nach wie vor für keine so tolle Idee.




> Sind für Klassen, die man nur ein einziges mal brauchen wird (bestes Beispiel sind dafür Sachen wie ActionListener die nur zu einem einzigen Button gehören) toll geeignet, da der Code, den der Button ausführt, direkt bei der initialisierung des Buttons dabeisteht und nicht ganz unten irgendwo, wo er als innerhalb eines "class" Blocks rumgamelt.
> Außerdem ist es verwirrend, wenn man irgendwo plötzlich eine Klasse in freier Wildbahn sieht, man aber nicht weiß das die eh nur 1 einzigiges mal instanziert wird.


exakt.

postingcounter--;


----------



## André Uhres (29. Mrz 2009)

0x7F800000 hat gesagt.:


> Wenn man _nur_ malen möchte, sollte man eher Jcomponent nehmen, dann kommt keiner in Versuchung darauf irgendwelche weitere JComponents einzufügen.


Wieso sollte man auf JComponent keine JComponents einzufügen können? Ein JPanel ist auch nichts weiter als ein JComponent (nur mit UI delegate).


----------



## 0x7F800000 (29. Mrz 2009)

André Uhres hat gesagt.:


> Wieso sollte man auf JComponent keine JComponents einzufügen können? Ein JPanel ist auch nichts weiter als ein JComponent (nur mit UI delegate).


Ja, natürlich kann man auch einem JComponent weitere Components hinzufügen, weil es ja irgendwie alles auf's AWT draufgeklebt ist, und von Container abgeleitet ist. Aber rein semantisch sieht es imho besser aus, wenn man von JComponent ableitet im Fall dass eigentlich nichts weiter hinzugefügt werden soll, und von JPanel im Fall dass weitere hinzugefügte Components erwartet werden. Ich finde das einfach wegen der Analogie zu Component & Container irgendwie klarer, beim Component durfte man ja eigentlich nichts hinzufügen (oder etwa doch ???:L)


----------



## Zaphi67 (29. Mrz 2009)

Erstmal vielen Dank für die vielen Tips und Hinweise. Die Lösung für mein Fensterchen fand ich schlißlich im verschachteln von Panels. Dank 0X7F80000hab ich auch die Eventlistener eingebaut.
[HIGHLIGHT="Java"]import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

public class Knöpfe {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		JFrame f = new JFrame("Markos erstes Fenster");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setSize(300,400);
		f.setLocationRelativeTo(null);
		f.getContentPane().setLayout(new GridLayout(2,1));

		JPanel pa = new JPanel();
		f.add(pa);

		JButton a = new JButton("Start");
		a.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.out.println("sie haben Start gedrückt");
            }
        });
		JButton b = new JButton("End");
		b.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.out.println("sie haben End gedrückt");
            }
        });
		JButton c = new JButton("Farbe");
		c.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.out.println("mal die farbe wechseln...");
                ((JButton)e.getSource()).setBackground((new Color[]{Color.RED,Color.BLUE,Color.YELLOW})[(new java.util.Random()).nextInt(3)]);
            }
        });
		pa.add(a);
		pa.add(b);
		pa.add(c);

		JTextArea la = new JTextArea("Soll später die Konsole ersetzen. Hier soll dann stehen welchen Button man gedrückt hat",2,1);
		la.setEditable(false);
		f.add(la);



		f.setVisible(true);
	}

}
[/HIGHLIGHT]
Ein paarSchönheitsfehlermüssen noch ausgebessert werden (das Fenster soll sich nicht vergrößern oder verkleinern lassen).
Vieleicht gibt es ja noch Verbeserungvorschläge. Ich will vieleicht nochmal versuchen das Ganze mit GridBagLayout zu machen.
Aber als nächstes willich versuchen das der Text der momentan in der Konsole ausgegeben wird wenn ein Button gedrückt wird in dem TextArea im Fenster erscheint. Vieleicht beim Farbbutton auch noch welche Farbe grad dargestellt wird.
Ein Problemchen hab ich da schon.Wie überrede ich einen längeren Text wie er jetzt z.B. in dem Textfenster steht einzufließen (mit automatischem Zeileumruch)?


----------



## hdi (29. Mrz 2009)

> class Knöpfe


Bitte keine Umlaute nutzen, weder bei Klassen noch sonst wo.



> das Fenster soll sich nicht vergrößern oder verkleinern lassen


[HIGHLIGHT="Java"]setResizable(false);[/HIGHLIGHT]



> Wie überrede ich einen längeren Text wie er jetzt z.B. in dem Textfenster steht einzufließen (mit automatischem Zeileumruch)?


Was meinst du mit "einfließen"? Als Animation? Dazu bräuchtest du dann einen Thread.

Wenn du einfach nur willst dass eine JTextArea einen gewissen text hat, geht das per

[HIGHLIGHT="Java"]myArea.setText(konsolenText);[/HIGHLIGHT]

automatischer Zeilenumbruch:

[HIGHLIGHT="Java"]myArea.setLineWrap(true);[/HIGHLIGHT]


----------



## Mofi (29. Mrz 2009)

ich würd ehrlich gesagt das panel erst zum frame hinzufügen, wenn die buttons drauf sind.

vermutlich ist es unherheblich, aber ich denke es wäre übersichtlicher bzw. je mehr sachen du dem frame zufügst desto sinnvoller ist es alles nacheinander zu tun und bisher hab ich das immer sehr am ende gesehen 

und wenn du den text im fenster haben willst für ich das eher mit nem JLabel tun. da kannste auch text draufmachen. textarea ist eher was zum eintippen(denk ic hzumindestens)?
beim label kann man den text einfach per setText("text") methode(methode nimmt nen string) setzen.
bei der JTextArea hab ich auf der schnelle nur eine insert methode gefunden. da müsstest mal in der API genauer schauen


----------



## Zaphi67 (29. Mrz 2009)

Super Sache. Alles in 0,nix gefixt. Danki 
Außer eins


> Was meinst du mit "einfließen"? Als Animation? Dazu bräuchtest du dann einen Thread.
> 
> Wenn du einfach nur willst dass eine JTextArea einen gewissen text hat, geht das per
> 
> ...


Also mit einfließen meine ich nur mit Zeilenumbruch (Fließtext).

myArea.setText(konsolenText); hört sich einfach an. Aber wie lese ich den Konsolentext aus? Der ist ja bei jedem Button anders.Bin wie gesagt blutiger Anfänger.Geht das mit System.in.readln oder so?


----------



## 0x7F800000 (29. Mrz 2009)

Zaphi67 hat gesagt.:


> Aber wie lese ich den *Konsolen*text aus? Der ist ja bei jedem *Button* anders.Bin wie gesagt blutiger Anfänger.Geht das mit System.in.readln oder so?


Öhm, was? Programmierst du jetzt was für die Konsole, oder programmierst du jetzt eine GUI? In welcher Richtung ist hier der Norden? ???:L


----------



## Zaphi67 (30. Mrz 2009)

0x7F800000 hat gesagt.:


> Öhm, was? Programmierst du jetzt was für die Konsole, oder programmierst du jetzt eine GUI? In welcher Richtung ist hier der Norden? ???:L



Das ist doch nur ein einfaches Versuchsobjekt. Einen Text auf Buttendruck in der Konsole auszugeben war nur der Versuch Eventlistener anzuwenden.Im Nächsten Schritt will das der Text nicht in der Konsole sondern in dem Textfenster (probierl mal den Quelltext dann siehst du was ich meine, da ist nämlich mächtig was dazugekommen) das jetzt unter den Buttons ist. Schön wär noch wenn da beim Farwechselbutten zusätzlich die aktuelle Farbe wäre.
Also z.B

```
myTextArea.setText(Konsolentext + aktuelle Farbe);
(
```


----------



## 0x7F800000 (30. Mrz 2009)

[highlight=Java]
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

public class _ {
    public static void main(String[] args) {
        JFrame f = new JFrame("Markos erstes Fenster");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300,400);
        f.setLocationRelativeTo(null);
        f.getContentPane().setLayout(new GridLayout(2,1));

        //wofür zum Henker steht "la" lalalalalaaaaa?! 
        //textArea muss aus listenern sichtbar sein, deswegen steht die jetzt hier vorne und ist final.
        //im normalfall wären das eh alles private membervariablen, da wäre die reihenfolge flexibler...
        final JTextArea textArea = new JTextArea(
                "Soll später die Konsole ersetzen. " +
                "Hier soll dann stehen welchen Button man gedrückt hat",2,1);
        textArea.setEditable(false);
        textArea.setLineWrap(true);

        JPanel panel = new JPanel();

        //gleichartige buttons die dasselbe machen kann man ruhig mal auch mit einer schleife erzeugen
        // (nicht dass du dir später ein taschenrechner programmierst, und dann jeden button einzeln erzeugst
        //  solche Leute gibt's hier dauernd, die wollen einfach nicht glauben, 
        //  dass man nicht nur mit integern iterrieren kann...)

        //was ne foreach-schleife ist weißt du hoffentlich? 
        //heist sogut wie "Für jedes String aus diesem Array mach dies und das", ist recht praktisch...
        for(String buttonLabel:new String[]{"Bigbang","Start","Mittendrin","Ende","Dark Era"}){
            JButton b=new JButton(buttonLabel);
            b.addActionListener(new ActionListener(){
                @Override
                public void actionPerformed(ActionEvent e){
                    //dieses casting ist leider ein artefakt aus typunsicheren zeiten 
                    //aber wir wissen ja, dass die quelle ein Button gewesen ist...
                    textArea.append(((JButton)e.getSource()).getText()); 
                }
            });
            panel.add(b);
        }

        JButton c = new JButton("Farbe");
        c.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                ((JButton)e.getSource()).setBackground((new Color[]{Color.RED,Color.BLUE,Color.YELLOW})[(new java.util.Random()).nextInt(3)]);
                textArea.append(((JButton)e.getSource()).getBackground().toString());
            }
        });

        panel.add(c);
        f.add(panel);
        f.add(textArea);

        f.setVisible(true);
    }
}
[/highlight]
da stehn ein paar kommentare drin...


----------



## André Uhres (30. Mrz 2009)

0x7F800000 hat gesagt.:


> Ja, natürlich kann man auch einem JComponent weitere Components hinzufügen, weil es ja irgendwie alles auf's AWT draufgeklebt ist, und von Container abgeleitet ist. Aber rein semantisch sieht es imho besser aus, wenn man von JComponent ableitet im Fall dass eigentlich nichts weiter hinzugefügt werden soll, und von JPanel im Fall dass weitere hinzugefügte Components erwartet werden. Ich finde das einfach wegen der Analogie zu Component & Container irgendwie klarer, beim Component durfte man ja eigentlich nichts hinzufügen (oder etwa doch ???:L)


 Der eigentliche Unterschied besteht lediglich darin, daß JPanel einen UI delegate hat und JComponent nicht. Vom Inhalt her sind sie austauschbar.


----------



## Ebenius (30. Mrz 2009)

0x7F800000 hat gesagt.:


> Ja, natürlich kann man auch einem JComponent weitere Components hinzufügen, weil es ja irgendwie alles auf's AWT draufgeklebt ist, und von Container abgeleitet ist. Aber rein semantisch sieht es imho besser aus, wenn man von JComponent ableitet im Fall dass eigentlich nichts weiter hinzugefügt werden soll, und von JPanel im Fall dass weitere hinzugefügte Components erwartet werden. Ich finde das einfach wegen der Analogie zu Component & Container irgendwie klarer, beim Component durfte man ja eigentlich nichts hinzufügen (oder etwa doch ???:L)


Sehe ich eigentlich genauso. Wenn man eine Komponente baut, um andere Komponenten darauf zu platzieren, nutzt man ein (J)Panel. Wenn man eine Komponente benötigt darüber hinaus noch mehr können soll, leitet man von (J)Panel ab. Soll der Sinn der Komponente aber nicht der sein, andere Komponenten zu tragen, wäre eine Ableitung von JComponent treffender, da diese nicht den Eindruck erwecken würde, eine Komponente zum Zweck des Tragens anderer Komponenten zu sein.

Anmerkung: JComponent zeichnet von Hause aus die Hintergrundfarbe nicht, während JPanel, wenn die _opaque_-Eigenschaft _true_ ist, seine Fläche mit der Hintergrundfarbe füllt. Das muss man bei einem JComponent-Derivat beachten.

Ebenius


----------



## André Uhres (30. Mrz 2009)

Ebenius hat gesagt.:


> Soll der Sinn der Komponente aber nicht der sein, andere Komponenten zu tragen, wäre eine Ableitung von JComponent treffender.


Das sehe ich nicht so, denn der eigentliche Unterschied besteht darin, daß JPanel einen UI delegate hat und JComponent nicht. Vom Inhalt her bleiben sie schlicht austauschbar.


----------



## Ebenius (30. Mrz 2009)

André Uhres hat gesagt.:


> Das sehe ich nicht so, denn der eigentliche Unterschied besteht darin, daß JPanel einen UI delegate hat und JComponent nicht. Vom Inhalt her bleiben sie schlicht austauschbar.


Der Inhalt ist allerdings genau so wichtig wie die Dokumentation. Die Schnittstellenbeschreibung von JPanel ist leider recht spärlich, aber sie behauptet: 





> JPanel is a generic lightweight container.


Mit "generic container" ist gemeint, dass ein JPanel dafür da ist, andere Komponenten unterschiedlicher Art zu tragen. Die Schnittstellenbeschreibung Ihrer Super-Klasse ist für eine Ableitung bindend. Daher wäre JComponent als SuperClass besser geeignet, da diese nicht dem Zweck dient andere Komponenten zu tragen.

Ebenius


----------



## 0x7F800000 (30. Mrz 2009)

André Uhres hat gesagt.:


> Das sehe ich nicht so, denn der eigentliche Unterschied besteht darin, daß JPanel einen UI delegate hat und JComponent nicht. Vom Inhalt her bleiben sie schlicht austauschbar.


Wie gesagt, was die funktionalität der beiden angeht hast du natürlich völlig Recht.
Mir geht's lediglich um den Namen der Dinger. Die ganzen Exceptions tun ja meistens auch nichts sinnvolles, sondern markieren mit ihrem Namen lediglich, was schiefgegangen ist. Aber man geht trotzdem nicht hin und schmeißt MissingRessourceException, wenn eine UnmodifiableSetException vom Sinn her besser gepasst hätte.:bahnhof:


----------



## André Uhres (30. Mrz 2009)

JPanel und JComponent sind beide Container, die geeignet sind um Kindkomponenten aufzunehmen. Wir mögen den einen in einem gewissen Zusammenhang bevorzugen, aber sicherlich nicht aufgrund ener Funktionalität, die beide haben!


----------



## Ebenius (30. Mrz 2009)

André Uhres hat gesagt.:


> JPanel und JComponent sind beide Container, die geeignet sind um Kindkomponenten aufzunehmen. Wir mögen den einen in einem gewissen Zusammenhang bevorzugen, aber sicherlich nicht aufgrund ener Funktionalität, die beide haben!


Nein. Aufgrund einer Beschreibung die beide *nicht* teilen.

Ebenius


----------



## André Uhres (30. Mrz 2009)

Ebenius hat gesagt.:


> Nein. Aufgrund einer Beschreibung die beide *nicht* teilen.
> Ebenius


Klingt verwirrend. Es ist unsinnig zu sagen, ich nehme kein JPanel weil wahrscheinlich keine Kindkomponenten drauf kommen. Jede JComponent kann Kindkomponenten haben (egal ob mit oder ohne Beschreibung).

Wir könnten sinnvoller sagen: Ich nehme JComponent, weil ich keinen UI delegate brauche.


----------



## Ebenius (31. Mrz 2009)

André Uhres hat gesagt.:


> Klingt verwirrend. Es ist unsinnig zu sagen, ich nehme kein JPanel weil wahrscheinlich keine Kindkomponenten drauf kommen. Jede JComponent kann Kindkomponenten haben (egal ob mit oder ohne Beschreibung).


Die API-Doc von JPanel sagt nunmal, ein JPanel wäre ein  "generic container". Das heißt, sein *Zweck* besteht darin, andere Komponenten zu tragen. Wenn eine Komponente diesem Zweck nicht dient, sollte sie auch nicht von JPanel ableiten.



André Uhres hat gesagt.:


> Wir könnten sinnvoller sagen: Ich nehme JComponent, weil ich keinen UI delegate brauche.


Wir könnten vor allem sagen: Ich nehme JComponent, weil ich -- wenn ich ein UI-Delegate benötige -- kein PanelUI haben möchte, sondern ein eigenes. Ein PanelUI geht davon aus, das UI eines "generic container" anzubieten; ein beliebiges LookAndFeel könnte der Meinung sein, für Panels ein UI-Delegate zu anzubieten welches meine Komponente dann plötzlich seltsam dekoriert; mit GradientPaint, Border, irgendeinem Dekor auf dem Hintergrund, ...; wie sich Accessibility-Pakete mit dem vermeintlichen Panel auseinander setzten vermag ich nicht zu vermuten. Außerdem benötige ich keinen LayoutManager der vom JPanel mit initialisiert wird; warum sollte ich den also "mitschleppen".

Wie auch immer Du es begründen möchtest ist mir wurscht: Wenn ich kein Panel habe sondern eine andere Komponente, dann sollte deren Hierarchie nicht behaupten, dass es sich um ein Panel handelte.

Ebenius


----------



## André Uhres (31. Mrz 2009)

Ebenius hat gesagt.:


> Das heißt, sein *Zweck* besteht darin, andere Komponenten zu tragen.


Das ist der Zweck jeder JComponent .


----------



## Ebenius (31. Mrz 2009)

André Uhres hat gesagt.:


> Das ist der Zweck jeder JComponent .


Nö. Der Zweck einer JList ist es, Daten untereinander darzustellen. Der Zweck eines JButtons ist es, eine Aktion per Knopfdruck zur Verfügung zu stellen. Der Zweck eines JMenu ist es, Menüeinträge anzuzeigen. Und der Zweck eines JPanels ist es, beliebige Komponenten zu tragen.

Ebenius


----------



## Leroy42 (31. Mrz 2009)

Zaphi67 hat gesagt.:


> Nun finde ich das Buch allerdings etwas steif und wenig aufeinander Aufbauend. Außedem bevorzuge ich die Methode "learning by doing"...



Ich habe den Thread erst bis hierher gelesen, aber ich prophezeie schon
einmal, das du mit dieser Einstellung "learning by doing" erhebliche Schwierigkeiten 
bekommen wirst.

Hier zum Beispiel schon mal das erste Problem:



Zaphi67 hat gesagt.:


> Ich mußte 3 Buttens machen und einen auf unsichtbar setzen, sonst war der immer über das ganze Fenster und hat die anderen verdeckt. Komischerweise kann ic nur bei 2 Buttons Größe und Position ändern.



:shock:


----------



## Leroy42 (31. Mrz 2009)

hdi hat gesagt.:


> was meinst du mit "einfließen"? Als animation? Dazu bräuchtest du dann einen thread.



lol :d


----------



## André Uhres (31. Mrz 2009)

Ebenius hat gesagt.:


> Nö. Der Zweck einer JList ist es, Daten untereinander darzustellen. Der Zweck eines JButtons ist es, eine Aktion per Knopfdruck zur Verfügung zu stellen. Der Zweck eines JMenu ist es, Menüeinträge anzuzeigen. Und der Zweck eines JPanels ist es, beliebige Komponenten zu tragen.
> 
> Ebenius


Manche JComponents mögen keine Kinder haben, oder haben schon genug davon. Das ändert aber nichts daran, daß alle da sind um Kinder zu haben, ähnlich wie die Menschen


----------



## Ebenius (31. Mrz 2009)

André Uhres hat gesagt.:


> Manche JComponents mögen keine Kinder haben, oder haben schon genug davon. Das ändert aber nichts daran, daß alle da sind um Kinder zu haben, ähnlich wie die Menschen


Ahja. Klar.


----------



## Zaphi67 (2. Apr 2009)

Wollt doch nur ein Wenig Hilfe und nun streiten sich alle um panel oder component .
Naja, mal egal. Ich danke jedenfalls nochmal recht herzlichallen die mir geholfen haben mein kleines erstes Projekt zu verwirklichen. Ich bin sehr stolz darauf, auch wenn es für die Meisten hier warscheinlich Pillepalle ist. Falls sich jemand mitmir freuen möchte hier die Final:
[HIGHLIGHT="Java"]import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.text.*;

import javax.swing.*;

public class Knoepfe {
	public static void main(String[] args) {
		JFrame fenster = new JFrame("Markos erstes Fenster");
		fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		fenster.setSize(300, 200);
		fenster.setLocationRelativeTo(null);
		fenster.setResizable(false);
		fenster.getContentPane().setLayout(new GridLayout(2, 1));

		final JTextArea textArea = new JTextArea("Hier erscheint dann das Resultat", 2,
				1);
		textArea.setEditable(false);
		textArea.setLineWrap(true);

		JPanel panel = new JPanel();
		fenster.add(panel);

		JButton a = new JButton("Zeit");
		a.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				String uhrzeit = DateFormat.getTimeInstance(DateFormat.SHORT).format(new Date());
				textArea.setText("Gibt die aktuelle Uhrzeit aus.\nEs ist:"+uhrzeit);
			}
		});
		panel.add(a);

		JButton b = new JButton("Date");
		b.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				int jj,mm,tt;
			      GregorianCalendar cal = new GregorianCalendar();
			      jj=cal.get(Calendar.YEAR);
			      mm=cal.get(Calendar.MONTH)+1; 
			      tt=cal.get(Calendar.DATE);

			      textArea.setText("Gibt das aktuelle Datum aus.\nDas heutige Datum ist: "+tt+"."+mm+"."+jj);


			}
		});
		panel.add(b);
		JButton c = new JButton("Farbe");
		c.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				((JButton) e.getSource())
						.setBackground((new Color[] { Color.RED, Color.BLUE,
								Color.YELLOW, Color.BLACK, Color.DARK_GRAY, Color.GRAY, Color.CYAN, Color.LIGHT_GRAY,
								Color.MAGENTA, Color.ORANGE, Color.PINK, Color.WHITE})[(new java.util.Random())
								.nextInt(10)]);
				textArea.setText("Hier wird die Farbe des Buttons geändert. "
						+ "\nDies geschieht per Zufallsgenerator."
						+ "\nDie aktuelle Farbe ist: \n\n"
						+ ((JButton) e.getSource()).getBackground().toString());
				// textArea.append(((JButton)e.getSource()).getBackground().toString());
			}
		});
		panel.add(c);
		JLabel platzhalter = new JLabel("Willkommen zu meinem ersten Programm.");
		panel.add(platzhalter);
		JLabel hinweis = new JLabel("Drücken sie eine Taste");
		panel.add(hinweis);
		fenster.add(textArea);

		fenster.setVisible(true);
	}

}
[/HIGHLIGHT]
Nun werd ich mich an mein nächtes Projekt machen. Natürlich brauch ich da auch wieder Hilfe. Ich bin nicht sicher ob ich dazu einen neuen Beitrag schreiben soll, oder einfach hier weitermachen? Ich schreib einfach mal welche Übung mir vorschwebt.
Es soll ein einfaches Fensterchen sein mit nem Button ("drück mich").
Auf klick erscheint jedesmal ein anderer Text in einem Textfenster oder Label.
z.B.
erster klick = "he nicht so doll.Das tut doch weh.Mach nochmal"
zweiter klick = "das war schon besser. Aber etwas gefühlvoller geht bestimmt"
dritter klick = "ohhjaaaa...das war schön. Weiter so".

das ganze bis so ner Art Höhepunkt und dann weiter mit

zwölfter klick = nu is gut
dreizehnter klick = ach menno jetzt langst aber echt
vierzehnter klick = ok..dann eben nochmal von vorn.

Das Fenster mit Text und so sollte kein Prob mer sein.
Aber wie realisiere ich das mit dem Text?
Und wie gehtnach dem letzten Klick alles wieder von vorn los?
Ansatzweise würde ich mal zu ner While Schleife tendieren in der dann ein Array ausgelesen wird in dem die Textzeilen (natürlich als StringVariablen deklariert) ausgelesen werden.
Ist vieleicht nicht die eleganteste Lösung, aber da ich ja amLernen bin willich die Strings erstmal mit in den Code einbauen.
Im nächsten Schritt vieleicht versuchen die Strings aus ner externen Text Datei auszulesen.
Und vieleicht sogar den Butten auf klick noch Geräusche machen lassen.

Also wie immer bin ich für jeden Tip sehr dankbar.
Also schreibt fleißig und streitet euch nicht über panels und component.
Immer dran denken:
Wer andern eine Bratwurst brät, der hat ein Bratwurstbratgerät.

PS:Meine Leertaste ist kaputt :-(


----------



## Schandro (2. Apr 2009)

> Ansatzweise würde ich mal zu ner While Schleife tendieren in der dann ein Array ausgelesen wird in dem die Textzeilen (natürlich als StringVariablen deklariert) ausgelesen werden.


Weiß jetzt nicht wie ne while-Schleife dazu passt.
Du brauchst eigentlich nur:
Ein String-Array (oder ArrayList), in dem die ganzen Texte der Reihenfolge nach abgespeichert sind
Einen int als Membervaraible, der den aktuel ausgegebenen Index abspeichert. Sobald auf den Button geklickt wird, wird dieser Index einfach nur um eins erhöht und das Element des String-Arrays mit diesem index ausgegeben. Sobald der index größer als das String-Array werden will, setzt du ihn wieder auf 0 (einfache if-Abfrage...)

Noch 3 sehr kleine Tips zu deinem fertigen, ansonsten schon ganz guten, Code oben:

1. Besser nicht deutsch und english mischen (Knoepfe und fenster sind mir jetzt direkt aufgefallen)
Besser alles auf English.

2. Ich weiß jetzt nicht, wie wichtig das für JTextAreas ist, wahrscheinlich ist es dort egal weil sie Java-intern sind, aber normalerweise nimmt man nicht
"\n" für einen  Zeilenumbruch, sondern
System.getProperty("line.separator");
Das ist Platformunabhängiger.

3. Die 3 JButons "a", "b" und "c" hätten einen besseren namen verdient


----------



## Landei (2. Apr 2009)

4. Immer wieder benötigte Dinge wiederverwenden

Mach eine Klassen-Variable private static final java.util.Random RANDOM = new java.util.Random(); und dann in main nur noch RANDOM.nextInt();
Das Farb-Feld kannst du ebenfalls so "auslagern"
private static final Color[] COLORS = new Color[]{Color.RED, ...}; und dann in main nur noch COLORS[...]
Das gleiche mit dem Calender u.s.w.


----------



## Ebenius (2. Apr 2009)

Wieso eigentlich "nextInt(10)" bei 12 Farben?  Lagere diesen Teil lieber in eine Methode aus: [HIGHLIGHT="Java"]private static Color randomColor(Color[] colors) {
  return colors[new Random().nextInt(colors.length)];
}[/HIGHLIGHT]
Die Random-Instanz würde ich nicht in der Klasse halten. Sie wird nur an einer Stelle verwendet. Sie kann erzeugt werden wenn sie benötigt wird. Sie wird vergessen, wenn sie nicht mehr gebraucht wird. Das Feld der Farben würde ich ebenfalls aus der Methode herausnehmen. Dadurch wird der Quelltext übersichtlicher.

Ebenius


----------

