Organisation von Quellcode

[padde479]

Hallo zusammen!

Ich bin gerade dabei, eine Anwendung zu schreiben. Da dies meine erste größere Java-Applikation ist, habe ich eine Frage zur Organisation der Quellcode-Dateien. Bisher habe ich eine Fenster mit einer Menüzeile und zwei kleinen Menüs. Ich habe auch schon ein paar Menüeinträge erzeugt und diese mit kleinen Funktionen belegt. Aber ist es nicht sinnvoller, gewisse Funktionen auszulagern? Bisher geschieht alles in einer Klasse Main. Wie ist es denn sinnvoll, das Projekt in einzelne Klassen zu organisieren? Könnt ihr mir da Tipps geben?

Hier erst einmal der bisherige Quellcode.

/**
 * Main.java
 */
package jile.gui;

import java.awt.Dimension;
import java.awt.Event;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.print.PrinterJob;

import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.KeyStroke;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

/**
 * Die Hauptklasse der Anwendung.
 * 
 * @author PHA
 * @version 0.0.1
 */
public class Main extends JFrame {
	public static final long serialVersionUID = System.currentTimeMillis();
	
	private JFrame    frame;
	private JMenuBar  menubar = new JMenuBar();
	private JMenuItem item;
	
	
	
	public Main() {
		frame = new JFrame("Jile");
		
		menubar.add(createFileMenu());
		menubar.add(createHelpMenu());
		frame.setJMenuBar(menubar);
		
		// Schließmechanismus einbauen
		frame.addWindowListener(new WindowClosingAdapter(true));		
		// Dimension des Fensters festlegen
		Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
		int width = screen.width; int height = screen.height;
		frame.setSize(width, height);
		frame.setVisible(true);
	}
	
	private JMenu createFileMenu() {
		JMenu file = new JMenu("File");
		file.setMnemonic('F');
		item = new JMenuItem("New", 'N');
		setCTRLAccelerator(item, 'N');
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				new AboutDialog();
			}
		});
		file.add(item);
		file.addSeparator();
		item = new JMenuItem("Open", 'O');
		setCTRLAccelerator(item, 'O');
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				JFileChooser chooser = new JFileChooser();
				chooser.showOpenDialog(frame);
			}
		});
		file.add(item);
		file.addSeparator();
		item = new JMenuItem("Print", 'P');
		setCTRLAccelerator(item, 'P');
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				PrinterJob job    = PrinterJob.getPrinterJob();
				if (job.printDialog()) {
					try {
						job.print();
					} catch (Exception ex) {
						ex.printStackTrace();
					}
				}
			}
		});
		file.add(item);
		file.addSeparator();
		item = new JMenuItem("Quit", 'Q');
		setCTRLAccelerator(item, 'Q');
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				System.exit(0);
			}
		});
		file.add(item);
		return file;
	}
	
	private JMenu createHelpMenu() {
		JMenu help = new JMenu("Help");
		help.setMnemonic('H');
		item = new JMenuItem("About Jile", 'A');
		setCTRLAccelerator(item, 'A');
		item.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				String msg = "Jile\n";
				ImageIcon imageIcon = new ImageIcon("U:\\swmslogo.bmp");
				JOptionPane.showMessageDialog(frame, msg, "About Jile", JOptionPane.INFORMATION_MESSAGE, imageIcon);
			}
		});
		help.add(item);
		return help;
	}
	
	private void setCTRLAccelerator(JMenuItem item, char accelerator) {
		KeyStroke keyStroke = KeyStroke.getKeyStroke(accelerator, Event.CTRL_MASK);
		item.setAccelerator(keyStroke);
	}
	
	/**
	 * Die <code>main</code>-Methode zum Starten der Anwendung.
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Main();
	}

}

Hier registrie ich ja für jeden Menüeintrag einen eigenen ActionListener. Und kann ich die Menüs nicht besser in eigene Klassen auslagern, damit alles übersichtlicher wird und Änderungen leichter zu tätigen sind?

Gruß
Padde

PS: Wieso bekomme ich im JOption-Dialog eigentlich kein Bild angezeigt, obwohl es an genau dieser Position im Dateisystem zu finden ist?

 

[Campino]

In mehrere Klassen zu zerlegen ist in jedem Fall sinnvoll. Für jedes JMenuItem eine eigene Klasse zu schreiben ist ein bisschen mit wie Kanonen auf Spatzen schießen, aber zerlegen ist schon sinnvoll. Dabei würde ich z.B. in den ActionListenern, die du an die JMenuItems hängst jeweils nur eine Methode aufrufen und in der dann alles andere machen. Eventuell kannst du diese Methoden alle in eine andere Klasse auslagern.

 

[padde479]

Und wie stell' ich das am besten an? Kannst Du mir vielleicht ein Beispielprojekt geben, an dem man eine solche Vorgehensweise sehen kann? Ich habe echt keine Idee, wie dass von statten gehen soll. In Tutorials etc. sieht man ja immer nur, wie man eine bestimmte Komponente verwendet, wie man aber mehrere Komponenten sinnvoll über mehrere Klassen miteinander verbindet, sucht man vergebens.

Gruß
Padde

 

[Wildcard]

Sieh dir doch einfach das repository eines beliebigen Elcipse oder Sourceforge Projekts an...

 

[SlaterB]

da gibts auch kein Standard-Vorgehen,

in deinem Fall könntest du eine Klasse FileMenu erstellen und den Inhalt von
private JMenu createFileMenu() {
}
komplett in den Konstruktor der neuen Klasse verschieben,
schon hast du ein Dritter der Klasse ausgelagert

falls das FileMenü irgendwie mit dem HauptFrame zusammenarbeiten soll (z.B. in irgendeinem TextFeld was setzen),
dann muss das HauptFrame in Konstruktor als Paramter übergeben und im FileMenü as Exemplarvariable gespeichert werden

Falls deine ActionListener irgendwann mal größer werden, bietet es sich an eine Logikklasse zu haben.
Das FileMenü bekommt dann ein Objekt der Logikklasse als Exemplarvariable, und die ActionListener ein übersichtliches Aussehen,
z.B.

item = new JMenuItem("Print", 'P'); 
      setCTRLAccelerator(item, 'P'); 
      item.addActionListener(new ActionListener() { 
         public void actionPerformed(ActionEvent event) { 
            logik.print();
         } 
      });

 

[Campino]

SlaterB: Eine FileMenu-Klasse halte ich für nicht optimal, da sie nicht wiederverwertbar ist und nur einmal gebraucht wird, aber eine einzig richtige Lösung gibt es nicht. Ich würde das so machen:

public class Fenster extends JFrame{
private Controller control;
private JButton knopf=new JButton("Klick mich");

public Fenster(Controller control){
this.control=control;

initGUI();
}

public void initGUI(){
//Fenstergröße usw. 
this.getContentPane().add(knopf);
knopf.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
control.drueckMich();
}
});
}
}

public class Controller{
private Fenster fenster;

public static void main(String args[]){
new Controller();
}

public Controller(){
fenster=new Fenster(this);
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Hier falls das mal an ein anderes Fenster soll, deshalb nicht in der Fensterklasse
fenster.setVisible(true);
}

publi void drueckMich(){
//Button-Kram, Zugriffe auf andere Componenten über getter/setter des Fenster-Objekts
}
}

(keine garantie für Funktionsfähigkeit/Compilierbarkeit, nur eben so runtergeschrieben)

 

[Gast]

Wie wäre es ein MVC-Pattern zu benutzen?
Damit kann schon mal vorsortiert werden in Modell, View und Controller. Dafür gibts schon mal ein paar tutorials.
Wenn es dann übersichtlicher geworden ist, wirds vielleicht auch einfacher mit der weiteren Umstrukturierung.