Java Objekte Speichern

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Java Objekte Speichern

    Hallo,

    Ich habe momentan Ferien und deswegen viel Zeit also habe ich mir gestern ein kleines Vokabelprogramm zusammengebastelt....

    Bisher funktioniert auch alles so wie ich es mir vorgestellt habe.

    Doch jetzt wollte ich eine Option einbauen womit man die möglichkeit hat bereits vorhande Vokabeln einzuspeichern. Mein Programm funktioniert momentan so :

    Ich habe 4 Klassen :

    -Die Main Klasse

    -Eine Klasse wo die Gui iniatialisiert/Definiert wird und die ganzen Aktionen für die Gui rein gepackt sind (Eintragen & Abfragen der Vokabeln)

    -Eine "Vokabel_Eintrag" Klasse wo die ganzen Daten eingetragen werden und Abgefragt werden können.

    -Und ein Hilfe Fenster..Da habe ich aber noch nichts gemacht.

    Momentan funktioniert das Eintragen so :

    bildupload.sro.at/p/398034.html

    (Bild ist auch im Anhang,Mit List meine ich ArrayList)

    Hier nochmal ein UML Diagramm:

    [IMG:http://www10.pic-upload.de/thumb/29.07.12/uhtosgt6ck8l.png]


    Also stellt sich die Frage wie bekomme ich es hin einen Array dauerhaft zu Speichern ?

    Ich würde jetzt einfach sagen das ein Filewriter den ganzen Inhalt eines Arrays in ein Textfile schreibt und das dann später wieder herausgelesen wird..Aber das erscheint mir irgendwie..komisch.

    was mache ich wenn ich mehrere Lektionen habe ? Wie kriege ich das hin , das der User da wählen kann ? oder Anderes gibt es eine Möglichkeit Objekte zu speichern.

    btw. In meinem Code überschreibt er immer das vorhande Objekt was die Vokabeln speichert.Weil ich nicht weiß wie ich das hinbekomme das er immer wieder ein neues individuelles Objekt erzeugt was im ganzen code verwendet werden kann

    (Ich arbeite in meinem Code mit Globalen Variablen , in diesem Fall ein Globales "Vokabeleintrag Objekt"

    Ich erwarte nicht das sich jemand den ganzen Code daunten durchließt aber es wäre echt Toll wenn mir jemand verbesserungschläge geben könnte ( Wie kann ich das mit dem Speichern lösen ? , Wie bekomme ich das hin das beim jeden "Eintragen" ein neues Individueles Objekt erstellt was man dann in der ganzen Klasse verwenden kann ?

    Fragen die ich mir auch noch stelle sind..:Ist mein Code überhaupt Objektorientert ?

    Allgemeine Verbesserungsvorschläge sind natürlich auch erwünscht, z.b Der Still oder der Gesamte Lösungsweg.

    Der Code :

    Main Klasse :

    Quellcode

    1. public class Vokabelprogramm_Main {
    2. /**
    3. * @param args
    4. */
    5. public static void main(String[] args) {
    6. Vokabelprogramm Programm = new Vokabelprogramm();
    7. Programm.IniatizeComponents();
    8. Programm.Starten();
    9. }
    10. }
    Alles anzeigen


    Vokabelprogramm Klasse:

    Quellcode

    1. import java.awt.Font;
    2. import java.awt.GridLayout;
    3. import java.awt.List;
    4. import java.awt.event.ActionEvent;
    5. import java.awt.event.ActionListener;
    6. import java.io.FileInputStream;
    7. import java.io.FileOutputStream;
    8. import java.io.ObjectInputStream;
    9. import java.io.ObjectOutput;
    10. import java.io.ObjectOutputStream;
    11. import java.util.ArrayList;
    12. import javax.swing.JButton;
    13. import javax.swing.JFrame;
    14. import javax.swing.JLabel;
    15. import javax.swing.JMenu;
    16. import javax.swing.JMenuBar;
    17. import javax.swing.JMenuItem;
    18. import javax.swing.JOptionPane;
    19. import javax.swing.JPanel;
    20. public class Vokabelprogramm extends JFrame {
    21. JPanel InfoPanel;
    22. JPanel ButtonsPanel;
    23. JPanel AnzahlPanel;
    24. JPanel KontrollePanel;
    25. JPanel ProzentausgabePanel;
    26. JLabel AnzahlLabel;
    27. JLabel ÜberschriftLabel;
    28. JLabel LetztevokabelLabel;
    29. JLabel Prozentlabel;
    30. JMenuBar Menu;
    31. JMenu Datei;
    32. JMenuItem Neu;
    33. JMenuItem Speichern;
    34. JMenuItem Laden;
    35. JMenu Hilfe;
    36. JMenuItem HilfeItem;
    37. JButton MündlichAbfragenButton;
    38. JButton SchriftlichAbfragenButton;
    39. String LetzteDeutscheVokabel;
    40. String LetzteFremdspracheVokabel;
    41. String Deutsch;
    42. String Fremd;
    43. int vokabelzahl;
    44. float Richtige_Vokabeln;
    45. float Falsche_Vokabeln;
    46. float floatProzent;
    47. private float floatvokabel;
    48. Boolean abfragend;
    49. String[] Deutscherarray;
    50. String[] Fremderarray;
    51. Vokabel_Eintrag Aktuelle;
    52. public void IniatizeComponents(){
    53. Menu = new JMenuBar();
    54. Datei = new JMenu("Datei");
    55. Speichern = new JMenuItem("Speichern");
    56. Laden=new JMenuItem("Laden");
    57. Hilfe = new JMenu("Hilfe");
    58. HilfeItem=new JMenuItem("Hilfe");
    59. Neu = new JMenuItem("Neu");
    60. Menu.add(Datei);
    61. Menu.add(Hilfe);
    62. Datei.add(Neu);
    63. Datei.add(Speichern);
    64. Datei.add(Laden);
    65. Hilfe.add(HilfeItem);
    66. LetzteDeutscheVokabel="Deutsch";
    67. LetzteFremdspracheVokabel="Fremdsprache";
    68. this.setBounds(300, 200, 700, 400);
    69. this.setLayout(null);
    70. ÜberschriftLabel=new JLabel("Voci Boci");
    71. AnzahlLabel=new JLabel("Gespeicherte Vokabeln : " + vokabelzahl);
    72. Prozentlabel=new JLabel("Prozentausgabe: 100 %" );
    73. Prozentlabel.setFont(new Font("Monospaced",Font.BOLD,12));
    74. MündlichAbfragenButton=new JButton("Mündlich Abfragen");
    75. SchriftlichAbfragenButton=new JButton("Schriftlich Abfragen");
    76. LetztevokabelLabel =new JLabel("Letzte Vokabel:"+LetzteDeutscheVokabel + "/" + LetzteFremdspracheVokabel);
    77. InfoPanel = new JPanel();
    78. ÜberschriftLabel.setFont(new Font("Monospaced", Font.BOLD, 36));
    79. InfoPanel.add(ÜberschriftLabel);
    80. AnzahlPanel = new JPanel();
    81. AnzahlPanel.add(AnzahlLabel);
    82. ButtonsPanel=new JPanel();
    83. ButtonsPanel.add(MündlichAbfragenButton);
    84. ButtonsPanel.add(SchriftlichAbfragenButton);
    85. KontrollePanel =new JPanel();
    86. KontrollePanel.add(LetztevokabelLabel);
    87. LetztevokabelLabel.setFont(new Font("Monospaced",Font.ITALIC,28));
    88. ProzentausgabePanel = new JPanel();
    89. ProzentausgabePanel.add(Prozentlabel);
    90. this.setJMenuBar( Menu );
    91. this.add(InfoPanel);
    92. InfoPanel.setBounds(0, 0, 700, 50);
    93. this.add(ButtonsPanel);
    94. ButtonsPanel.setBounds(50, 75, 600, 100);
    95. ButtonsPanel.setLayout( new GridLayout(1,1));
    96. this.add(KontrollePanel);
    97. KontrollePanel.setBounds(0, 200, 700, 70);
    98. this.add(AnzahlLabel);
    99. AnzahlLabel.setBounds(500, 275, 200, 50);
    100. this.setVisible(true);
    101. this.add(ProzentausgabePanel);
    102. ProzentausgabePanel.setBounds(0, 283, 200, 50);
    103. }
    104. public void Starten() {
    105. Neu.addActionListener(new ActionListener() {
    106. @Override
    107. public void actionPerformed(ActionEvent e) {
    108. eintragen();
    109. }
    110. });
    111. SchriftlichAbfragenButton.addActionListener(new ActionListener() {
    112. @Override
    113. public void actionPerformed(ActionEvent e) {
    114. SchriftlichAbfragen();
    115. }
    116. });
    117. MündlichAbfragenButton.addActionListener(new ActionListener() {
    118. @Override
    119. public void actionPerformed(ActionEvent e) {
    120. MündlichAbfragen();
    121. }
    122. });
    123. HilfeItem.addActionListener(new ActionListener() {
    124. @Override
    125. public void actionPerformed(ActionEvent e) {
    126. new Hilfe();
    127. }
    128. });
    129. Speichern.addActionListener(new ActionListener() {
    130. @Override
    131. public void actionPerformed(ActionEvent e) {
    132. Speichern();
    133. }
    134. });
    135. Laden.addActionListener(new ActionListener() {
    136. @Override
    137. public void actionPerformed(ActionEvent e) {
    138. laden();
    139. }
    140. });
    141. }
    142. public void eintragen() {
    143. abfragend = true;
    144. ArrayList Deutsche = new ArrayList();
    145. ArrayList Fremde = new ArrayList();
    146. /* //Reseten
    147. if (Aktuelle!=null) {
    148. Aktuelle=null;
    149. vokabelzahl=0;
    150. Deutsche=new ArrayList();
    151. Fremde=new ArrayList();
    152. }
    153. */
    154. while(abfragend) {
    155. Deutsch =JOptionPane.showInputDialog("Deutsche Vokabel ?("+vokabelzahl+")");
    156. if(check(Deutsch) == true) {
    157. //Vorübergehenden Array
    158. Deutscherarray = new String[vokabelzahl];
    159. Fremderarray = new String[vokabelzahl];
    160. //Konvertieren von List zu String
    161. Deutsche.toArray(Deutscherarray);
    162. Fremde.toArray(Fremderarray);
    163. //Label Aktualieren
    164. AnzahlLabel.setText("Gespeicherte Vokabeln : " + vokabelzahl);
    165. //Instanz von Globaler Varibalen erzeugen
    166. Aktuelle = new Vokabel_Eintrag();
    167. //Variablen zu weißen
    168. Aktuelle.SetDeutscheVokabeln(Deutscherarray);
    169. Aktuelle.SetFremdsprachigeVokabeln(Fremderarray);
    170. break;
    171. }
    172. Fremd=JOptionPane.showInputDialog("Fremdsprachige Vokabel ? ("+vokabelzahl+")");
    173. if(check(Fremd) == false) {
    174. //Vorübergehenden Array
    175. Deutscherarray = new String[vokabelzahl];
    176. Fremderarray = new String[vokabelzahl];
    177. //Konvertieren von List zu String
    178. Deutsche.toArray(Deutscherarray);
    179. Fremde.toArray(Fremderarray);
    180. //Instanz von Globaler Varibalen erzeugen
    181. Aktuelle = new Vokabel_Eintrag();
    182. //Variablen zu weißen
    183. Aktuelle.SetDeutscheVokabeln(Deutscherarray);
    184. Aktuelle.SetFremdsprachigeVokabeln(Fremderarray);
    185. }
    186. Deutsche.add(Deutsch);
    187. Fremde.add(Fremd);
    188. LetztevokabelLabel.setText("Letzte Vokabel:"+Deutsch + "/" + Fremd);
    189. vokabelzahl++;
    190. }
    191. }
    192. private boolean check(String ZuÜberprüfenderString) {
    193. boolean fertig = false;
    194. if(ZuÜberprüfenderString==null) {
    195. fertig=true;
    196. }
    197. return fertig;
    198. }
    199. public float GetProzentsatz() {
    200. floatvokabel = vokabelzahl;
    201. float EinProzent=floatvokabel/100;
    202. System.out.println("Ein Prozent :"+EinProzent);
    203. floatProzent=Richtige_Vokabeln/EinProzent;
    204. this.setVisible(true);
    205. return floatProzent;
    206. }
    207. private void SchriftlichAbfragen() {
    208. if (Aktuelle!=null) {
    209. String[] Deutscherarray = Aktuelle.GetDeutscheVokabeln();
    210. String[] Fremderarray = Aktuelle.GetFremdsprachigeVokabeln();
    211. System.out.println(Deutscherarray.length);
    212. Richtige_Vokabeln=0;
    213. for (int i = 0; i < Deutscherarray.length; i++) {
    214. String Eingabe = JOptionPane.showInputDialog(Deutscherarray[i]);
    215. String Antwort=Fremderarray[i];
    216. if(check(Eingabe)==true) {
    217. System.out.print("Check == False ");
    218. Richtige_Vokabeln=0;
    219. break;
    220. }
    221. if(Eingabe.equals(Antwort)) {
    222. Richtige_Vokabeln++;
    223. }
    224. else {
    225. JOptionPane.showMessageDialog(null, "Falsch ! Richtig wäre : " + Fremderarray[i]);
    226. }
    227. }
    228. floatProzent=GetProzentsatz();
    229. floatProzent= Math.round(floatProzent);
    230. System.out.println("FloatProzent: "+floatProzent);
    231. Prozentlabel.setText("Status: " + floatProzent + "%");
    232. }
    233. else {
    234. JOptionPane.showMessageDialog(null, "Keine Vokabeln Vorhanden");
    235. }
    236. }
    237. public void Speichern(){
    238. if (Aktuelle!=null){
    239. try {
    240. String DateiName=JOptionPane.showInputDialog("Name der Lektion ? (Speichername)");
    241. FileOutputStream f = new FileOutputStream(DateiName);
    242. ObjectOutput s = new ObjectOutputStream(f);
    243. s.writeObject(Aktuelle);
    244. s.flush();
    245. } catch (Exception e) {
    246. System.out.println("Klappt nicht");
    247. }
    248. }
    249. else {
    250. JOptionPane.showMessageDialog(null, "Keine Vokabeln Vorhanden");
    251. }
    252. }
    253. public void MündlichAbfragen() {
    254. if (Aktuelle!=null) {
    255. String[] Deutscherarray = Aktuelle.GetDeutscheVokabeln();
    256. String[] Fremderarray = Aktuelle.GetFremdsprachigeVokabeln();
    257. Richtige_Vokabeln=0;
    258. for (int i = 0; i < Deutscherarray.length; i++) {
    259. JOptionPane.showMessageDialog(null,"Was bedeutet " + Deutscherarray[i] + "?");
    260. String Antwort=Fremderarray[i];
    261. int eingabe = JOptionPane.showConfirmDialog(null,"Die Antwort war " + Fremderarray[i] + " , Hast du du es gewusst","Einverständnis",JOptionPane.YES_NO_CANCEL_OPTION);
    262. System.out.println(eingabe);
    263. if( eingabe==0) {
    264. Richtige_Vokabeln++;
    265. }
    266. if (eingabe==1) {
    267. JOptionPane.showMessageDialog(null, "Richtig wäre " + Fremderarray[i] + " Gewesen");
    268. }
    269. if (eingabe==2) {
    270. Richtige_Vokabeln=0;
    271. break;
    272. }
    273. }
    274. floatProzent=GetProzentsatz();
    275. floatProzent= Math.round(floatProzent);
    276. System.out.println("FloatProzent: "+floatProzent);
    277. Prozentlabel.setText("Status: " + floatProzent + "%");
    278. }
    279. else {
    280. JOptionPane.showMessageDialog(null, "Keine Vokabeln Vorhanden");
    281. }
    282. }
    283. public void laden(){
    284. try {
    285. String ladener = JOptionPane.showInputDialog("Welche Lektion soll geladen werden ?");
    286. FileInputStream in = new FileInputStream(ladener);
    287. ObjectInputStream s = new ObjectInputStream(in);
    288. Aktuelle = (Vokabel_Eintrag)s.readObject();
    289. JOptionPane.showMessageDialog(null, ladener +".datei wurde geladen");
    290. } catch (Exception e) {
    291. JOptionPane.showMessageDialog(null,"konnte nicht geladen werden");
    292. }
    293. }
    294. }
    Alles anzeigen


    Die Vokabeleintrag Klasse:

    Quellcode

    1. import java.io.Serializable;
    2. public class Vokabel_Eintrag implements Serializable
    3. {
    4. String[] DeutscheVokabeln;
    5. String[] FremdsprachigeVokabeln;
    6. String Lektionname;
    7. public void SetDeutscheVokabeln(String[] DeutscheVokabeln) {
    8. this.DeutscheVokabeln=DeutscheVokabeln;
    9. }
    10. public String[] GetDeutscheVokabeln() {
    11. return DeutscheVokabeln;
    12. }
    13. public void SetFremdsprachigeVokabeln(String[] FremdsprachigeVokabeln) {
    14. this.FremdsprachigeVokabeln=FremdsprachigeVokabeln;
    15. }
    16. public String[] GetFremdsprachigeVokabeln() {
    17. return FremdsprachigeVokabeln;
    18. }
    19. public void SetLektionname(String Lektionname) {
    20. this.Lektionname=Lektionname;
    21. }
    22. public String GetLektionname() {
    23. return Lektionname;
    24. }
    25. }
    Alles anzeigen


    Mit freundlichen Grüßen

    Philip
    Bilder
    • Vokabellprogramm_UML.png

      38,65 kB, 990×684, 277 mal angesehen

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von philip2007 ()

  • Hallo,

    Vielen Dank für die Antwort !

    Das hilft mir schonmal weiter.

    Hätte jemand vieleicht einen Link Parat wo gut erklärt wird wie Java mit Datenbanken zusammen arbeitet ?

    Bzw. Was würde sich am ehesten anbieten bei meinem Vokabelprogramm ? (SQL,sqlite..) Oder ist das Egal was ich mir da anschaue ?


    dateien ist eine möglichkeit.
    die andere ist datenbank, z.b. mysql, sqlite...



    Dateien ???

    Wenn man das ganze in Dateien einspeichert sind das dann nicht Datenbänke ?

    Oder ist das etwas anderes ?

    Nochmals vielen Dank für die Antwort !

    LG Philip
  • schau dir das hier an
    openbook.galileocomputing.de/j…82-4544-99ee-43299a6d0bb2

    welche db du nimmst, ist es eigentlich egal, musst du entscheiden was du alles brauchst. sqlite ist klein und leich übertragbar.
    mysql ist schon grösser und benötigt ein mysql server, aber bietet auch mehr möglichkeiten und funktionalität.

    die datenbanken basieren auch auf dateien, die daten werden ja letztendlich auch auf der platte abgespeichert. lies dich aber erst mal im thema ein, dann sind schon mal viele fragen weg.
    MfG ShureG

    There are 10 kinds of people. Those who understand binary notation, and those who do not.