Buttonbefehle in eigene Klasse schreiben

[Heidi]

Schönen guten Abend.

Wie der Titel schon sagt möchte ich die Befehle die beim Klick auf einen Button ausgeführt werden gerne in eigene Klasse schreiben um ein wenig an Übersichtlichkeit zu gewinnen.

Habe einige Foren durchsucht und vieles ausprobiert, gelange aber leider nicht das erreicht was ich erreichen wollte

....
		JButton hinzufuegen = new JButton("Vorgang hinzufügen");
		hinzufuegen.addActionListener(new MyButton());
....

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MyButton extends Benutzeroberfläche implements ActionListener {

	public void actionPerformed(ActionEvent ae){
		bezeichnung.enable(true);
		anfang.enable(true);
		dauer.enable(true);
		erfüllt.enable(true);
		uebernehmen.enable(true);

	}
}

 

[Gast2]

aber leider nicht das erreicht was ich erreichen wollte

Wäre interessant zu wissen was genau das ist

Vermutlich wollst du auf die Variablen

bezeichnung

,

anfang

etc. der Klasse Benutzeroberfläche zugreifen, oder?
Das funktioniert so wie du das gemacht hast leider nicht. Sobald du

new MyButton()

aufrufst wird eine neue Instanz von Benutzeroberfläche erzeugt, und ich denke mal nicht dass du das möchtest.
Du kannst deiner MyButton Klasse eine Referenz auf die bestehende Benutzeroberfläche im Konstruktor mitgeben und auf dieser Referenz dann deine Befehle ausführen.

Aber wie gesagt, ein paar mehr Infos was du überhaupt willst wären hilfreich

 

[Marcinek]

Das ist fast schon richtig.

Nur, dass du durch das erweitern deiner Benutzeroberfläche NICHT das Objekt erweiterst, sondern die Klasse.

Das bedeutet, wenn du in deinem MyButton auf Methoden zugreifst, die von Benutzeroberfläche erben, dann änderst du nicht die Benutzeroberfläche, die den ActionListener erzeugt.
Denke das ist logisch.

Um das aber tun zu können musst du nicht von Benutzeroberfläche erben, sondern du musst die Referenz des Objekts in deinen Actionlistener bekannt machen.

i.d.R. wirst du in dem Konstruktor deines Actionlisteners noch Benutzeroberfläche als Parameter einfügen.

....
        JButton hinzufuegen = new JButton("Vorgang hinzufügen");
        hinzufuegen.addActionListener(new MyButton(this));
....

und

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
public class MyButton extends Benutzeroberfläche implements ActionListener {

private Benutzeroberfläche eineBenutzeroberfäche = null; 

     public MyButton (Benutzeroberfläche eineOberfläche) {
        this.eineBenutzeroberfläche = eineOberfläche;
    }

    public void actionPerformed(ActionEvent ae){
        this.eineBenutzeroberfläche.bezeichnung.enable(true);
        this.eineBenutzeroberfläche.anfang.enable(true);
        this.eineBenutzeroberfläche.dauer.enable(true);
        this.eineBenutzeroberfläche.erfüllt.enable(true);
        this.eineBenutzeroberfläche.uebernehmen.enable(true);
 
    }
}

 

[Heidi]

Das ist fast schon richtig.

Nur, dass du durch das erweitern deiner Benutzeroberfläche NICHT das Objekt erweiterst, sondern die Klasse.

Das bedeutet, wenn du in deinem MyButton auf Methoden zugreifst, die von Benutzeroberfläche erben, dann änderst du nicht die Benutzeroberfläche, die den ActionListener erzeugt.
Denke das ist logisch.

Um das aber tun zu können musst du nicht von Benutzeroberfläche erben, sondern du musst die Referenz des Objekts in deinen Actionlistener bekannt machen.

i.d.R. wirst du in dem Konstruktor deines Actionlisteners noch Benutzeroberfläche als Parameter einfügen.

Vielen Dank schonmal für die Hilfe und die gute und verständnissvolle Erklärung...

Aber bevor ich jetzt google, kann ich auch direkt fragen.
was bedeutet "...=null;"
das habe ich des öfteren gelesen und möchte jetzt auch gerne mal wissen was dadurch geschieht

 

[Marcinek]

Das ist eine null-Referenz also nix.

Wie ein leerer Behälter.

Da hätte man aber googeln können :bahnhof:

 

[Michael...]

was bedeutet "...=null;"

Die Referenz der Variable auf ein Objekt wird quasi "gelöscht", d.h. die Variable referenziert auf nichts mehr - ist sozusagen leer.

JButton button = new JButton("OK");  // button referenziert auf einen JButton mit der Beschriftung OK
button = null; //jetzt referenziert button auf nichts mehr

Dies macht man manchmal um explizit Variablen mit null zu initialisieren, oder wenn man sicherstellen will, das die Variable nicht mehr auf das ursprüngliche Objekt verweist.

Zu Deiner usprunglichen Fragestellung: Was soll den nach dem Buttonclick passieren? Hast Du da ein (kleines) konkretes Bsp?

 

[Heidi]

So für den einen Button hat das soweit ganz gut geklappt und macht ja auch sinn.

Sobald ich aber nun ein wenig Handlung in den Button hinbekommen will läuft das gar nicht wie ich das gerne hätte

die klasse "ButtonHinzufuegen" läuft soweit reibungslos

bei der Klasse "ButtonEntfernen treten dann schon Probleme auf....
also mein problem ist das die variable index nicht übergeben wird(resultiert aus einem mouseclickedlistener)

public class TestBenutzeroberfläche {
	public static void main(String[] args) {
		Benutzeroberfläche b=new Benutzeroberfläche();
		b.Benutzeroberfläche();
		HinweiseBenutzeingabe benutz=new HinweiseBenutzeingabe();
		benutz.HinweisBenutzeingabe();
	}
}

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;

import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.ToolTipManager;
import javax.swing.border.TitledBorder;

public class Benutzeroberfläche extends JFrame implements ActionListener,
		MouseListener {
	protected DefaultListModel daten = new DefaultListModel();
	private JList auflistung = new JList(daten);
	protected JButton hinzufuegen;
	private JButton bearbeiten = new JButton("Vorgang bearbeiten");
	private JButton entfernen;

	protected JTextField bezeichnung = new JTextField();
	protected JTextField anfang = new JTextField();
	protected JTextField dauer = new JTextField();
	protected JTextField erfüllt = new JTextField();
	protected JButton uebernehmen = new JButton("Änderungen übernehmen");
	private JPanel p1, p2, p3, p4, p5, p6, p7, p8;
	protected int index;
	protected ArrayList<Vorgang> vorgaenge = new ArrayList<Vorgang>();

	public void Benutzeroberfläche() {

		this.setTitle("Gannt-Diagramm-Editor");
		this.setSize(1050, 650);
		this.setLocationRelativeTo(null);
		this.setVisible(true);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		bezeichnung.enable(false);
		anfang.enable(false);
		dauer.enable(false);
		erfüllt.enable(false);
		uebernehmen.enable(false);

		hinzufuegen = new JButton("Vorgang hinzufügen");
		hinzufuegen.addActionListener(new ButtonHinzufuegen(this));
		
		entfernen=new JButton ("Vorgang entfernen");
		entfernen.addActionListener(new ButtonEntfernen(this,index));

		// JPanel-Verschachtelung zur Darstellung "Alle Vorgänge"
		p1 = new JPanel(new GridLayout(2, 1, 5, 5));
		p1.setBorder(new TitledBorder("Alle Vorgänge"));
		p1.add(auflistung);

		p2 = new JPanel(new GridLayout(3, 1, 5, 5));
		p2.add(hinzufuegen);
		p2.add(bearbeiten);
		p2.add(entfernen);

		p1.add(p2);

		// JPanel-Verschachtelung zur Darstellung "Vorgangsdaten"
		p3 = new JPanel(new BorderLayout(5, 5));
		p6 = new JPanel(new GridLayout(4, 2, 5, 5));
		p3.setBorder(new TitledBorder("Vorgangsdaten"));
		p6.add(new JLabel("Bezeichnung"));
		p6.add(bezeichnung);
		p6.add(new JLabel("Starttag"));
		p6.add(anfang);
		p6.add(new JLabel("Dauer"));
		p6.add(dauer);
		p6.add(new JLabel("Erfüllt"));
		p6.add(erfüllt);
		p3.add(p6, BorderLayout.CENTER);
		p3.add(uebernehmen, BorderLayout.SOUTH);

		p7 = new JPanel(new GridLayout(1, 1, 5, 5));
		p7.setBorder(new TitledBorder("Projektdaten"));

		p4 = new JPanel(new GridLayout(3, 1));
		p4.add(p1);
		p4.add(p3);
		p4.add(p7);

		// JPanel zur Darstellung des Gantt-Diagramms
		p5 = new JPanel(new GridLayout(1, 1, 10, 10));
		p5.setBorder(new TitledBorder("Diagramm"));
		p8 = new GanttDiagrammDarstellung(vorgaenge);
		p5.add(p8);

		this.add(p4, BorderLayout.WEST);
		this.add(p5, BorderLayout.CENTER);

		// ActionListener-Methode den JButtons zuweisen
		uebernehmen.addActionListener(this);
		bearbeiten.addActionListener(this);
		// MouseListener-Methode den Textfeldern zuweisen
		auflistung.addMouseListener(this);

	}

	// mouseClicked-Event zur Bestimmung des angewählten Namens

	public void mouseClicked(MouseEvent e) {
		if (e.getClickCount() == 1) {
			index = auflistung.locationToIndex(e.getPoint());
		}
	}
	

	public void actionPerformed(ActionEvent ae) {

		if (ae.getSource() == bearbeiten) {
			bezeichnung.enable(true);
			anfang.enable(true);
			dauer.enable(true);
			erfüllt.enable(true);
			uebernehmen.enable(true);
			bezeichnung.setText(vorgaenge.get(index).getName());
			anfang.setText("" + vorgaenge.get(index).getAnfang());
			dauer.setText("" + vorgaenge.get(index).getDauer());
			erfüllt.setText("" + vorgaenge.get(index).getErfüllt() + "%");
			vorgaenge.remove(index);
			daten.remove(index);
			System.out.println(index);
		}

//		if (ae.getSource() == entfernen) {
//			bezeichnung.enable(true);
//			anfang.enable(true);
//			dauer.enable(true);
//			erfüllt.enable(true);
//			uebernehmen.enable(true);
//			vorgaenge.remove(index);
//			daten.remove(index);
//		}

		if (ae.getSource() == uebernehmen) {
			String name = bezeichnung.getText();
			double a = Double.parseDouble(anfang.getText());
			double d = Double.parseDouble(dauer.getText());
			double e = Double.parseDouble(erfüllt.getText());
			vorgaenge.add(new Vorgang(name, a, d, e));
			daten.addElement(name);
			// Eingabefelder leeren
			bezeichnung.setText("");
			anfang.setText("");
			dauer.setText("");
			erfüllt.setText("");
			// Eingabefelder "ausschalten"
			bezeichnung.enable(false);
			anfang.enable(false);
			dauer.enable(false);
			erfüllt.enable(false);
			uebernehmen.enable(false);
			// Gannt-Diagramm erneuern
			p5.remove(p8);
			p8 = new GanttDiagrammDarstellung(vorgaenge);
			p5.add(p8);

		}

	}

	public void mouseEntered(MouseEvent e) {
	}

	public void mouseExited(MouseEvent e) {
	}

	public void mousePressed(MouseEvent e) {
	}

	public void mouseReleased(MouseEvent e) {
	}
}

import inf.v3d.obj.Text;

import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;

import javax.swing.JComponent;
import javax.swing.JPanel;

public class GanttDiagrammDarstellung extends JPanel {

	private ArrayList<Vorgang> vorgaenge;
	private int gesamtdauer;

	public GanttDiagrammDarstellung(ArrayList<Vorgang> vorgaenge) {
		super();
		this.vorgaenge = vorgaenge;
	}

	public void zählerFürDauer() {
		gesamtdauer = 0;
		for (int i = 0; i < vorgaenge.size(); i++) {
			if (vorgaenge.get(i).getAnfang() + vorgaenge.get(i).getDauer() > gesamtdauer) {
				gesamtdauer = (int) (vorgaenge.get(i).getAnfang() + vorgaenge
						.get(i).getDauer());
			}
		}
	}

	// Verwendung von Boxen zur grafischen Darstellung der Bauabläufe
	public void balkenDarstellung(Graphics g) {
		for (int i = 0; i < vorgaenge.size(); i++) {
			double erfüllt= (vorgaenge.get(i).getDauer())*((vorgaenge.get(i).getErfüllt())/100);
			double unerfüllt=(vorgaenge.get(i).getDauer())-erfüllt;
			g.setColor(Color.red);
			g.drawRect((int) (120 + 15 * vorgaenge.get(i).getAnfang()),
					115 + 50 * i, (int) (15 * (vorgaenge.get(i).getDauer())),
					15);
			g.fillRect((int) (120 + 15 * vorgaenge.get(i).getAnfang()),
					115 + 50 * i, (int) (15 * (vorgaenge.get(i).getDauer())),
					15);
			g.setColor(Color.green);
			g.drawRect((int) (120 + 15 * vorgaenge.get(i).getAnfang()),
					115 + 50 * i, (int) (15 * erfüllt),
					15);
			g.fillRect((int) (120 + 15 * vorgaenge.get(i).getAnfang()),
					115 + 50 * i, (int) (15 * erfüllt),
					15);
		}
	}

	// Beschriftung der Balken
	public void vorgangsBeschriftung(Graphics g) {
		g.setColor(Color.black);
		for (int i = 0; i < vorgaenge.size(); i++) {
			g.drawString(vorgaenge.get(i).getName(), 10, (int) (130 + i * 50));

		}
	}

	// Grafische Darstellung der Zeitunterteilung
	public void unterteilungTage(Graphics g) {
		zählerFürDauer();
		for (int i = 0; i < gesamtdauer; i++) {
			g.setColor(Color.gray);
			g.drawLine(120 + i * 15, 100, 120 + i * 15, 500);
			if (i % 5 == 0) {
				g.drawString(""+i, 116+i*15, 95);
				g.drawRect(119+i*15, 100, 2, 400);
				g.fillRect(119+i*15, 100, 2, 400);
			}
		}
	}

	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		unterteilungTage(g);
		balkenDarstellung(g);
		vorgangsBeschriftung(g);
	}

}

import java.util.ArrayList;

import javax.swing.ToolTipManager;

public class HinweiseBenutzeingabe extends Benutzeroberfläche {

	public void HinweisBenutzeingabe() {

		// Tooltipps für die Eingabewerte durch den Benutzer
		ToolTipManager.sharedInstance().setInitialDelay(100);
		bezeichnung
				.setToolTipText("<html>Geben Sie hier den Namen ihres Vorgangs ein.<br>Benutzen Sie bitte Werte größer 0!</html>");
		anfang
				.setToolTipText("<html>Geben Sie hier den Starttag ihres Vorgangs ein.<br>Benutzen Sie bitte Werte größer 0!</html>");
		dauer
				.setToolTipText("<html>Geben Sie hier die Dauer ihres Vorgangs ein.<br>Benutzen Sie bitte Werte größer 0!</html>");
		erfüllt
				.setToolTipText("<html>Geben Sie hier den Erfüllungsgrades ihres Vorgangs ein.<br>Benutzen Sie bitte Werte zwischen 0 und 100!</html>");

	}

}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class ButtonEntfernen extends Benutzeroberfläche implements
		ActionListener {

	private Benutzeroberfläche eineBenutzeroberfläche=null;

	public ButtonEntfernen(Benutzeroberfläche eineOberfläche, int index) {
		this.eineBenutzeroberfläche = eineOberfläche;
		this.index = index;
	}

	public void actionPerformed(ActionEvent ae) {
		bezeichnung.enable(true);
		anfang.enable(true);
		dauer.enable(true);
		erfüllt.enable(true);
		uebernehmen.enable(true);
		System.out.println(index);
		vorgaenge.remove(index);
		daten.remove(index);

	}
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ButtonHinzufuegen extends Benutzeroberfläche implements
		ActionListener {

	private Benutzeroberfläche eineBenutzeroberfläche;

	public ButtonHinzufuegen(Benutzeroberfläche eineOberfläche) {
		this.eineBenutzeroberfläche = eineOberfläche;

	}

	public void actionPerformed(ActionEvent ae) {
		//Eingabefelder "ausschalten"
		this.eineBenutzeroberfläche.bezeichnung.enable(true);
		this.eineBenutzeroberfläche.anfang.enable(true);
		this.eineBenutzeroberfläche.dauer.enable(true);
		this.eineBenutzeroberfläche.erfüllt.enable(true);
		this.eineBenutzeroberfläche.uebernehmen.enable(true);

	}
}

public class Vorgang {
	private String name;
	private double anfang;
	private double dauer;
	private double erfüllt;

	public Vorgang(String name, double anfang, double dauer, double erfüllt) {
		this.name = name;
		this.anfang = anfang;
		this.dauer = dauer;
		this.erfüllt = erfüllt;
	}

	public String getName() {
		return name;
	}

	public double getAnfang() {
		return anfang;
	}

	public double getDauer() {
		return dauer;
	}

	public double getErfüllt() {
		return erfüllt;
	}
}

 

[Michael...]

Oh je ;-) Bitte nicht persönlich nehmen, aber da fehlt wohl noch an den Grundlagen. Mit Oberflächen sollte man erst loslegen, wenn man ein allgemeines Verständnis für die OO-Programmierung mit Java hat, sonst verrennt man sich.

Dieses ganze extends Benutzeroberfläche ist Quatsch, da Du ja nicht die Klasse Benutzeroberfläche erweitern willst, sondern in den einzelnen Klassen auf ein konkretes Objekt der Klasse Benutzeroberfläche zugreifen willst.
Und folgendes sollten eigentlich Konstruktoren werden:

[JAVA=36] public void Benutzeroberfläche() {[/code]
...
[JAVA=7] public void HinweisBenutzeingabe() {[/code]

Welche Inhalte man aus Klassen auslagert und welche nicht, sollte man sich gut Überlegen. In Deinem Fall haben die Actions u.a. auch unmittelbare Auswirkungen auf die GUI selbst, dieses auszulagern macht (zumindest) so nicht viel Sinn. Man könnte einzelne Umfänge aus der GUI zusammenfassen und als eigene Komponente aus der GesamtGUI auslagern.

Im folgenden Bsp. habe ich mal eine Möglichkeit aufgezeigt ActionListener als eigene Klasse auszulagern. Da aber aufgrund der Actions manipulationen an der GUI vorgenommen werden, habe ich zum einen das GUI Objekt an den Listener (über dessen Konstrukor) übergeben zum anderen aber die Methoden selbst in der GUI Klasse implementiert. Es macht da nicht unbedingt Sinn, dass der Listener die einzelnen Bestandteile der GUI bis ins letzte Detail kennt.

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class Demo {
	
	public static void main(String[] s) {
		Demo demo = new Demo();
		DemoGUI gui = demo.new DemoGUI();
		gui.setVisible(true);
	}
	
	private static String EDIT = "Bearbeiten", DELETE = "Entfernen", SAVE = "Speichern";
	
	class DemoGUI extends JFrame {
		private JTextArea textArea;
		private JButton bearbeitenBtn, entfernenBtn, speichernBtn;
		
		public DemoGUI() {
			this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			this.setBounds(0, 0, 400, 200);
			this.setLocationRelativeTo(null);
			textArea = new JTextArea("DummyText");
			bearbeitenBtn = new JButton(Demo.EDIT);
			entfernenBtn = new JButton(Demo.DELETE);
			speichernBtn = new JButton(Demo.SAVE);
			JPanel panel = new JPanel(new GridLayout(1, 3));
			panel.add(bearbeitenBtn);
			panel.add(entfernenBtn);
			panel.add(speichernBtn);
			
			this.getContentPane().add(new JScrollPane(textArea), BorderLayout.CENTER);
			this.getContentPane().add(panel, BorderLayout.SOUTH);
			
			this.speichernAction();
			
			MyActionListener listener = new MyActionListener(this);
			bearbeitenBtn.addActionListener(listener);
			entfernenBtn.addActionListener(listener);
			speichernBtn.addActionListener(listener);
		}
		
		public void bearbeitenAction() {
			textArea.setEnabled(true);
			speichernBtn.setEnabled(true);
			bearbeitenBtn.setEnabled(false);
		}
		
		public void entfernenAction() {
			textArea.setText("");
			textArea.setEnabled(true);
			speichernBtn.setEnabled(true);
			bearbeitenBtn.setEnabled(false);
		}
		
		public void speichernAction() {
			textArea.setEnabled(false);
			speichernBtn.setEnabled(false);
			bearbeitenBtn.setEnabled(true);
		}
	}
	
	class MyActionListener implements ActionListener {
		private DemoGUI gui;
		
		public MyActionListener(DemoGUI gui) {
			this.gui = gui;
		}
		
		public void actionPerformed(ActionEvent e) {
			if (e.getActionCommand().equals(Demo.EDIT))
				gui.bearbeitenAction();
			else if (e.getActionCommand().equals(Demo.DELETE))
				gui.entfernenAction();
			else if (e.getActionCommand().equals(Demo.SAVE))
				gui.speichernAction();
		}
	}
}

 

[Heidi]

Oh je ;-) Bitte nicht persönlich nehmen, aber da fehlt wohl noch an den Grundlagen. Mit Oberflächen sollte man erst loslegen, wenn man ein allgemeines Verständnis für die OO-Programmierung mit Java hat, sonst verrennt man sich.

Dieses ganze extends Benutzeroberfläche ist Quatsch, da Du ja nicht die Klasse Benutzeroberfläche erweitern willst, sondern in den einzelnen Klassen auf ein konkretes Objekt der Klasse Benutzeroberfläche zugreifen willst.
Und folgendes sollten eigentlich Konstruktoren werden:


Welche Inhalte man aus Klassen auslagert und welche nicht, sollte man sich gut Überlegen. In Deinem Fall haben die Actions u.a. auch unmittelbare Auswirkungen auf die GUI selbst, dieses auszulagern macht (zumindest) so nicht viel Sinn. Man könnte einzelne Umfänge aus der GUI zusammenfassen und als eigene Komponente aus der GesamtGUI auslagern.

Im folgenden Bsp. habe ich mal eine Möglichkeit aufgezeigt ActionListener als eigene Klasse auszulagern. Da aber aufgrund der Actions manipulationen an der GUI vorgenommen werden, habe ich zum einen das GUI Objekt an den Listener (über dessen Konstrukor) übergeben zum anderen aber die Methoden selbst in der GUI Klasse implementiert. Es macht da nicht unbedingt Sinn, dass der Listener die einzelnen Bestandteile der GUI bis ins letzte Detail kennt.

Vielen Dank für den Hinweis. Hab es jetzt erstmal aufgegeben die Buttons alle in eigene Klassen zu packen und setze statt übersichtlichkeit dann doch lieber auf funktionalität des programms. muss ja schließlich freitag fertig sein.

trotzdem vielen dank für die mühen...:toll: