Threads SuM Class Animation

[Gerrit123]

Hallo,

ich wollte mal fragen ob sich hier jemand mit den Bibliotheken
Stifte und Mäuse auskennt oder die Doku zur Klasse Animation versteht.
Und mir damit etwas weiter helfen kann.

Meine frage wäre, wie genau muss man den Abstrakten Dienst "zeichne()"
aus der Klasse Animation implementieren, damit der Zeichenvorgang wie
in der Doku beschrieben, immer wieder aufgerufen wird und wo
kann man beschrieben, was genau neugezeichnet werden soll?
Sehr verwirrende Doku, da ist sogar die auf deutsch übersetzte MSDN von MS einfacher zu verstehen.

Ich habe einfach mal die Duku Seite (HTML Datei) der Klasse Animation angehängt.
SuM-BlueJ-Doku-Paket kann man sich hier herunter laden: http://www.mg-werl.de/sum/bjw.zip

Vielen Dank
Gruß Gerrit

 

[Spacerat]

SUM (und Vergleichbares) ist mehr oder weniger Java für den Kindergarten oder Leuten, die nur Deutsch verstehen oder besser gesagt, SUM hat keinen didaktischen Nährwert. Im Gegenteil, es umgeht auch noch die Notwendigkeit sich Grundlagen anzueignen, z.B. Grundlagen über Threads und WTs (WindowToolkits - Swing, SWT, AWT). Stattdessen eignet man sich Abarten an, die man besser schnell wieder vergessen sollte. Und dann ist SUM auch noch so mager dokumentiert? Dann tu dir selbst einen gefallen und studiere entsprechende Kapitel der Insel oder Guido Krüger.

Ich denke mal nicht, dass du selber kaum etwas für deine Misere SUM lernen zu müssen kannst, weil die in 99% aller Fälle von Möchtegern-Dozenten ausgeht, die kaum wissen, warum SUM der falsche Weg ist, jemandem Java beibringen zu wollen. Also, nichts gegen dich, aber entschieden gegen diese SUM-Blendwerke.

Animationen jedenfalls sind auch ohne SUM recht simpel.
Guido Krger - JAVA 1.1 lernen - Kapitel 24 Animation

 

[Gerrit123]

Ja, das dachte ich mir schon als ich mir SuM zum ersten mal angesehen habe bzw. die Doku dazu.
Nur bin ich leider gezwunden, die Aufgabe mit der Klasse aus der Bibliothek zu lösen.
Ich hab hab schon ein verstandnis von Threads und Klassen, doch mit der beschreibung in der
Doku komm ich nicht weit.

Was ich mir vostellen kann ist, das Animation einen neuen Thread erstellt, mit einer schleife
die das zeichnen aufruft und dann eine gewisse Zeit wartet. Nur ob das jetzt stimmt weiß ich
noch nicht wirklich, weil ich einfach keine weiteren infos finden kann.

Auch nirgends findet man
Beispiel Code dazu, was Spacerat ja nur bestätigt, Müll sollte nicht weiter verbreitet werden.
Nur blöd wenn man so zu sagen dazu gezwungen wird, den Müll zu verwenden, nur weil der Lehrer
zu faul ist, ordenliches/richtiges evtl. eigenes Unterrichtsmaterial zu erstellen/sich anzueignen.

Danke für den Link. ist Interessant und gut verständlich.
Nur hilft es mir in dieser Situation nicht viel.

 

[Spacerat]

Also wenn du so willst, kannst du "zeichne()" getrost fast wie eine normale "run()"-Methode eines Threads implementieren. Leider weis auch ich nicht, an welche Bedingungen ihr Aufruf bereits durch "<Animation>.run()" geknüpft ist (z.B. "while(!isInterruptetd())" und "Thread.sleep()").
Nun weis ich auch kaum, wo man was in SUM zeichnet, iwie benötigt man dazu ja einen Graphics-Kontext.
Evtl. hat's ja irgendwo 'ne "paint(Graphics g)"-Methode, in diesem Fall würde ich in "zeichne()" schlicht "repaint()" (wie gewohnt XD) aufrufen.

 

[Gerrit123]

Das mit dem Graphics-Kontext/Objekt ist auch so eine sache.
Da blinkt man einfach nur schlecht durch, weil die ganzen Sum Klassen
alle von von anderen Sum Klassen erben die widerum sonstwas geerbt haben.
All diese Klassen sind in der Doku genauso schlecht beschrieben wie die Klasse Animation.

Gegeben war: Eine eigene Klasse (.java) namens "Animation" welche von EBAnwendung erbt.
EBAnwendung (SuM Klasse) erbt selber von Ereignisanwendung (SuM Klasse) welche wohl das
Fenster bereitstellt.

Ereignisanwendung besitzt den void "bearbeiteUpdate()" (Das Fenster wird neu gezeichnet.)
Somit könnte man mit der eigenen Klasse "Animation" auch "bearbeiteUpdate()" aufrufen
welches das Fenster zum neu zeichenen zwingt (aber Komplett? das kann doch nicht richtig sein).

Um das ganze richtig verwirrent zu machen, gibt es dann noch die Klasse "Animation" als SuM Klasse.
Jene beschreibung aus der Doku ich oben angehängt habe.

Die gegebene eigene Klasse "Animation" sieht so aus:

import sum.ereignis.*;
import sum.komponenten.*;
import sum.werkzeuge.*;

public class Animation extends EBAnwendung
{

    private Apfel apfel;

public Animation()
    {
    super(800,600); // Das fenster erzeugen (aus EBAnwendung bzw. Ereignisanwendung)
    Apfel = new Apfel ();
    }

public void fuehreAus()
    {
    Apfel.zeichne()
    }
}

//-----------------------------------------------------

public class Apfel
{
public Apfel()
    {
        // Instanzvariable initialisieren
        Koerper = new Koerper();
        Blatt = new Blatt();
    }
public void zeichne()
    {
        Koerper.zeichne();
        Blatt.zeichne();
    }
}

//---------------------------------------------------------

Klasse Körper und Blatt beinhalten dan die eigentlich Paint Methode:

public void zeichne()
    {
        // tragen Sie hier den Code ein
        stift.bewegeBis(300,200); //Legt so zu sagen den Ursprung fest (Ja verFailt ...)
        stift.zeichneKreis(60); // ...
    }

Nur wie das mit dem neuzeichenen in der (SuM Klasse) "Animation" gemeint ist, verstehe ich nicht.
Diese höllen Doku, es ist zum Haare ausreißen

 

[Spacerat]

Das ist ja zum auswachsen...
Solche Dinger in anderen Fächern und das Abschneiden der Deutschen in der Pisa-Studie wäre kein Wunder.
Gibt es eigentlich keine Elternvereinigungen mehr, die man auf diese (ich nenn es mal) lari-fari Javaausbildung mittels SuM nicht aufmerksam machen kann? Das einzige, was man mit diesem Kindergartenzeugs lernt, ist offensichtlich Frust. Ehrlich gesagt, würde ich jetzt reihenweise sechsen riskieren, es schlicht drauf ankommen lassen und dem Dozenten bzw. Lehrer schon allein damit, dass er überhaupt SuM (oder ähnliches) in Erwägung zieht, sein Unvermögen bescheinigen, jemandem vernünftig Java beibringen zu wollen. Ganz nebenbei dann evtl. noch die Aufgabe mit ganz "normalen" Java-SE Klassen lösen, dann hat die Fakultät in dieser Beziehung keine echten Chancen mehr.
Ist zwar jetzt auch nicht die Lösung für dein spezielles Animationsproblem, aber wenigstens eine, die diese cerebrale Diarhoe hoffentlich vom Lehrplan verschwinden lässt.
Um dein spezielles Problem in Augenschein zu nehmen, hilft's vllt., wenn du den ganzen Kram mal in ein Zip packst und hier postest.
[EDIT]Ich hab' die SuM-Animation mal durch 'nen decompiler gejagt aber unheimlich aufschlussreich ist das auch nicht. Eigentlich bestätigt der Quelltext nur das, was ich bereits ahnte ("zeichne()" entspricht "repaint()").

package sum.werkzeuge;

import java.io.Serializable;

public abstract class Animation extends Thread
  implements Serializable
{
  private boolean zAngehalten = false;

  public void run()
  {
    while (!zAngehalten)
    {
      try
      {
        zeichne();
        sleep(30L);
      }
      catch (InterruptedException e)
      {
      }
    }
  }

  public abstract void zeichne();

  public void gibFrei()
  {
    zAngehalten = true;
  }
}

...und btw: "gibFrei()"? was bitte wird denn da freigegeben? :lol: Den Sch... schau ich mir, glaub' ich, mal näher an. Kann ja nicht angehen, dass Lernsoftware potentiellen Entwicklern die "Birne" versaut. Es gibt weis Gott nicht viel, was den Mangel an didaktischen Nährwert noch toppen könnte, aber die Verbreitung ausgemachten Schwachsinns gehört definitiv dazu.[/EDIT]

 

[Gerrit123]

Erst einmal viele dank für deine außerordenliche Hilfe.
Das mit dem decompilieren war eine gute Idee.
Nun weiß man etwas mehr.

Das mit dem Beispielprojekt kann ich morgen (bzw. heute) in angriff nehmen.
Ich glaube zu diesem zeitpunkt bekomm ich das nicht mehr ganz auf die Kette ^^

Gute Nacht

 

[Gerrit123]

So ich glaube ich habe es jetzt verstanden wie das gnaze vom Lehrer gemeint war.
Und zwar denke ich, das die eigene Klasse (nicht abstrakt) als "Main" Klasse dienen soll.
Ja ich weiß, Main ohne Main? Es wird geforder BlueJ zu benutzen (wieder so ein Ding), womit
es einem möglich ist, eine instanz zu erstellen/aus zu führen, ohne das man einen "Einstiegspunkt" benötigt.

Das ganze läuft dann so ab, das die Klasse Animation von EBanwendung erbt und das Fenster bereitstellt.
Das mit der SuM-Klasse Animation ist ja so, das diese Klasse abstrakt ist, die Methode zeichne() bereitstellt,
und einen Thread bereistellt (muss das mit dem Thread in JAVA nochmal nachschlagen).

[Wichtigerer Teil ^^]

Nur wie genau sollte ich das mit dem erben, von der Strucktur her am besten aufbauen?

Jedes zu zeichnende Objekt (Beispiel -> Apfel = Rumpf und Blatt) von SuM-Animation erben lassen, was widerum
bedeuten würde, dass mehrere Threads erstellt werden würden, welche dann jeweils "zeichne()" des jeweiligen
Objektes aufrufen (rendundant?) oder das anders anstelle, dass ich nur einen Thread aus der abstrakten Klasse Animation brauche.

Nur ist mir noch nicht eingefallen wie ich das anstelle, hätte da jemand einen Vorschlag?

Gruß Gerrit
PS: Sorry für die komischen Satzbau/Formulierung
Edit: verdammt Doppelpost : /

 

[Marco13]

Nur überflogen (ich gehe davon aus dass Spacerat sich noch genauer darum kümmert) aber für mich sieht das aus, als sollte es sowas geben wie

public class Animation extends WasAuchImmer
{
    // Eine Liste von Äpfeln (eigentlich: Objekte, die 
    // eine "zeichne" Methode haben - schau' mal ob
    // die vielleicht in einem Interface definiert ist)
    private List<Apfel> apfels = new ArrayList<Apfel>();
 
    public Animation()
    {
        apfels.add(new Apfel ());
    }
 
    public void fuehreAus()
    {
        // Zeichne alle Äpfel
        for (Apfel apfel : apfels)
        {
            apfel.zeichne()
        }
    }
}

Ist aber ohne Gewähr

BTW: Ich glaube, dass sowas wie SuM schon sinnvoll sein kann - so für die Mittelstufe, wo's ggf. das Englisch nocht nicht ganz so robust ist, und auch viele Schüler zumindest irgendwas mit "Grafik" brauchen, damit der GameBoy Portable, die PSP und das Smartphone mit 'Angry Birds' nicht den Kampf gegen den Unterrichtsstoff gewinnen....

 

[Spacerat]

BTW: Ich glaube, dass sowas wie SuM schon sinnvoll sein kann - so für die Mittelstufe, wo's ggf. das Englisch nocht nicht ganz so robust ist, und auch viele Schüler zumindest irgendwas mit "Grafik" brauchen, damit der GameBoy Portable, die PSP und das Smartphone mit 'Angry Birds' nicht den Kampf gegen den Unterrichtsstoff gewinnen....

Okay... von diesem Standpunkt her hast du recht. Aber zumindest sollte man es dann weder nur kostenpflichtig dokumentieren, noch es nur für eine IDE (BlueJ) propagieren, das riecht zu sehr nach Werbung für sonst unnützes Zeugs. Darüber hinaus sollte man irreführende Konstrukte wie oben vermeiden.

Also wenn jedes Objekt eine Methode "zeichne()" hat, müsstet du doch eigentlich im Animationszyklus nur diese Methoden der Reihe nach aufrufen, ggf noch mit 'nem einleitenden "bewege()". Dazu würde dann auch eine Animationsklasse genügen indem man dort Marcos Vorschlag aufgreift.

class MyAnimation extends Animation {
  public void zeichne() {
    for(Apfel a : aepfel) {
      // bewege(a);
      a.zeichne();
    }
  }
}

 

[Gerrit123]

Ah ich sehe gerade das mit dem

class MyAnimation extends Animation {}

Geht ja nicht, weil MyAnimation ja von EBAnwendung erben muss.

Und eine mehrfach vererbung geht in Java ja bekanntlich nur mit einem Interface.
Und da der Lehrer diese nicht einmal angesprochen hat, wird das wohl nicht der richtige weg sein.

Also mir fällt da einfach keine Lösung zu ein:

- Eine Klasse welche von EBanwendung erben muss, damit ein Fenster erstellt wird.
- Es muss irgendwo/irgendwie die abstrakte Klasse Animation geerbt werden, damit
der Thread mit der While-Schleife implementiert wird, der von allen Objekten zeiche() aufruft.

Doch wie soll man das ohne Interfaces unter einem Hut bringen irgendie stimmt das ganze vorne
und hinten nicht. ;(

 

[Spacerat]

Relativ einfach:

class MyAnimation extends EBanwendung {
  private List<Apfel> aepfel = new ArrayList<Apfel>();

  private Animation anim = new Animation() {
    public void zeichne() {
      for(Apfel a : aepfel) {
        bewege(a);
        a.zeichne();
      }
    }
  };

  public MyAnimation() {
    anim.start();
  }

  private void bewege(Apfel a) {
    // was immer zum bewegen notwendig ist
  }
}

... aber lass mich raten... anonyme Klassen hattet ihr auch noch nicht.

 

[Gerrit123]

... aber lass mich raten...

Du hast es erfasst.

Das mit den Inneren Klassen kannte ich so auch noch nicht.
Habe bis jetzt aus dem [c]new[/c] immer herrausgeschlossen, das ein Objekt erzeugt wird.
Doch die Klasse Animation ist ja eig. abstrackt, aber wenn das so läuft auch gut.

Aber wie sich der Lehrer das jetzt genau vorgestellt hat... k.A.
Wie man das ohne Interface & innerer anonymer Klassen lösen soll, ist mir ein Rätzel.

Die Aufgabe wurde über die Ferien aufgegeben, kein Wort zu Interfaces oder iaK.
Einfach nur, nutzt die Klasse Animation!, unfassbar.

 

[Gerrit123]

Da ich nicht mehr Editieren kann, schreibe ich eine neue Antowrt.
Habe nun eine extra Klasse erstellt, die erbt von EB und Erstellt das Objekt Animation welche von Animation erbt.
Alles wird gezeichnet mit nur einem Thread. Danke, Thema ist für mich dann erledigt.