Java Brauch mal ein bissel Hilfe :D

[Ru77y]

Tach,
bin quasi "Java-Newbe" => besser gesagt, ich lern es zurzeit!

wollt mal was ausprobieren:

import java.awt.* ;
import java.awt.event.* ;

public class Klick extends Frame
    implements ActionListener, WindowListener {

  private Button b1;
  private Button b2;
  // ... more Components ...

  public Klick (String s) {
    super(s);
  }

  public void init() {
    setLayout (new FlowLayout() );
    b1 = new Button("Press me! ");
    b1.addActionListener (this);
    add(b1);
 
	setLayout (new FlowLayout() );
    b2 = new Button("Press me not! ");
    b2.addActionListener (this);
    add(b2);
    // ... more Components ...
    addWindowListener(this);
    setSize(200,80); // or: pack();
    setVisible(true);
  }

  public static void main (String[] args) {
    Klick f = new Klick("Button");
    f.init();
  }

  public void actionPerformed (ActionEvent e) 
  {
    System.out.println("Button was pressed.");

  	System.out.println("You shouldn´t press the Button.");
  }
  public void windowClosing (WindowEvent e) 
  {
    dispose();
    System.exit(0);
  }
  public void windowClosed (WindowEvent e) { }
  public void windowOpened (WindowEvent e) { }
  public void windowIconified (WindowEvent e) { }
  public void windowDeiconified (WindowEvent e) { }
  public void windowActivated (WindowEvent e) { }
  public void windowDeactivated (WindowEvent e) { }
}

Wo es scheitert, is wenn ich den "Press me not Button!" klicke soll eine andere Bildschirmausgabe kommen!

Danke!

 

[WingX]

Du weist beiden Button denselben ActionListener zu (this). In der Methode ActionPerformed steht halt nun mal eine Ausgabe drin, die von beiden Buttons ausgelöst wird.
Du solltest für jeden Button einen ActionListener erstellen.
Vom Stil her ist es fraglich, ob es sinnvoll ist, eine Frame Klasse zu erweitern und dann das Interface ActionListener zu implementieren.

 

[CoolHandLuke]

besser wäre es so:

JButton addButton = new JButton("Add");
		addButton.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					// hier den Code rein
				}
			});

 

[Ru77y]

Funz net so !
könntest ja mal den kompletten (geänderten) Quelltext posten

 

[DerEineDa]

So sollte das aussehen:

import java.awt.* ;
import java.awt.event.* ;

public class Klick extends Frame {
    
    private Button b1;
    private Button b2;
    // ... more Components ...
    
    public Klick (String s) {
        super(s);
    }
    
    public void init() {
        setLayout (new FlowLayout() );
        b1 = new Button("Press me! ");
        b1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button was pressed.");
            }
        });
        add(b1);
        
        setLayout (new FlowLayout());
        b2 = new Button("Press me not!");
        b2.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println("You shouldn´t press the Button.");
            }
        });
        add(b2);
        // ... more Components ...
        addWindowListener(new WindowAdapter() {
            public void windowClosing (WindowEvent e) {
                dispose();
                System.exit(0);
            }
        });
        
        setSize(200,80); // or: pack();
        setVisible(true);
    }
    
    public static void main (String[] args) {
        Klick f = new Klick("Button");
        f.init();
    }
}

Übrigens würde ich init() noch im Konstruktor aufrufen, und nicht aus der main-Methode heraus.

Vielleicht noch ein paar Worte der Erklärung:
Der Methode addActionListener() übergeben wir eine anonym von ActionListener abgeleitete Klasse. Anonyme Klassen sind eines der nützlichsten und wohl auch wichtigsten Sprachkonstrukte, deswegen solltest du das auf jeden Fall mit lernen.

new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // Code
    }
};

In dem Beispiel leiten wir anonym von ActionListener ab und überlagern direkt die actionPerformed-Methode. Anonym bedeutet in dem Kontext, dass die abgeleitete Klasse keinen Namen besitzt. Wir leiten also direkt von einer Klasse ab, überlagern eine oder mehrere Methoden und machen daraus direkt mit new ein Objekt, das wir der addActionListener-Methode übergeben.

Das selbe wird für addWindowListener gemacht, nur dass ich hier von WindowAdapter ableite, und nicht WindowListener implementiere. WindowListener ist ein Interface, und wie du schon an deinem Beispiel gut sehen konntest, muss man von einem Interface alle seine Methoden implementieren, damit die Klasse nicht als abstrakt gilt. Da dies unbequem ist, gibt es die WindowAdapter-Klasse, die WindowListener komplett mit leeren Methoden implementiert, so dass wir davon ableiten und nur die Methoden überlagern brauchen, die wir auch haben möchten.
Oder andersrum: Hätte ich in meinem Beispiel anstatt WindowAdapter dann WindowListener geschrieben, hätte ich - genau wie du vorher - alle Methoden des WindowListener-Interfaces implementieren müssen, wie du es mit den ganzen leeren Methoden getan hast.

 

[Ru77y]

Danke!!

2 Dinge noch!

=> Das mit dem Konstruktor hatten wir nur mal kurz (demnächst aber mehr) in der Berufss. angeschnitten
> Was war noch mal der Konstruktor


=> Und wie kann man die Console ausblenden, so das man nur das Fenster sieht?


Danke, danke

 

[DerEineDa]

Was der Konstruktor ist:

Salopp gesagt ist es eine Methode, die immer automatisch aufgerufen wird, sobald du mit new ein neues Objekt erzeugst. In deinem Fall erwartet der Konstruktor einen String, den du ja auch in der main-Methode beim new-Aufruf übergibst.

Console ausblenden:

Dein Compiler ruft wahrscheinlich immer beim Starten des Programmes die Datei java.exe auf (das ist die Runtime, in der deine Klasse ausgeführt wird). Wenn du das Konsolenfenster nicht sehen willst, musst du dein Programm mit javaw.exe ausführen.

 

[Ru77y]

javaw => console wird immer noch angezeigt, nur ohne ausgabe

 

[Backslash]

Ich hab zwar keine Ahnung von Java, aber bei C# muss man auch dem Compiler sagen, dass es eine GUI-Anwendung ist, vielleicht gehts in die Richtung

 

[CoolHandLuke]

Dem Compiler muss man hier nichts sagen, javaw sollte eigentlich ausreiche, um keine Konsolenausgabe zu sehen. "start->ausführen" und dann "javaw ..." wenn ich das bei mir unter W2k versuche, bekomme ich die Fehlermeldungen in einer windowstypsichen msgbox - statt an der Konsole.

oder man probiert "start javaw"..... oder wie das noch unter Windows ging.

aber wahrscheinlich wäre es sinnvoller, das Programm in eine jar-Datei zu verpacken. Setzt man die Dateitypenverknüpfungen richtig, so lässt sich das Programm via Doppelklick starten.

Ähnlich einfach wäre ein Webstart mit "offline" Option. Dazu bräuchte man aber einen lokalen oder entfernten Webserver

 

[DerEineDa]

Wenn ich javaw.exe sage, dann meine ich auch javaw.exe

Wichtig ist nur, dass man dem Ding noch den Classpath mitgibt. So in der Art:
javaw.exe -cp c:\OrdnerMitClassDateien Klick
...wobei "Klick" die Class-Datei mit der main-Methode ist, nur eben ohne das ".class" hinten dran.

Klappt mit mit dem beschriebenen Programm einwandfrei.

 

[Ru77y]

Mit javaw jeds doch, habs auch mal mit .jar files probiert und is viel besser!

 

[resi4ever]

Du solltest für jeden Button einen ActionListener erstellen.

Das kann ich ja so nicht stehen lassen...

Du musst nur jedem JButton ein eindeutigs ACTION COMMAND (public void setActionCommand(String actionCommand)) zuweisen und in der actionPerformed() die Quelle des ActionEvents (public Object getSource()) mit dem ACTION COMMAND String vergleichen. Dann kannst du alles in einer actionPerformed() abfackeln.

Da dann aber eine actionPerformed() bei vielen Componenten und Funktionalitäten sehr schnell unübersichtlich wird, solltest du diese Funktionalitäten immer in eigene Methoden kapseln!

Viel Spaß noch beim coden

 

[Patar]

Hi

Man muss nicht für jeden Button einen ActionListener haben, man kann nämlich das ActionEvent e, welches übergeben abfragen, von welcher Schaltfläche es verursacht wurde:

public void actionPerformed (ActionEvent e) 
  {
     if(e.getSource()==b1){
           //erster button gedrückt
     }
     else{
           //anderer Button gedrückt
     }
  }

 

[WingX]

@resiforever und patar: Das ist ein gut gemeinter Hinweis, für jeden Button einen ActionListener zu implementieren. Die meisten Entwicklungsumgebungen machen das nämlich automatisch. Außerdem wird der Code dadurch meiner Meinung nach übersichtlicher, als wenn man in einen ActionEvent ne switch-case hat mit 10 oder 15 Buttons, was bei größeren Frames durchaus passieren kann.