Vernünftige Strukturierung, Guter Stil,.

[UnkiDunki]

Hi,

es gibt schon zwar einige Themen in diesem Forum, die meine Frage betreffen, aber da das eigentlich immer nur kurz angeschnitten worden ist und nicht ausführlich behandelt wurde, möchte ich da noch mal drauf eingehen:

Was ist eine vernünftige Strukturierung für ein Java-Programm? Was bezeichnet man als guten Stil?

Mir geht es jetzt garnicht um Style-Guides, sondern um einen bestmöglichen Programmaufbau und dass damit eine sehr gute Übersicht/"Wartungsmöglichkeit" gegeben ist.

Ich persönlich finde meinen Aufbau zwar schon verbessert, wenn man bedenkt, dass ich anfänglich z.B. bei Swing die GUI und alle damit im Zusammenhang stehenden Methoden in eine Klasse gepackt habe, aber zufrieden bin ich immer noch nicht...

Was sollte man also beachten? Was, warum und vorallem wie voneinander am besten trennen?

Ich habe das jetzt mal nach "Anfängerfragen" gepackt, weil das ja ziemlich essentiell ist, wenn mich auch der Schwerpunkt mit z.B. Swing am meisten interessieren würde...

Freue mich auf eure Beteiligung

 

[Landei]

Das wichtigste Prinzip ist meiner Meinung nach "Separation of Concerns". Wenn z.B. eine Methode (oder Klasse) etwas ausrechnet und dann anzeigt, sollte man sie in genau diese Teile aufspalten. Eigentlich auch logisch, wie soll ich sonst z.B. das Ergebnis vernünftig testen? Dann gilt natürlich "DRY" = don't repeat yourself: Duplizierter Code gehört zusammengefaßt. Mein nächster Vorschlag ist, Singletons möglichst zu vermeiden.

Insgesamt sollte man versuchen, den Code nicht "zu clever" zu schreiben. Immer, wenn ich versucht bin, einen Kommentar zu schreiben, wie eine Methode eigentlich funktioniert, habe ich mir angewöhnt, stattdessen über eine Vereinfachung / Aufteilung nachzudenken.

 

[foobar]

Darauf gibt es keine Pauschalantwort.

Zeig mal etwas Code, dann können wir dir bestimmt ein paar Tipps geben.

 

[UnkiDunki]

@Landei: Danke, das sind schon mal ein paar Tipps, mit denen ich was anfangen kann

@foobar: Ich wage mal dir vorsichtig zu widersprechen. Mit Sicherheit gibt es da sehr viele Pauschalantworten. Es gibt nur nicht DIE Antwort auf meine Frage, da es natürlich nicht DIE Programmstruktur gibt.
Und wenn ich jetzt Code poste, so finde ich, bekomme ich eben gerade dann nicht wirklich die "pauschalen" Antworten, die ich mir wünsche... ähhh... wie auch immer

Als Bsp. kann ich dir aber gerne mal die schon genannte GUI-Anwendung nennen, die natürlich das Design des z.B. JFrames beinhaltet, dann die ausgelösten Methoden, z.B. auf Drücken eines Buttons (also ActionListener), etc.

Sorry, wenn ich jetzt "verquer" schreibe

 

[Zed]

Mach ich einen kleinen Dialog dann lagere ich eigentlich (es gibt immer Sonderfälle) nichts aus Darstellung und Logik in eine Klasse. Der Actionlistener macht meistens nur ein Dispose. So hab ich alle auf einem Fleck und muss nicht über 2 o. 3 Klassen suchen.

Hab ich ein Menü und eine Statusleiste. Dann hab ich eine Mainklasse die einen ActionListener hat an diese binde ich mein Menü an. Die Menü Klasse kümmert sich nur um die Darstellung und anbindung an die MainKlasse. Wiederrum eine Statusanzeige in der Statusbar bei Mouseover habe ich gern in der Menüklasse. Habs nicht so gern wenn jeder scheiss in meiner Mainklasse ist.

Hab ich in der Main ein komliziertes Panel dann hat dieses Panel auch eine Main usw.

[Update]
Für Localisierung und Eigenschaften hab ich eigentlich immer gern einen Singelton Klasse. Wenns um Datum schiebereien geht habe ich eine Klasse DateUtilities auch Singelton.
Und ein Commnobjects Klasse als Singelton die meine MainKlasse hällt und oft benötigte Sachen

 

[0x7F800000]

Insgesamt sollte man versuchen, den Code nicht "zu clever" zu schreiben. Immer, wenn ich versucht bin, einen Kommentar zu schreiben, wie eine Methode eigentlich funktioniert, habe ich mir angewöhnt, stattdessen über eine Vereinfachung / Aufteilung nachzudenken.

ooh ja
dazu muss ich mich konsequenter zwingen, auch wenn's wehtut... guter tipp!

 

[UnkiDunki]

@foobar: Ich lasse doch mal die Hosen runter und zeige euch mal eine Klasse, die ihr hinsichtlich Struktur und Style bewerten könnt. Also hier mal ein sicherlich "Negativbeispiel":

Login-Fenster, welches Username und Passwort validiert (Datenbank) und bei Korrektheit das JFMain, also das Hauptfenster aufruft.

package gui;

import java.awt.Frame;
...
import javax.swing.JTextField;


import methods.Methods;

public class JFLogin extends JFrame{

	private static final long serialVersionUID = 1L;
	
	final JTextField textUsername = new JTextField("", 15);
	final JPasswordField textPassword = new JPasswordField(15);
	private static ResourceBundle textBundle = Methods.textBundle;
	
	public JFLogin(){
		
		super("JFLogin");
		paintGUI();
		}

	private void paintGUI() {

		// set frame
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setSize((int)(this.getToolkit().getScreenSize().width * 0.3),(int)(this.getToolkit().getScreenSize().height * 0.3));

		// location: central
		this.setLocation(this.getToolkit().getScreenSize().width / 2 - this.getWidth() / 2, this.getToolkit().getScreenSize().height/ 2 - this.getHeight() / 2);

		// set layout
		GridBagConstraints constraints = new GridBagConstraints();
		this.getContentPane().setLayout(new GridBagLayout());
		
		// add label "username"
		constraints.gridx = 0;
		constraints.gridy = 0;
		this.getContentPane().add(new JLabel(textBundle.getString("LABEL.username")+"*: "), constraints);

		// add textfield "username"
		constraints.gridx = 1;
		constraints.gridy = 0;
		this.getContentPane().add(textUsername, constraints);
		
		// add label "password"
		constraints.gridx = 0;
		constraints.gridy = 1;
		this.getContentPane().add(new JLabel(textBundle.getString("LABEL.password")+": "), constraints);

		// add textfield "password"
		constraints.gridx = 1;
		constraints.gridy = 1;
		textPassword.setEchoChar('#');
		this.getContentPane().add(textPassword, constraints);

		// add button "ok"
		constraints.gridx = 0;
		constraints.gridy = 2;
		JButton buttonOK = new JButton(textBundle.getString("BUTTON.enter"));
		this.getContentPane().add(buttonOK, constraints);
		
		// add button "cancel"
		constraints.gridx = 1;
		constraints.gridy = 2;
		JButton buttonCancel = new JButton(textBundle.getString("BUTTON.cancel"));
		this.getContentPane().add(buttonCancel, constraints);
		
		// add button "settings"
		constraints.gridx = 2;
		constraints.gridy = 2;
		JButton buttonSettings = new JButton(textBundle.getString("BUTTON.settings"));
		this.getContentPane().add(buttonSettings, constraints);
		
		textUsername.requestFocus();
		this.pack();
		
		// ----------- KEYLISTENER ------------
		textUsername.addKeyListener(new KeyListener() {

			public void keyPressed(KeyEvent key) {
				if (key.getKeyCode() == KeyEvent.VK_ENTER) {
					// TODO Auto-generated method stub
					textPassword.requestFocus();
				}

			}

			public void keyReleased(KeyEvent arg0) {
				// TODO Auto-generated method stub

			}

			public void keyTyped(KeyEvent arg0) {
				// TODO Auto-generated method stub

			}
		});
		
                // weitere KEYLISTENER
                ....
		
		// ----------- ACTIONLISTENER -------------
		buttonCancel.addActionListener(new ActionListener() {

			public void actionPerformed(final ActionEvent evt) {
				// TODO Auto-generated method stub
				
				try {
					Methods.closeConnection();
					Methods.closeH2Connection();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				dispose();
			}

		});

               // weitere ACTIONLISTENER
               ....
	}

	protected void buttonOKActionPerformed(ActionEvent evt) {
	
		if(!Methods.valiTFs(new JTextField[]{textUsername})) return;
		
		String pass = String.valueOf(textPassword.getPassword());
		String user = textUsername.getText();
		
		// verify with database informations
		try {
			Connection con = Methods.getConnection();
			Statement stmt = con.createStatement();
			ResultSet rs = stmt
					.executeQuery("SELECT * FROM USERS WHERE users_name = '"+ user + "' AND users_name != ''");

			String password = null;
			String currentUsername = null;

			while (rs.next()) {
				try {
					password = Methods.decryptData(rs.getString("users_password"));
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				currentUsername = rs.getString("users_name");
			}

			if (pass.equals(password)) { // check password

				Methods.setCurrentUsername(currentUsername);
				
				JFMain main = new JFMain();
				new Methods.JFrameShower(main);
				
				Methods.setLog(textBundle.getString("LOG.login"),0,"");
				
				dispose();
			} else {
				JOptionPane.showMessageDialog(null,textBundle.getString("ERROR.username_or_password_incorrect"), Methods.getTextBundle().getString("ERROR"),JOptionPane.ERROR_MESSAGE);
			}
		} catch (SQLException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	protected void buttonSettingsActionPerformed(ActionEvent evt) {
		// TODO Auto-generated method stub
		setEnabled(false);
		final JFSettings frame = new JFSettings(this);
		
		new Methods.JFrameShower(frame);
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosed(final WindowEvent e) {
				enableFrame();
			}
		});
	}		
	
	private void enableFrame() {
		this.setEnabled(true);
		this.setState(Frame.NORMAL);
		this.requestFocus();
	}
}

Habe, wie ihr seht, die GUI-Klassen im package "gui", TableModels, Tables in package "tables", die ausgelagerten Methoden in package "methods", etc. um da wenigstens ein wenig Struktur reinzubringen

Im Prinzip ist das eine ganz simple Klasse mit GUI, Key-, Actionlisteners und einigen Methoden.

Für Methoden, die ich häufiger gebrauche, wie z.B. Pflichtfeld-Überprüfung

Methods.valiTFs(new JTextField[]{textUsername})

habe ich eine eigene Klasse "Methods" die all diese statischen Methoden beinhaltet. Ob das so sinnvoll ist, mag ich zu bezweifeln, aber was weiss ich schon

Danke schon mal für euer Feedback

 

[Zed]

 final JTextField textUsername = new JTextField("", 15);
   final JPasswordField textPassword = new JPasswordField(15);
   private static ResourceBundle textBundle = Methods.textBundle;

Sollte man lassen was ist wenn Methods.textBundle ne Exception wirft? Definieren ok initialisieren irgendwo in einer init Methode.

Vorschlag:
Beim GridBagLayout diese Methoden nutzen.

	protected void addComponentInContainer(
		JComponent aGridBagLayoutetContainer,
		JComponent aComponentToAdd,
		int aGridX,
		int aGridY,
		int aGridWidth,
		int aGridHeigth,
		int aFillConstraint,
		int anAnchorConstraint,
		double aWeightX,
		double aWeightY,
		Insets anInsets) {

		GridBagConstraints theConstraint = new GridBagConstraints();

		theConstraint.gridx = aGridX;
		theConstraint.gridy = aGridY;
		theConstraint.gridwidth = aGridWidth;
		theConstraint.gridheight = aGridHeigth;
		theConstraint.fill = aFillConstraint;
		theConstraint.anchor = anAnchorConstraint;
		theConstraint.weightx = aWeightX;
		theConstraint.weighty = aWeightY;
		theConstraint.insets = anInsets;

		aGridBagLayoutetContainer.add(aComponentToAdd, theConstraint);
	}
protected void addComponentInLayout(
		JComponent aComponent,
		int aGridX,
		int aGridY,
		int aGridWidth,
		int aGridHeigth,
		int aFillConstraint,
		int anAnchorConstraint,
		double aWeightX,
		double aWeightY,
		Insets anInsets) {

		GridBagConstraints theConstraint = new GridBagConstraints();

		theConstraint.gridx = aGridX;
		theConstraint.gridy = aGridY;
		theConstraint.gridwidth = aGridWidth;
		theConstraint.gridheight = aGridHeigth;
		theConstraint.fill = aFillConstraint;
		theConstraint.anchor = anAnchorConstraint;
		theConstraint.weightx = aWeightX;
		theConstraint.weighty = aWeightY;
		theConstraint.insets = anInsets;

		this.add(aComponent, theConstraint);

Was spricht dagegen ein Interface KeyListner und ActionListener zu implementieren? Würde das ganze übersichtlicher machen. Bei ActionListnern kann man duch setzen einen actionCommand 20 faches implementieren eines actionlisteners auf eine implementation reduzieren.

Wie ich sehe macht dein Keylistener nix anderes als den Focus auf die nächste Komponente bei Enter setzen. Wenn man Enter in einer Komponente drückt wird der ActionListener aufgerufen. Der könnte den Focus auf die nächste Komponenete setzen.

Ich sag mal nix zu der Datenbankabfrage im ActionListener. Bei einer OO Sprache sollte man auch Objekte nutzen. [Update] Ok ist nicht im ActionListener aber blöder Name für eine Methode die durch den ActionListner aufgerufen wird. Warum hat die Methode ein ActionEvent?

Mal ein Bsp zur Datenbank:

Man macht sich ein Pakage database:
Dort findet man so Sachen wie initialisierung der Datenbank. Methode und Classen für den Zugriff auf die DB z.B getLogin(String User) ...

Jede Methode sollte Kommentiert werden. In 4 Wochen weißst nicht mehr was die Methoden machen.

 

[UnkiDunki]

Vielen Dank, Zed!!!
Das sind schon mal sehr gute Anregungen und Verbesserungsvorschläge, die du mir da gegeben hast.
Werde das alles mal umsetzen!
Genauso hatte ich mir ein Feedback vorgestellt

Ich sag mal nix zu der Datenbankabfrage im ActionListener. Bei einer OO Sprache sollte man auch Objekte nutzen. [Update] Ok ist nicht im ActionListener aber blöder Name für eine Methode die durch den ActionListner aufgerufen wird. Warum hat die Methode ein ActionEvent?

Ok... die Datenbankabfrage habe ich ausgelagert. In meine "Methoden-Klasse". So muss man nur noch einen Boolean auswerten...
Der ActionEvent ist natürlich sinnlos da. Hatte von anderer Stelle meines Programms den Code mal kopiert und da ist dieses Dingen übrig geblieben Ist aber nicht bei allen so

Mit dem Kommentieren hast du natürlich auch recht! Habe ich auch so gerlernt

Was spricht dagegen ein Interface KeyListner und ActionListener zu implementieren? Würde das ganze übersichtlicher machen. Bei ActionListnern kann man duch setzen einen actionCommand 20 faches implementieren eines actionlisteners auf eine implementation reduzieren.

Hier weiss ich im Moment noch nicht genau wie ich das spontan umsetzen soll, aber das finde ich raus

Noch mal vielen Dank für das super Feedback!

 

[Zed]

Ich schreibe gerade eine kleine Anwendung für mich

Hier mal ein Ausschnitt wie ich die Menübar darstelle und an die Anwendung anbinde.

/**
 * Diese Klasse representiert die Menübar
 */
public class MainMenuBarPanel extends JMenuBar implements MouseListener {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	/**
	 * Definiert die Menus 
	 */
	private enum EMENU{
		DATEI("datei",KeyEvent.VK_D,new EMENUITEM[] {EMENUITEM.EXIT}),
		MUSIC("musik",KeyEvent.VK_M,new EMENUITEM[] {EMENUITEM.READMP3FOLDER}),
		INFO("info",KeyEvent.VK_I,new EMENUITEM[] {EMENUITEM.ABOUT});

		private String name;
		private JMenu menu;
		private Integer keyEvent;
		private List<EMENUITEM> menuitems; 
		/**
		 * Konstruktor
		 * @param aName Name der Komponente
		 * @param aKeyEvent anbindung an einen Shortcut
		 * @param aMenuitems Unteritems des Menüs
		 */
		private EMENU(String aName,Integer aKeyEvent,EMENUITEM[] aMenuitems) {
			name = aName;
			keyEvent = aKeyEvent;
			menu = new JMenu(getLocalizedName());
			if(keyEvent != null) {
				menu.setMnemonic(keyEvent);
			}
			menuitems = new ArrayList<EMENUITEM>(Arrays.asList(aMenuitems));
		}
		public String getLocalizedName() {
			return MDBLanguage.getInstance().get(internationalPrefix() + name);
		}
		private String internationalPrefix() {
			return "mdb.general.menu.";
		}
		public List<EMENUITEM> getMenuItems(){
			return menuitems;
		}
		public JMenu getMenu() {
			return menu;
		}
	}
	/**
	 * Hier werden die MenuItems definiert. 
	 * Diese Menuitems werden zu einem Menu hinzuegefügt
	 */
	public enum EMENUITEM{
		EXIT("exit",KeyEvent.VK_Q),
		ABOUT("about",null),
		READMP3FOLDER("readmp3Folder",null);
		
		private JMenuItem menuitem;
		private String name;
		private Integer keyEvent;
		
		/**
		 * 
		 * @param aName Name der Komponenete
		 * @param aKeyEvent anbindung an einen Shoutcut
		 */
		private EMENUITEM(String aName,Integer aKeyEvent) {
			name = aName;
			keyEvent = aKeyEvent;
			menuitem = new JMenuItem(getLocalizedName());
			if(keyEvent != null) {
				menuitem.setAccelerator(KeyStroke.getKeyStroke(aKeyEvent,ActionEvent.CTRL_MASK));
			}
		}
		private String internationalPrefix() {
			return "mdb.general.menu.item.";
		}
		public String getLocalizedName() {
			return MDBLanguage.getInstance().get(internationalPrefix() + name);
		}
		public JMenuItem getMenuItem() {
			return menuitem;
		}
		public String getName() {
			return name;
		}
		public String getActionCommand() {
			return MENUPREFIX + name;
		}
		public String getDescription() {
			return MDBLanguage.getInstance().get(internationalPrefix() + "beschreibung." + name);
		}
	}
	/**
	 * Main Classe
	 */
	private MainAM am;
	/**
	 * StatusBar
	 */
	private MainStatusBar statusbar;
	/**
	 * Prefix für den ActionCommand
	 */
	public final static String MENUPREFIX = "menu_";
	/**
	 * Konstruktor
	 * @param statusbar 
	 */
	public MainMenuBarPanel(MainAM aAm, MainStatusBar aStatusbar) {
		super();
		am = aAm;
		statusbar = aStatusbar;
		init();
	}
	/**
	 * Initialisiert das JMenu
	 */
	private void init() {
		initMenu();
	}
	/**
	 * Initialisiert die Menus und SubMenus
	 */
	private void initMenu() {
		for(EMENU eachMenu: EMENU.values()) {
			JMenu theMenu = eachMenu.getMenu();
			for(EMENUITEM eachMenuItem : eachMenu.getMenuItems()) {
				JMenuItem theMenuItem = eachMenuItem.getMenuItem();
				theMenuItem.addActionListener(am);
				theMenuItem.setActionCommand(eachMenuItem.getActionCommand());
				theMenuItem.addMouseListener(this);
				theMenu.add(theMenuItem);
			}
			this.add(theMenu);
		}
	}
	
	/*
	 * MouseListener für die Statusbar 
	 */
	@Override
	public void mouseClicked(MouseEvent e) {
		statusbar.setText("");
	}
	@Override
	public void mouseEntered(MouseEvent e) {
		JMenuItem theMenuItem = (JMenuItem)e.getComponent();
		for(EMENUITEM eachItem : EMENUITEM.values()) {
			if(eachItem.getMenuItem().equals(theMenuItem)) {
				statusbar.setText(eachItem.getDescription());
				break;
			}
		}
	}
	@Override
	public void mouseExited(MouseEvent e) {
		statusbar.setText("");
	}
	@Override
	public void mousePressed(MouseEvent e) {
		statusbar.setText("");
	}
	@Override
	public void mouseReleased(MouseEvent e) {
		statusbar.setText("");
	}
}

Ich hab das so Aufgeteilt das wenn ich mal ein neuen Menüeintrag brauch ich einfach nur die Enumeration anpassen muss und schon hab ich einen neuen Eintrag

Jetzt kommt ein Ausschnitt aus der Hauptklasse des Programms

public class MainAM extends JFrame implements ActionListener
.
.
.
	public void actionPerformed(ActionEvent e) {
		if(e.getActionCommand().startsWith(MainMenuBarPanel.MENUPREFIX)) {
			menuBarActionPreformed(e);
		}
		
	}

private void menuBarActionPreformed(ActionEvent e) {
		if(e.getActionCommand().equals(EMENUITEM.EXIT.getActionCommand())) {
			this.dispose();
			System.exit(0);
		}
}

 

[Ebenius]

Nur mal eine Frage am Rande an Zed: Wieso schreibst Du Enums (EMENUITEM) groß? Das sind doch Typen die man CamelCase schreibt... Oder verstehe ich da was nich?

Ebenius

 

[Zed]

Hab gegoogelt und du hast recht immer CamelCase

 

[UnkiDunki]

Hi Zed (alle anderen dürfen sich natürlich auch angesprochen fühlen ),
habe jetzt mehr oder weniger alles so umgesetzt, wie du es in deinem ersten Post geraten hast.
Das Ergebnis sieht jetzt so aus:

package gui;
...
import methods.DatabaseMethods;
import methods.LanguageMethods;
import methods.UsersMethods;
import methods.WindowMethods;

public class JFLogin extends JFrame implements ActionListener {

	private static final long serialVersionUID = 1L;
	final JTextField textUsername = new JTextField("", 15);
	final JPasswordField textPassword = new JPasswordField(15);

	public JFLogin(){
		
		super(LanguageMethods.textBundle.getString("WINDOW_NAME.login")+" "+LanguageMethods.textBundle.getString("LABEL.software_name"));
		
		// set frame and its layout
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
		this.addWindowListener(new WindowAdapter() {
			public void windowClosing(final WindowEvent e) {
				closeFrame();	
			}
		});
		this.setSize((int)(this.getToolkit().getScreenSize().width * 0.3),(int)(this.getToolkit().getScreenSize().height * 0.3));
		this.setLocation(this.getToolkit().getScreenSize().width / 2 - this.getWidth() / 2, this.getToolkit().getScreenSize().height/ 2 - this.getHeight() / 2);
		this.getContentPane().setLayout(new GridBagLayout());
		
		// add labels & textfields and set actions
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),new JLabel(LanguageMethods.textBundle.getString("LABEL.username")+"*: "), 0, 0, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),new JLabel(LanguageMethods.textBundle.getString("LABEL.password")+": "), 0, 1, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		
		textUsername.setActionCommand("username");
		textUsername.addActionListener(this);
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),textUsername, 1, 0, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		
		textPassword.setEchoChar('#');
		textPassword.setActionCommand("ok");
		textPassword.addActionListener(this);
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),textPassword, 1, 1, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		
		// add buttons and set actions
		JButton buttonOK = new JButton(LanguageMethods.textBundle.getString("BUTTON.enter"));
		buttonOK.setActionCommand("ok");
		buttonOK.addActionListener(this);
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),buttonOK, 0, 2, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		
		JButton buttonCancel = new JButton(LanguageMethods.textBundle.getString("BUTTON.cancel"));
		buttonCancel.setActionCommand("cancel");
		buttonCancel.addActionListener(this);
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),buttonCancel, 1, 2, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		
		JButton buttonSettings = new JButton(LanguageMethods.textBundle.getString("BUTTON.settings"));
		buttonSettings.setActionCommand("settings");
		buttonSettings.addActionListener(this);
		WindowMethods.addComponentInContainer((JComponent) this.getContentPane(),buttonSettings, 2, 2, 1, 1, 0, GridBagConstraints.CENTER, 0.0, 0.0, new Insets(0,0,0,0));
		
		textUsername.requestFocus();
		this.pack();
		}

	@Override
	public void actionPerformed(ActionEvent e) {
		// buttonOK & textPassword -> login -> open main-frame
		if(e.getActionCommand().equals("ok")) if(UsersMethods.login(textUsername, textPassword)) dispose();
		// textUsername
		if(e.getActionCommand().equals("username")) textPassword.requestFocus();
		// buttonCancel
		if(e.getActionCommand().equals("cancel")) closeFrame();
		// buttonSettings
		if(e.getActionCommand().equals("settings")) WindowMethods.openFrame(this, new JFSettings(this));
	}	
	
	/**
	 * close connections to databases and dispose frame
	 */
	private void closeFrame(){
		try {
			DatabaseMethods.closeConnections();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		dispose();
	}
}

Keine anonyme ActionListener-Initialisierung mehr, die meisten Methoden ausgelagert in - für mich sinnvolle - Klassenstruktur (siehe Imports), deine (also Zeds) Layoutmethode übernommen und verwendet und ja...
Wenn man die Klassen (vorher und nachher) miteinander vergleicht, dann ist auf jeden Fall schon mal eine große Verbesserung zu sehen. Ob das jetzt so schon ganz annehmbar ist?

Vielen Dank schon mal für eure Tipps und weitere Anregungen, um mir wenigstens ein bisserl Stil beizubringen