Googlehupf
Erfahrenes Mitglied
Hallo zusammen,
ich hab hier ein Programm das aus einem Hauptfenster und einem Dialog entsteht, der Dialog wird mittels einem Menu geöffnet. Beim Schließen des Dialogs, werden die Daten(höhe, breite, titel und farbe), die man im Dialog einstellt ins Hauptfenster übertragen, d.h. das Haupfenster nimmt jene Daten an die man im Dialog einstellt. Wenn man das Hauptfenster schließt werden die Daten in ein binär-file gespeichert, beim ausführen das Programms werden diese Daten vom binär-file geladen und das Fenster sieht noch immer so aus wie vorher.
Der Code:
Die Hauptklasse, also da wo das Hauptfenster gestaltet wird.(es gibt zwar noch noch ne Klasse, da steht das void main drinnen etc., aber diese ist unwichtig)
Die Klasse, die serializable implementiert bzw. von denen die Daten gesichert werden.
Klasse zum Farbe auswählen:
Abstrakte Klasse:
Exceptions:
Also es gibt ja da so nen try catch-block. Im try-Block wird irgendein Programmcode geschrieben, da kann ein Fehler auftreten, meinstens wenn ein Fehler auftritt, dann wird ja das Programm gestoppt, aber dieser catch fängt den Fehler ab und löst ihn? Richtig?
Und dann gehts ganz normal weiter.
Die Frage ist nun wo brauche ich den überall einen try-catch-block. Ich sehe jetzt nur da try-catch-blöcke, da wo eine aufgerufen wird in dem try-block, also FrameInit, oder DigInit. Hat das nen Grund? Oder wie weiß ich wann ich so was machen muss?
Welche Fehler werden denn da bei mir behandelt in den Klasse MainFrame, myDialog?
z.b. bei: FileNotFoundException, wenn im try-block versucht wird ein File zu öffnen, aber es nicht existiert, dann wird halt das so gelöst wie es bei mir da steht, right?
Was bedeutet aber nur "Exception", also beim catch? Wie gesagt welche Fehler können da auftreten? Für mich sieht das nicht nach einer Lösung aus, was da im catch-Block steht(Klasse MainFrame und myDialog). In den jeweiligen try-Blöchen werden ja die Methoden FrameInit bzw. DigInit oder so aufgerufen, warum steht bei den Methoden "throws Exception" da? Was macht das?
Abstrakte Klasse:
Also könnt ihr mir bitte den Teil in meinen Programm erklären was diese abstrakte Klasse da macht und für was die in meinem Fall jetzt gut ist. Also ich verstehe auch nicht warum wir die alte Frabe im DigInit holen und dann ins ColorSet übegeben, hat wahrscheinlich auch was mit den abstrakten Klassen zu tun.
Danke!
PS: Ich hab mir zwar über exceptions und abstract classes bei galileo computing was durchgelesen, aber leider hat es nichts wirklich geholfen.
mfg
ich hab hier ein Programm das aus einem Hauptfenster und einem Dialog entsteht, der Dialog wird mittels einem Menu geöffnet. Beim Schließen des Dialogs, werden die Daten(höhe, breite, titel und farbe), die man im Dialog einstellt ins Hauptfenster übertragen, d.h. das Haupfenster nimmt jene Daten an die man im Dialog einstellt. Wenn man das Hauptfenster schließt werden die Daten in ein binär-file gespeichert, beim ausführen das Programms werden diese Daten vom binär-file geladen und das Fenster sieht noch immer so aus wie vorher.
Der Code:
Die Hauptklasse, also da wo das Hauptfenster gestaltet wird.(es gibt zwar noch noch ne Klasse, da steht das void main drinnen etc., aber diese ist unwichtig)
Java:
public class MainFrame extends JFrame {
private JPanel p_center;
private JPanel contentPane;
private MyConfigData cfg;
private static final String CFG_FILE = "mytest.cfg";
private JMenuItem mi11;
/**
*
*/
public MainFrame() {
try {
// Speicher der Konfigurationsdaten beim Schliessen
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
save_Config(cfg);
System.exit(0);
}
});
cfg = load_Config();
if (cfg != null) {
FrameInit();
} else {
System.out.println("Error fetching Config Data");
System.exit(1);
}
} catch (Exception exception) {
exception.printStackTrace();
}
}
private void FrameInit() throws Exception {
contentPane = (JPanel) getContentPane();
contentPane.setLayout(new BorderLayout());
p_center = new JPanel();
p_center.setBackground(cfg.get_bg());
contentPane.add(p_center);
setSize(new Dimension(cfg.get_width(), cfg.get_height()));
setTitle(cfg.get_title());
// Menü
JMenuBar mb = new JMenuBar();
JMenu m1 = new JMenu("Setup");
mi11 = new JMenuItem("set Configuration");
mi11.addActionListener(new Menu_ActionListener());
m1.add(mi11);
mb.add(m1);
this.setJMenuBar(mb);
}
// Laden der Konfigurationsdaten
private MyConfigData load_Config() {
return load_Config_File();
// return load_Config_Reg();
}
// Speichern der Konfigurationsdaten
private void save_Config(MyConfigData mcd) {
save_Config_File(mcd);
// save_Config_Reg(mcd);
}
// Speichern der Konfigurationsdaten in Konfigdatei
private void save_Config_File(MyConfigData mcd) {
// // Speichern in Config-Datei
try {
FileOutputStream fs = new FileOutputStream(CFG_FILE);
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(mcd);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("CFG gespeichert \n");
}
// Laden der Konfigurationsdaten aus Konfigdatei
private MyConfigData load_Config_File() {
MyConfigData mcd = null;
// // Laden aus Konfigurationsdatei
try {
FileInputStream fs = new FileInputStream(CFG_FILE);
ObjectInputStream is = new ObjectInputStream(fs);
mcd = (MyConfigData) is.readObject();
is.close();
System.out.println("CFG von Datei geladen \n");
} catch (FileNotFoundException e) {
// Erstinitialisierung, wenn keine Config-Datei
mcd = new MyConfigData(800, 600, Color.RED, "Titel");
System.out.println("CFG neu erzeugt \n");
} catch (Exception e) {
e.printStackTrace();
}
return mcd;
}
private void menu_Handler(ActionEvent e) {
new MyConfigDialog(this, cfg);
p_center.setBackground(cfg.get_bg());
setSize(new Dimension(cfg.get_width(), cfg.get_height()));
setTitle(cfg.get_title());
validate();
}
private class Menu_ActionListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
menu_Handler(e);
}
}
}
Die Klasse, die serializable implementiert bzw. von denen die Daten gesichert werden.
Java:
import java.io.Serializable;
import java.awt.*;
public class MyConfigData implements Serializable {
private int width;
private int height;
private Color bg;
private String title;
/**
*
* @param width - Fensterbreite
* @param height - Fensterhöhe
* @param bg - Hintergrundfarbe
* @param title - Fenstertitel
*/
public MyConfigData(int width, int height,
Color bg, String title) {
this.width = width;
this.height = height;
this.bg = bg;
this.title = title;
}
/**
* Lesen der Fensterbreite
* @return
*/
public int get_width () {
return width;
}
/**
* Lesen der Fensterhöhe
* @return
*/
public int get_height () {
return height;
}
/**
* Lesen der Hintergrundfarbe
* @return
*/
public Color get_bg () {
return bg;
}
/**
* Lesen des Fenstertitels
* @return
*/
public String get_title () {
return title;
}
/**
* Setzen der Fensterbreite
* @param val
*/
public void set_width (int val) {
width = val;
}
/**
* Setzen der Fensterhöhe
* @param val
*/
public void set_height (int val) {
height = val;
}
/**
* Setzen der Hintergrundfarbe
* @param val
*/
public void set_bg (Color val) {
bg = val;
}
/**
* Setzen des Fenstertitels
* @param val
*/
public void set_title (String val) {
title = val;
}
}
Klasse zum Farbe auswählen:
Java:
import java.awt.*;
import javax.swing.*;
public class ColorSet extends ColorSetter {
private Color col;
private JRadioButton rb_r;
private JRadioButton rb_g;
private JRadioButton rb_b;
/**
*
* @param col - aktuelle Farbe
*/
public ColorSet (Color col) {
this.col = col;
setLayout (new GridLayout(3,1));
rb_r = new JRadioButton("RED");
rb_g = new JRadioButton("GREEN");
rb_b = new JRadioButton("BLUE");
this.add(rb_r);
this.add(rb_g);
this.add(rb_b);
ButtonGroup bg = new ButtonGroup();
bg.add(rb_r);
bg.add(rb_g);
bg.add(rb_b);
}
/**
* Abfrage der ausgewählten Farbe
*/
public Color get_Color() {
if (rb_r.isSelected()) {
col=Color.red;
}
else if (rb_g.isSelected()) {
col=Color.green;
}
else {
col=Color.blue;
}
return col;
}
}
Abstrakte Klasse:
Java:
import java.awt.*;
import javax.swing.*;
public abstract class ColorSetter extends JPanel{
abstract public Color get_Color();
}
Exceptions:
Also es gibt ja da so nen try catch-block. Im try-Block wird irgendein Programmcode geschrieben, da kann ein Fehler auftreten, meinstens wenn ein Fehler auftritt, dann wird ja das Programm gestoppt, aber dieser catch fängt den Fehler ab und löst ihn? Richtig?
Und dann gehts ganz normal weiter.
Die Frage ist nun wo brauche ich den überall einen try-catch-block. Ich sehe jetzt nur da try-catch-blöcke, da wo eine aufgerufen wird in dem try-block, also FrameInit, oder DigInit. Hat das nen Grund? Oder wie weiß ich wann ich so was machen muss?
Welche Fehler werden denn da bei mir behandelt in den Klasse MainFrame, myDialog?
z.b. bei: FileNotFoundException, wenn im try-block versucht wird ein File zu öffnen, aber es nicht existiert, dann wird halt das so gelöst wie es bei mir da steht, right?
Was bedeutet aber nur "Exception", also beim catch? Wie gesagt welche Fehler können da auftreten? Für mich sieht das nicht nach einer Lösung aus, was da im catch-Block steht(Klasse MainFrame und myDialog). In den jeweiligen try-Blöchen werden ja die Methoden FrameInit bzw. DigInit oder so aufgerufen, warum steht bei den Methoden "throws Exception" da? Was macht das?
Abstrakte Klasse:
Also könnt ihr mir bitte den Teil in meinen Programm erklären was diese abstrakte Klasse da macht und für was die in meinem Fall jetzt gut ist. Also ich verstehe auch nicht warum wir die alte Frabe im DigInit holen und dann ins ColorSet übegeben, hat wahrscheinlich auch was mit den abstrakten Klassen zu tun.
Danke!
PS: Ich hab mir zwar über exceptions und abstract classes bei galileo computing was durchgelesen, aber leider hat es nichts wirklich geholfen.
mfg
Zuletzt bearbeitet: