Digitaluhr nach Systemzeit

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

  • Digitaluhr nach Systemzeit

    hiho
    ich hab ein problem mit der systemzeit. also mein vorhaben ist folgendes:
    ich habe eine digitale uhr, die im moment nur als counter funktoiniert. jetzt will ich die aber zu ner uhr umfunktionieren, die nach der systemzeit läuft.
    jetzt weiß ich aber nicht, wie ich an die einzelnen werte der uhrzeit kommen soll, weil ich für jede ziffer die zahl extra einstellen muss.
    an das aktuelle datum komm ich ja durch

    Quellcode

    1. Date date = new Date();

    mit den (leider als deprecated markierten) methoden

    Quellcode

    1. date.getHours();date.getMinutes();date.getSeconds();

    komm ich an den aktuellen stunden, minuten und sekundenwert dran.
    jetzt muss ich es allerdings schaffen, jede ziffer einzeln zu bekommen.
    wenn die uhrzeit z.b. 23:43:21 ist, brauche ich die stunden nicht als 23, sondern als 2 und 3.
    meine idee war, die zahlen einfach in einen string zu packen, so dass ich jeden wert einzeln durch

    Quellcode

    1. string.charAt(int position);

    hohlen kann.
    aber wie soll ich int in string konvertieren?!? ich bekomm dann immer fehlermeldungen wie icompatible types und dass das nicht konvertierbar ist -.-
    kann mir wer weiterhelfen, oder ne bessere möglichkeit finden? der code der uhr ist dabei (die klasse Segment7 ist eig unwichtig, nur der vollständigkeit halber)

    Quellcode

    1. package PingPong;
    4. import javax.swing.*;
    5. import java.awt.event.*;
    6. import java.awt.*;
    9. /**
    10. * Write a description of class Clock here.
    11. *
    12. * @author (your name)
    13. * @version (a version number or a date)
    14. */
    15. public class Clock{
    18. public Thread th;
    19. public JPanel panel;
    20. public Segment7 ss1;
    21. public Segment7 ss2;
    22. public Segment7 sm1;
    23. public Segment7 sm2;
    24. public Segment7 sh1;
    25. public Segment7 sh2;
    28. public Clock(){
    30. }
    33. public JPanel fill(){
    34. panel = new JPanel();
    36. panel.setLayout(new FlowLayout(FlowLayout.CENTER));
    38. sh2 = new Segment7();
    39. panel.add(sh2);
    40. sh1 = new Segment7();
    41. panel.add(sh1);
    43. panel.add(new Panel());
    45. sm2 = new Segment7();
    46. panel.add(sm2);
    47. sm1 = new Segment7();
    48. panel.add(sm1);
    50. panel.add(new Panel());
    52. ss2 = new Segment7();
    53. panel.add(ss2);
    54. ss1 = new Segment7();
    55. panel.add(ss1);
    57. return panel;
    58. }
    61. public void count(){
    62. while(true){
    64. if(sh1.getValue() == 9){
    65. sh2.setValue(sh2.getValue() + 1);
    66. }
    67. if(ss1.getValue() == 9){
    68. if(ss2.getValue() == 5){
    69. if(sm1.getValue() == 9){
    70. if(sm2.getValue() == 5){
    71. sh1.setValue(sh1.getValue() + 1);
    72. sm2.setValue(0);
    73. sm1.setValue(0);
    74. ss2.setValue(0);
    75. ss1.setValue(0);
    76. sleep(1000);
    77. }
    78. }
    79. }
    80. }
    83. if(sm1.getValue() == 9){
    84. sm2.setValue(sm2.getValue() + 1);
    85. }
    86. if(ss1.getValue() == 9){
    87. if(ss2.getValue() == 5){
    88. sm1.setValue(sm1.getValue() + 1);
    89. ss2.setValue(0);
    90. ss1.setValue(0);
    91. sleep(1000);
    92. }
    93. }
    96. if(ss1.getValue() == 9){
    97. ss2.setValue(ss2.getValue() + 1);
    98. }
    99. ss1.setValue(ss1.getValue() + 1);
    101. sleep(1000);
    103. }
    104. }
    107. private void sleep(int millis){
    108. try{
    109. Thread.sleep(millis);
    110. }
    111. catch(InterruptedException e){
    112. System.err.println(e.toString());
    113. }
    114. }
    116. public void start(){
    117. th = new Thread(new ClockRunnable());
    118. th.start();
    119. }
    122. public static void main(String[] args){
    123. JFrame f = new JFrame("Clock");
    124. Container c = f.getContentPane();
    125. Clock cl = new Clock();
    126. c.add(cl.fill());
    127. f.pack();
    128. f.setVisible(true);
    129. cl.start();
    131. }
    136. class ClockRunnable implements Runnable{
    138. public void run(){
    139. count();
    140. }
    142. }
    146. }
    152. /**
    153. *
    154. *
    155. * @author JavaBook 33.2
    156. * @version 1.1
    157. */
    159. class Segment7 extends Canvas{
    160. private int digit;
    161. private boolean hasfocus;
    162. private int[][] polysx = {
    163. { 1, 2, 8, 9, 8, 2}, //Segment 0
    164. { 9,10,10, 9, 8, 8}, //Segment 1
    165. { 9,10,10, 9, 8, 8}, //Segment 2
    166. { 1, 2, 8, 9, 8, 2}, //Segment 3
    167. { 1, 2, 2, 1, 0, 0}, //Segment 4
    168. { 1, 2, 2, 1, 0, 0}, //Segment 5
    169. { 1, 2, 8, 9, 8, 2}, //Segment 6
    170. };
    171. private int[][] polysy = {
    172. { 1, 0, 0, 1, 2, 2}, //Segment 0
    173. { 1, 2, 8, 9, 8, 2}, //Segment 1
    174. { 9,10,16,17,16,10}, //Segment 2
    175. {17,16,16,17,18,18}, //Segment 3
    176. { 9,10,16,17,16,10}, //Segment 4
    177. { 1, 2, 8, 9, 8, 2}, //Segment 5
    178. { 9, 8, 8, 9,10,10}, //Segment 6
    179. };
    180. private int[][] digits = {
    181. {1,1,1,1,1,1,0}, //Ziffer 0
    182. {0,1,1,0,0,0,0}, //Ziffer 1
    183. {1,1,0,1,1,0,1}, //Ziffer 2
    184. {1,1,1,1,0,0,1}, //Ziffer 3
    185. {0,1,1,0,0,1,1}, //Ziffer 4
    186. {1,0,1,1,0,1,1}, //Ziffer 5
    187. {1,0,1,1,1,1,1}, //Ziffer 6
    188. {1,1,1,0,0,0,0}, //Ziffer 7
    189. {1,1,1,1,1,1,1}, //Ziffer 8
    190. {1,1,1,1,0,1,1} //Ziffer 9
    191. };
    193. public Segment7()
    194. {
    195. this(0);
    196. }
    198. public Segment7(int digit)
    199. {
    200. super();
    201. this.digit = digit;
    202. this.hasfocus = false;
    203. }
    205. public Dimension getPreferredSize()
    206. {
    207. return new Dimension(5*10,5*18);
    208. }
    210. public Dimension getMaximumSize()
    211. {
    212. return new Dimension(5*10,5*18);
    213. }
    215. public Dimension getMinimumSize()
    216. {
    217. return new Dimension(1*10,1*18);
    218. }
    220. public void paint(Graphics g)
    221. {
    222. Color darkblue = new Color(0,0,100);
    223. Color lightblue = new Color(0,0,255);
    224. //dx und dy berechnen
    225. int dx = getSize().width / 10;
    226. int dy = getSize().height / 18;
    227. //Hintergrund
    228. g.setColor(darkblue);
    229. g.fillRect(0,0,getSize().width,getSize().height);
    230. //Segmente
    231. g.setColor(lightblue);
    232. for (int i=0; i < 7; ++i) { //alle Segmente
    233. if (digits[digit][i] == 1) {
    234. Polygon poly = new Polygon();
    235. for (int j = 0; j < 6; ++j) { //alle Eckpunkte
    236. poly.addPoint(dx*polysx[i][j],dy*polysy[i][j]);
    237. }
    238. g.fillPolygon(poly);
    239. }
    240. }
    241. //Trennlinien
    242. g.setColor(darkblue);
    243. g.drawLine(0,0,dx*10,dy*10);
    244. g.drawLine(0,8*dy,10*dx,18*dy);
    245. g.drawLine(0,10*dy,10*dx,0);
    246. g.drawLine(0,18*dy,10*dx,8*dy);
    247. }
    249. public int getValue()
    250. {
    251. return digit;
    252. }
    254. public void setValue(int value)
    255. {
    256. digit = value % 10;
    257. repaint();
    258. }
    260. }
    Alles anzeigen
    contest
    -- Ein Wettnewerb für Jugendliche Programmierer --
    Jeder Helfer ist willkommen ;)

  • also erstmal: Die Date-Methoden sind deprecated markiert, da man stattdessen die Calendar Klasse verwenden soll:

    Quellcode

    1. Calendar jetzt = GregorianCalendar.getInstance();

    und dann zugriff mit

    Quellcode

    1. jetzt.get(Calendar.HOUR_OF_DAY);
    2. jetzt.get(Calendar.MINUTE);

    usw.

    Und wie du an die einzlnen Ziffern einer Zahl kommst?

    Quellcode

    1. int zehner = zahl / 10;
    2. int einer = zahl % 10;

    gilt natürlich nur für Zahlen bis 100, aber das sollte bei Zeitangaben kein Problem darstellen ;)

  • hi
    jo danke, ich hab das jetzt entsprechend geändert und alles klappt. uhr läuft jetzt nach systemzeit, und das sogar ziemlich genau ;)
    aber bei so vielen if-verschachtelungen verliert man irgendwann den durchblick :(
    kann man das vllt auch einfacher machen? weil ich noch 3 dazu machen musste...
    mfg
    contest
    -- Ein Wettnewerb für Jugendliche Programmierer --
    Jeder Helfer ist willkommen ;)

  • Irgendwas schein ich falsch zu machen, ich brauch kein einziges if ;)

    Quellcode

    1. public void count()
    2. {
    3. while (true)
    4. {
    5. Calendar cal = GregorianCalendar.getInstance(Locale.getDefault());
    7. int h1 = cal.get(Calendar.HOUR_OF_DAY)%10;
    8. int h2 = cal.get(Calendar.HOUR_OF_DAY)/10;
    10. sh1.setValue(h1);
    11. sh2.setValue(h2);
    13. int m1 = cal.get(Calendar.MINUTE)%10;
    14. int m2 = cal.get(Calendar.MINUTE)/10;
    16. sm1.setValue(m1);
    17. sm2.setValue(m2);
    19. int s1 = cal.get(Calendar.SECOND)%10;
    20. int s2 = cal.get(Calendar.SECOND)/10;
    22. ss1.setValue(s1);
    23. ss2.setValue(s2);
    25. sleep(1000);
    27. }
    28. }
    Alles anzeigen


    schöne Grüße aus München

  • hm nagut, das is auch ne lösung :)
    habs mal reingebastelt und funktioniert einwandfrei^^
    jetzt muss ich das nur noch so machen, dass man beides verwenden kann, dann kann ich die uhr wahlweise auch als counter nutzen ;)
    kannste mir da vllt ein tipp geben, wie man das am einfachsten macht? ;)

    für beide arten von "zählen" ne methode oder wie? hab dazu ne variable systemTime eingebaut. wenn die true ist, wird nach systemzeit gezählt, wenn sie false ist, dient das ganze als stoppuhr.

    Quellcode

    1. import javax.swing.*;
    2. import java.awt.event.*;
    3. import java.awt.*;
    4. import java.util.*;
    7. /**
    8.  * Write a description of class Clock here.
    9.  * 
    10.  * @author (your name) 
    11.  * @version (a version number or a date)
    12.  */
    13. public class Clock{
    16.   public Thread th;
    17.   public JPanel panel;
    18.   public Segment7 ss1;
    19.   public Segment7 ss2;
    20.   public Segment7 sm1;
    21.   public Segment7 sm2;
    22.   public Segment7 sh1;
    23.   public Segment7 sh2;
    24.   private boolean systemTime;
    25.    
    26.    
    27.   public Clock(boolean systemTime){
    28.   this.systemTime = systemTime;
    29.   }
    30.    
    31.    
    32.   public JPanel fill(){
    33.   panel = new JPanel();
    34.    
    35.   panel.setLayout(new FlowLayout(FlowLayout.CENTER));
    36.    
    37.   sh2 = new Segment7(2);
    38.   panel.add(sh2);
    39.   sh1 = new Segment7(4);
    40.   panel.add(sh1);
    41.    
    42.   panel.add(new Panel());
    43.    
    44.   sm2 = new Segment7(5);
    45.   panel.add(sm2);
    46.   sm1 = new Segment7(9);
    47.   panel.add(sm1);
    48.    
    49.   panel.add(new Panel());
    50.    
    51.   ss2 = new Segment7(3);
    52.   panel.add(ss2);
    53.   ss1 = new Segment7(5);
    54.   panel.add(ss1);
    55.    
    56.   return panel;
    57.   }
    58.    
    59.    
    60.   public void tick(){
    61.    
    62.   while(systemTime == false){
    63.    
    64.   if(ss1.getValue() == 9){
    65.   if(ss2.getValue() == 5){
    66.   if(sm1.getValue() == 9){
    67.   if(sm2.getValue() == 5){
    68.   if(sh1.getValue() == 9){
    69.   sh2.setValue(sh2.getValue() + 1);
    70.   sh1.setValue(0);
    71.   sm2.setValue(0);
    72.   sm1.setValue(0);
    73.   ss2.setValue(0);
    74.   ss1.setValue(0);
    75.   sleep(1000);
    76.   }
    77.   }
    78.   }
    79.   }
    80.   }
    81.   if(ss1.getValue() == 9){
    82.   if(ss2.getValue() == 5){
    83.   if(sm1.getValue() == 9){
    84.   if(sm2.getValue() == 5){
    85.   sh1.setValue(sh1.getValue() + 1);
    86.   sm2.setValue(0);
    87.   sm1.setValue(0);
    88.   ss2.setValue(0);
    89.   ss1.setValue(0);
    90.   sleep(1000);
    91.   }
    92.   }
    93.   }
    94.   }
    95.    
    96.    
    97.   if(sm1.getValue() == 9){
    98.   if(ss2.getValue() == 5){
    99.   if(ss1.getValue() == 9){
    100.   sm2.setValue(sm2.getValue() + 1);
    101.   sm1.setValue(0);
    102.   ss2.setValue(0);
    103.   ss1.setValue(0);
    104.   sleep(1000);
    105.   }
    106.   }
    107.   }
    108.   if(ss1.getValue() == 9){
    109.   if(ss2.getValue() == 5){
    110.   sm1.setValue(sm1.getValue() + 1);
    111.   ss2.setValue(0);
    112.   ss1.setValue(0);
    113.   sleep(1000);
    114.   }
    115.   }
    116.    
    117.    
    118.   if(ss1.getValue() == 9){
    119.   ss2.setValue(ss2.getValue() + 1);
    120.   }
    121.   ss1.setValue(ss1.getValue() + 1);
    122.    
    123.   sleep(1000);
    124.    
    125.   }
    126.    
    127.    
    128.    
    129.   while(systemTime){
    130.   Calendar cal = GregorianCalendar.getInstance(Locale.getDefault());
    131.  
    132.   int h1 = cal.get(Calendar.HOUR_OF_DAY)%10;
    133.   int h2 = cal.get(Calendar.HOUR_OF_DAY)/10;
    134.    
    135.   sh1.setValue(h1);
    136.   sh2.setValue(h2);
    137.  
    138.   int m1 = cal.get(Calendar.MINUTE)%10;
    139.   int m2 = cal.get(Calendar.MINUTE)/10;
    140.  
    141.   sm1.setValue(m1);
    142.   sm2.setValue(m2);
    143.  
    144.   int s1 = cal.get(Calendar.SECOND)%10;
    145.   int s2 = cal.get(Calendar.SECOND)/10;
    146.  
    147.   ss1.setValue(s1);
    148.   ss2.setValue(s2);
    149.  
    150.   sleep(1000);
    151.   }
    152.    
    153.    
    154.    
    155.   }
    156.    
    157.    
    158.   private void sleep(int millis){
    159.   try{
    160.   Thread.sleep(millis);
    161.   }
    162.   catch(InterruptedException e){
    163.   System.err.println(e.toString());
    164.   }
    165.   }
    166.    
    167.   public void start(){
    168.   th = new Thread(new ClockRunnable());
    169.   th.start();
    170.   }
    171.    
    172.    
    173.   public void stop(){
    174.   th.interrupt();
    175.   }
    176.    
    177.    
    178.   public static void main(String[] args){
    179.   JFrame f = new JFrame("Clock");
    180.   Container c = f.getContentPane();
    181.   Clock cl = new Clock(true);
    182.   c.add(cl.fill());
    183.   f.pack();
    184.   f.setVisible(true);
    185.   cl.start();
    186.    
    187.   }
    188. }
    Alles anzeigen


    mfg
    contest
    -- Ein Wettnewerb für Jugendliche Programmierer --
    Jeder Helfer ist willkommen ;)

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von DarthMaul ()

  • Klar kann ich dir da auch helfen. Machen wir mal wieder eine kleine Nachhilfestunde hier in Sachen Software-Design. Zerlegen wir mal dein Problem logisch. Also du willst deine Uhr die du gleichzeitig auch als Counter verwenden willst, die Darstellung soll gleich bleiben, aber die Logik soll änderbar sein. Ok dann bauen wir eine Komponente, die nur die Darstellung übernimmt. Dazu nehmen wir einfach deine Klasse Clock.

    So ganz in Ordnung ist sie zwar auch nicht, aber für unsere Zwecke reichts aus und wenn ich den Rest noch verbessern würde, führt das an dieser Stelle zu weit.

    Als erstes schmeiß mal den Thread und die beiden Methode die die Logik zum Zeitberechnen verwenden raus. Dafür kommt eine Methode setValues(int hours, int minutes, int seconds) rein.

    Quellcode

    1. public void setValues(int hours, int minutes, int seconds)
    2. {
    3. sh1.setValue(hours % 10);
    4. sh2.setValue(hours/10);
    6. sm1.setValue(minutes % 10);
    7. sm2.setValue(minutes/10);
    9. ss1.setValue(seconds % 10);
    10. ss2.setValue(seconds/10);
    11. }
    Alles anzeigen


    Soweit so gut, jetzt nimmt Clock irgendwelche Werte entgegen und stellt sie dar aber es ist ihr egal welche Werte das sind. Natürlich brauchen wir jetzt zwei Klassen für die Logik, einmal als Uhr und einmal als Counter.

    Zuerst mal die Uhr:

    Quellcode

    1. public class Uhr implements Runable
    2. {
    3. private Clock clock;
    5. public Uhr(Clock clock)
    6. {
    7. this.clock = clock;
    8. }
    10. public void run()
    11. {
    12. while(true)
    13. {
    14. Calendar cal = GregorianCalendar.getInstance();
    15. clock.setValues(cal.get(Calendar.HOUR_OF_DAY),cal.get(Calendar.MINUTE),cal.get(Calendar.SECOND));
    16. Thread.sleep(1000);
    17. }
    18. }
    19. }
    Alles anzeigen


    Ich verkürz den Code ein bisschen ist schon spät aber das Grundprinzip sollte klar werden. Als nächstes bauen wir den Counter:

    Quellcode

    1. public class Counter implements Runable
    2. {
    3. private Clock clock;
    4. private int seconds=0;
    6. public Counter(Clock clock)
    7. {
    8. this.clock = clock;
    9. }
    11. public void run()
    12. {
    13. while(true)
    14. {
    16. int s = seconds % 60;
    17. int h = seconds/(60*60);
    18. int m = seconds/60-h*60;
    20. clock.setValues(h,m,s);
    21. seconds++;
    22. Thread.sleep(1000);
    23. }
    24. }
    25. }
    Alles anzeigen


    Die Berechnung müsste stimmen aber da bin ich mir nicht 100% sicher, aber das ist ja auch nicht das Thema.

    So als letztes zur Verwendung des ganzen:

    Quellcode

    1. public class Test
    2. {
    3. public static void main(String[] args)
    4. {
    5. JFrame frame = new JFrame();
    6. Clock c1 = new Clock();
    7. Clock c2 = new Clock();
    9. JPanel cp1 = c1.fill();
    10. JPanel cp2 = c2.fill();
    12. frame.add(cp1, BorderLayout.NORTH);
    13. frame.add(cp2, BorderLayout.SOUTH);
    15. frame.pack();
    17. Thread uhrenThread = new Thread(new Uhr(c1));
    18. Thread counterThread = new Thread(new Counter(c2));
    20. uhrenThread.start();
    21. counterThread.start();
    23. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    24. frame.setVisible(true);
    25. }
    26. }
    Alles anzeigen


    Jetzt sind wir damit fertig. Das ganze läuft unter dem Begriff "Seperation of concerns" zu deutsch so viel wie Trennung von Zuständigkeit.

    Ich arbeite eigentlich immer so, dass ich mir zuerst überlege welche Beteiligte es bei einem Problem geben könnte, dabei denk ich eigentlich noch nicht mal in Klassen sondern stell mir vor, welche Aufgaben es gibt um ein Problem zu lösen und wie man dieses geschickt aufteilen könnte. Wenn der Schritt getan ist, ist der Rest dann relativ einfach; zuerst überleg ich wie die Teile sich gegenseitig verwenden und zwar sollten diese Berührungspunkte so schlank wie möglich sein. In dem Fall wäre es ungeschickt eine setHours(int h) setMinutes(int m) setSeconds(int s) zu machen, weil die Methoden eh immer in der gleichen Reihenfolge aufgerufen werden würden, also fass ich sie gleich zusammen.
    Der Rest ist reine Programmierarbeit und ab da recht unspannend. Dennoch ist es der wichtigste Teil des Ganzen: 1. Werd ich für das Ergebnis bezahlt und 2. macht es einen stolz wenn man sieht, dass das was man sich überlegt hat auch funktioniert.

    so genug für heute.
    mfg

  • wow cool^^
    vielen dank erst mal für die mühe :)
    das ist genau das, was wir in der schule immer nicht machen. da lernen wir alles mögliche an methoden und so, aber wie man hinterher sowas plant und konzipiert, ham wir so noch nie besprochen.
    einbauen werd ich da allerdings erst heut abend oder so, weil ich mittags weg bin ;)
    mfg
    contest
    -- Ein Wettnewerb für Jugendliche Programmierer --
    Jeder Helfer ist willkommen ;)

  • Naja es ist auch irgendwie verständlich, dass dein Lehrer dir "nur" die Methoden beibringt, ich will ja nicht kritisieren und ich weiß auch nicht auf welche Schule du gehst, aber ich geh mal davon aus, dass dein Lehrer selbst auch noch nicht professionell Software entwickelt hat. Das Ganze hat sehr viel mit Erfahrung zu tun und solche Sachen hab ich auch erst durch mein Studium gelernt. Richtig Gedanken darüber hab ich mir erst bei meiner Diplomarbeit gemacht. Aber seh es einfach so, du lernst jetzt in der Schule den Werkzeugkasten kennen, ein Bild wirst du auch nicht aufhängen können wenn dir keiner erklärt hat wie ein Hammer funktioniert.

    Aber eins ist mir noch aufgefallen. Die stop-Methode in deiner Uhr wird deine Uhr nicht stoppen. Thread#stop() ist zu Recht deprecated aber interrupt führt dich nicht zum Ziel. Interrupt holt Threads zurück die schlafen oder in einem wait-Block stecken aber stopt sie nicht. Es gibt einen Spruch dazu. "Threads sollten nicht gekillt, sondern in den Selbstmord getrieben werden."

    Das geht so: definiere eine boolean-Variable in deinem Runnable die true ist. Die Schleife die läuft lautet nicht mehr while(true) sondern prüft auf diese Variable. Dein Runnable bekommt noch eine Methode stop in der deine Variable auf false gesetzt wird.

    Quellcode

    1. public class Uhr implements Runnable
    2. {
    3. private boolean laeuft = true; //deine Variable zum stoppen
    4. ...
    5. public Uhr(Clock c)
    6. {
    7. ....
    8. }
    10. public void run()
    11. {
    12. while(laeuft) //hier wird geschaut ob die Uhr noch läuft
    13. {
    14. ...
    15. }
    16. }
    18. public void stop()
    19. {
    20. laeuft = false; //jetzt hört die Uhr auf zu laufen
    21. }
    22. }
    Alles anzeigen


    So ich hoffe du kommst nun zu deinem Ziel.

    mfg

  • ziel erreicht ;) noch mals danke.
    ja ok dass unsere lehrerein nicht professionell programmiert und deshalb nicht perfekt ist nehmich ihr auch nicht übel. aber sie will uns immer unterstützen (meinen freund und mich), weil wir den werkzeugkasten etwas besser kennen als die anderen :p nur wäre es halt schön wenn wir in solchen sachen unterstützung bekommen würden.
    aber jetzt klappt ja alles^^
    mfg
    contest
    -- Ein Wettnewerb für Jugendliche Programmierer --
    Jeder Helfer ist willkommen ;)